johnandersen777.bsky.social/socialweb-computer-console
console.socialweb.computer: kcp, kubectl and ssh compiled to wasm in a browser tab with a terminal; a kcp fork
0
0
/*
Copyright 2022 The kcp Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package builder
import (
"context"
"fmt"
"slices"
"k8s.io/apiextensions-apiserver/pkg/apis/apiextensions"
apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
structuralschema "k8s.io/apiextensions-apiserver/pkg/apiserver/schema"
"k8s.io/apiextensions-apiserver/pkg/apiserver/validation"
"k8s.io/apiextensions-apiserver/pkg/registry/customresource"
"k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/util/validation/field"
"k8s.io/apiserver/pkg/registry/rest"
"k8s.io/klog/v2"
kcpdynamic "github.com/kcp-dev/client-go/dynamic"
corev1alpha1 "github.com/kcp-dev/sdk/apis/core/v1alpha1"
"github.com/kcp-dev/sdk/apis/tenancy/initialization"
tenancyv1alpha1 "github.com/kcp-dev/sdk/apis/tenancy/v1alpha1"
"github.com/kcp-dev/virtual-workspace-framework/pkg/dynamic/apiserver"
registry "github.com/kcp-dev/virtual-workspace-framework/pkg/forwardingregistry"
)
func initializingWorkspaceRequirements(initializer corev1alpha1.LogicalClusterInitializer) (labels.Requirements, error) {
labelSelector := map[string]string{
tenancyv1alpha1.WorkspacePhaseLabel: string(corev1alpha1.LogicalClusterPhaseInitializing),
}
key, value := initialization.InitializerToLabel(initializer)
labelSelector[key] = value
requirements, selectable := labels.SelectorFromSet(labelSelector).Requirements()
if !selectable {
return nil, fmt.Errorf("unable to create a selector from the provided labels")
}
return requirements, nil
}
func filteredLogicalClusterReadOnlyRestStorage(
ctx context.Context,
clusterClient kcpdynamic.ClusterInterface,
initializer corev1alpha1.LogicalClusterInitializer,
) (apiserver.RestProviderFunc, error) {
requirements, err := initializingWorkspaceRequirements(initializer)
if err != nil {
return nil, err
}
return registry.ProvideReadOnlyRestStorage(
ctx,
func(ctx context.Context) (kcpdynamic.ClusterInterface, error) { return clusterClient, nil },
registry.WithStaticLabelSelector(requirements),
nil,
)
}
func delegatingLogicalClusterReadOnlyRestStorage(
ctx context.Context,
clusterClient kcpdynamic.ClusterInterface,
initializer corev1alpha1.LogicalClusterInitializer,
) (apiserver.RestProviderFunc, error) {
requirements, err := initializingWorkspaceRequirements(initializer)
if err != nil {
return nil, err
}
return func(
resource schema.GroupVersionResource,
kind schema.GroupVersionKind,
listKind schema.GroupVersionKind,
typer runtime.ObjectTyper,
tableConvertor rest.TableConvertor,
namespaceScoped bool,
schemaValidator validation.SchemaValidator,
subresourcesSchemaValidator map[string]validation.SchemaValidator,
structuralSchema *structuralschema.Structural,
) (mainStorage rest.Storage, subresourceStorages map[string]rest.Storage) {
statusSchemaValidate, statusEnabled := subresourcesSchemaValidator["status"]
var statusSpec *apiextensions.CustomResourceSubresourceStatus
if statusEnabled {
statusSpec = &apiextensions.CustomResourceSubresourceStatus{}
}
var scaleSpec *apiextensions.CustomResourceSubresourceScale
strategy := customresource.NewStrategy(
typer,
namespaceScoped,
kind,
registry.ValidatePathSegmentName,
schemaValidator,
statusSchemaValidate,
structuralSchema,
statusSpec,
scaleSpec,
[]apiextensionsv1.SelectableField{},
)
storage, statusStorage := registry.NewStorage(
ctx,
resource,
"",
kind,
listKind,
strategy,
nil,
tableConvertor,
nil,
func(ctx context.Context) (kcpdynamic.ClusterInterface, error) { return clusterClient, nil },
nil,
®istry.StorageWrappers{
registry.WithStaticLabelSelector(requirements),
withUpdateValidation(initializer),
},
)
// we want to expose some but not all the allowed endpoints, so filter by exposing just the funcs we need
subresourceStorages = make(map[string]rest.Storage)
if statusEnabled {
subresourceStorages["status"] = &struct {
registry.FactoryFunc
registry.DestroyerFunc
registry.GetterFunc
registry.UpdaterFunc
// patch is implicit as we have get + update
registry.TableConvertorFunc
registry.CategoriesProviderFunc
registry.ResetFieldsStrategyFunc
}{
FactoryFunc: statusStorage.FactoryFunc,
DestroyerFunc: statusStorage.DestroyerFunc,
GetterFunc: statusStorage.GetterFunc,
UpdaterFunc: statusStorage.UpdaterFunc,
TableConvertorFunc: statusStorage.TableConvertorFunc,
CategoriesProviderFunc: statusStorage.CategoriesProviderFunc,
ResetFieldsStrategyFunc: statusStorage.ResetFieldsStrategyFunc,
}
}
// only expose GET
return &struct {
registry.FactoryFunc
registry.ListFactoryFunc
registry.DestroyerFunc
registry.GetterFunc
registry.TableConvertorFunc
registry.CategoriesProviderFunc
registry.ResetFieldsStrategyFunc
}{
FactoryFunc: storage.FactoryFunc,
ListFactoryFunc: storage.ListFactoryFunc,
DestroyerFunc: storage.DestroyerFunc,
GetterFunc: storage.GetterFunc,
TableConvertorFunc: storage.TableConvertorFunc,
CategoriesProviderFunc: storage.CategoriesProviderFunc,
ResetFieldsStrategyFunc: storage.ResetFieldsStrategyFunc,
}, subresourceStorages
}, nil
}
// withUpdateValidation adds further validation to ensure that a user of this virtual workspace can only
// remove their own initializer from the list.
func withUpdateValidation(initializer corev1alpha1.LogicalClusterInitializer) registry.StorageWrapper {
return registry.StorageWrapperFunc(func(resource schema.GroupResource, storage *registry.StoreFuncs) {
delegateUpdater := storage.UpdaterFunc
storage.UpdaterFunc = func(ctx context.Context, name string, objInfo rest.UpdatedObjectInfo, createValidation rest.ValidateObjectFunc, updateValidation rest.ValidateObjectUpdateFunc, forceAllowCreate bool, options *metav1.UpdateOptions) (runtime.Object, bool, error) {
validationFunc := rest.ValidateObjectUpdateFunc(func(ctx context.Context, obj, old runtime.Object) error {
logger := klog.FromContext(ctx)
previous, _, err := unstructured.NestedStringSlice(old.(*unstructured.Unstructured).UnstructuredContent(), "status", "initializers")
if err != nil {
return errors.NewInternalError(fmt.Errorf("error accessing initializers from old object: %w", err))
}
current, _, err := unstructured.NestedStringSlice(obj.(*unstructured.Unstructured).UnstructuredContent(), "status", "initializers")
if err != nil {
logger.Error(err, "error accessing initializers from new object")
return errors.NewInternalError(fmt.Errorf("error accessing initializers from old object: %w", err))
}
invalidUpdateErr := errors.NewInvalid(
tenancyv1alpha1.Kind("LogicalCluster"),
name,
field.ErrorList{field.Invalid(
field.NewPath("status", "initializers"),
current,
fmt.Sprintf("only removing the %q initializer is supported", initializer),
)},
)
// Allow updates that don't touch initializers (e.g. condition-only status
// updates while bindings are still pending). Otherwise require exactly one
// initializer removed and it must be the one this VW is scoped to.
if len(previous) != len(current) {
if len(previous)-len(current) != 1 {
return invalidUpdateErr
}
if slices.Contains(current, string(initializer)) {
return invalidUpdateErr
}
}
return updateValidation(ctx, obj, old)
})
return delegateUpdater.Update(ctx, name, objInfo, createValidation, validationFunc, forceAllowCreate, options)
}
})
}