schema fallback

Author: mjudeikis

backend/provider/kcp/controllers/apibindingtemplate/controller.go

@@ -23,12 +23,15 @@ package apibindingtemplate
 import (
 	"context"
 	"fmt"
+	"net/url"
 	"strings"
 
 	apisv1alpha1 "github.com/kcp-dev/sdk/apis/apis/v1alpha1"
 	apisv1alpha2 "github.com/kcp-dev/sdk/apis/apis/v1alpha2"
 	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/client-go/rest"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/cluster"
@@ -51,6 +54,11 @@ type APIBindingTemplateReconciler struct {
 	manager        mcmanager.Manager
 	opts           controller.TypedOptions[mcreconcile.Request]
 	ignorePrefixes []string
+
+	// baseConfig is the kcp admin/root REST config used to construct
+	// VW clients for the apiresourceschema virtual workspace.
+	baseConfig *rest.Config
+	scheme     *runtime.Scheme
 }
 
 // New returns a new APIBindingTemplateReconciler.
@@ -59,11 +67,15 @@ func New(
 	mgr mcmanager.Manager,
 	opts controller.TypedOptions[mcreconcile.Request],
 	ignorePrefixes []string,
+	baseConfig *rest.Config,
+	scheme *runtime.Scheme,
 ) (*APIBindingTemplateReconciler, error) {
 	r := &APIBindingTemplateReconciler{
 		manager:        mgr,
 		opts:           opts,
 		ignorePrefixes: ignorePrefixes,
+		baseConfig:     baseConfig,
+		scheme:         scheme,
 	}
 
 	return r, nil
@@ -80,6 +92,39 @@ func (r *APIBindingTemplateReconciler) shouldIgnore(name string) bool {
 	return false
 }
 
+// extractClusterID extracts the cluster ID from an apiexport virtual workspace
+// URL. The URL format is:
+// https://host:port/services/apiexport/root:org:ws/<apiexport-name>/clusters/{cluster-id}
+func extractClusterID(clusterConfig *rest.Config) (string, error) {
+	u, err := url.Parse(clusterConfig.Host)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse cluster host URL: %w", err)
+	}
+
+	pathParts := strings.Split(strings.Trim(u.Path, "/"), "/")
+	if len(pathParts) < 6 || pathParts[4] != "clusters" {
+		return "", fmt.Errorf("unexpected apiexport URL format: %s", u.Path)
+	}
+
+	return pathParts[5], nil
+}
+
+// newVWClient creates a client pointing at the apiresourceschema virtual workspace
+// for the given cluster ID:
+// https://host:port/services/apiresourceschema/{clusterID}/clusters/*/
+func (r *APIBindingTemplateReconciler) newVWClient(clusterID string) (client.Client, error) {
+	cfg := rest.CopyConfig(r.baseConfig)
+	u, err := url.Parse(cfg.Host)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse base config host: %w", err)
+	}
+
+	u.Path = fmt.Sprintf("/services/apiresourceschema/%s/clusters/*", clusterID)
+	cfg.Host = u.String()
+
+	return client.New(cfg, client.Options{Scheme: r.scheme})
+}
+
 // Reconcile implements reconcile.Reconciler for multicluster-runtime.
 func (r *APIBindingTemplateReconciler) Reconcile(ctx context.Context, req mcreconcile.Request) (ctrl.Result, error) {
 	logger := log.FromContext(ctx)
@@ -97,6 +142,7 @@ func (r *APIBindingTemplateReconciler) Reconcile(ctx context.Context, req mcreco
 	}
 
 	c := cl.GetClient()
+	clusterConfig := cl.GetConfig()
 
 	binding := &apisv1alpha2.APIBinding{}
 	if err := c.Get(ctx, req.NamespacedName, binding); err != nil {
@@ -106,15 +152,12 @@ func (r *APIBindingTemplateReconciler) Reconcile(ctx context.Context, req mcreco
 		return ctrl.Result{}, fmt.Errorf("failed to get APIBinding %q: %w", req.Name, err)
 	}
 
+	// Build the schema getter with VW fallback.
+	getSchema := r.schemaGetterWithFallback(c, clusterConfig)
+
 	rec := reconciler{
-		client: c,
-		getAPIResourceSchema: func(ctx context.Context, name string) (*apisv1alpha1.APIResourceSchema, error) {
-			var schema apisv1alpha1.APIResourceSchema
-			if err := c.Get(ctx, client.ObjectKey{Name: name}, &schema); err != nil {
-				return nil, err
-			}
-			return &schema, nil
-		},
+		client:               c,
+		getAPIResourceSchema: getSchema,
 	}
 
 	if err := rec.reconcile(ctx, binding); err != nil {
@@ -125,6 +168,48 @@ func (r *APIBindingTemplateReconciler) Reconcile(ctx context.Context, req mcreco
 	return ctrl.Result{}, nil
 }
 
+// schemaGetterWithFallback returns a function that first tries to get the
+// APIResourceSchema from the current workspace, and if not found, falls back
+// to the apiresourceschema virtual workspace.
+func (r *APIBindingTemplateReconciler) schemaGetterWithFallback(
+	workspaceClient client.Client,
+	clusterConfig *rest.Config,
+) func(ctx context.Context, name string) (*apisv1alpha1.APIResourceSchema, error) {
+	return func(ctx context.Context, name string) (*apisv1alpha1.APIResourceSchema, error) {
+		logger := log.FromContext(ctx)
+
+		// 1. Try the current workspace first.
+		var schema apisv1alpha1.APIResourceSchema
+		err := workspaceClient.Get(ctx, client.ObjectKey{Name: name}, &schema)
+		if err == nil {
+			return &schema, nil
+		}
+		if !errors.IsNotFound(err) {
+			return nil, err
+		}
+
+		// 2. Fallback: try the apiresourceschema virtual workspace.
+		logger.V(2).Info("APIResourceSchema not found in workspace, trying VW fallback", "schema", name)
+
+		clusterID, err := extractClusterID(clusterConfig)
+		if err != nil {
+			return nil, fmt.Errorf("cannot build VW fallback client: %w", err)
+		}
+
+		vwClient, err := r.newVWClient(clusterID)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create VW client for cluster %q: %w", clusterID, err)
+		}
+
+		var vwSchema apisv1alpha1.APIResourceSchema
+		if err := vwClient.Get(ctx, client.ObjectKey{Name: name}, &vwSchema); err != nil {
+			return nil, fmt.Errorf("APIResourceSchema %q not found in workspace or VW: %w", name, err)
+		}
+
+		return &vwSchema, nil
+	}
+}
+
 // getTemplateMapper returns a mapper that enqueues the owning APIBinding when
 // an APIServiceExportTemplate changes.
 func getTemplateMapper(clusterName string, cl cluster.Cluster) handler.TypedEventHandler[client.Object, mcreconcile.Request] {

backend/server.go

@@ -271,7 +271,7 @@ func NewServer(ctx context.Context, c *Config) (*Server, error) {
 	// Setup kcp-specific APIBindingTemplate controller. Only active when
 	// provider is kcp (APIBindings only exist in kcp workspaces).
 	if c.Options.Provider == "kcp" {
-		s.APIBindingTemplate, err = apibindingtemplate.New(ctx, s.Config.Manager, opts, c.Options.ProviderKcp.APIBindingIgnorePrefixes)
+		s.APIBindingTemplate, err = apibindingtemplate.New(ctx, s.Config.Manager, opts, c.Options.ProviderKcp.APIBindingIgnorePrefixes, c.ClientConfig, c.Scheme)
 		if err != nil {
 			return nil, fmt.Errorf("error setting up APIBindingTemplate Controller: %w", err)
 		}