MVP: More agnostic backend

Author: mjudeikis

backend/http/handler.go

@@ -18,6 +18,7 @@ package http
 
 import (
 	"bytes"
+	"context"
 	"encoding/base64"
 	"encoding/json"
 	"errors"
@@ -32,10 +33,11 @@ import (
 	"github.com/gorilla/mux"
 	"github.com/gorilla/securecookie"
 	"golang.org/x/oauth2"
-	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	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"
 	componentbaseversion "k8s.io/component-base/version"
 	"k8s.io/klog/v2"
 
@@ -66,6 +68,7 @@ type handler struct {
 	backendCallbackURL string
 	providerPrettyName string
 	testingAutoSelect  string
+	schemaSource       string
 
 	cookieEncryptionKey []byte
 	cookieSigningKey    []byte
@@ -78,6 +81,7 @@ func NewHandler(
 	provider *OIDCServiceProvider,
 	oidcAuthorizeURL, backendCallbackURL, providerPrettyName, testingAutoSelect string,
 	cookieSigningKey, cookieEncryptionKey []byte,
+	schemaSource string,
 	scope kubebindv1alpha2.InformerScope,
 	mgr *kubernetes.Manager,
 ) (*handler, error) {
@@ -87,6 +91,7 @@ func NewHandler(
 		backendCallbackURL:  backendCallbackURL,
 		providerPrettyName:  providerPrettyName,
 		testingAutoSelect:   testingAutoSelect,
+		schemaSource:        schemaSource,
 		scope:               scope,
 		client:              http.DefaultClient,
 		kubeManager:         mgr,
@@ -328,6 +333,15 @@ func createSessionState(authCode *AuthCode, token *oauth2.Token) (*session.State
 	}, nil
 }
 
+type UISchema struct {
+	Name     string
+	Version  string
+	Group    string
+	Kind     string
+	Scope    string // "Namespaced" or "Cluster"
+	Resource string
+}
+
 func (h *handler) handleResources(w http.ResponseWriter, r *http.Request) {
 	logger := getLogger(r)
 
@@ -346,41 +360,69 @@ func (h *handler) handleResources(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	labelSelector := labels.Set{
-		resources.ExportedCRDsLabel: "true",
-	}
-
-	crds, err := h.kubeManager.ListCustomResourceDefinitions(r.Context(), cluster, labelSelector.AsSelector())
+	apiResourceSchemas, err := h.getBackendDynamicResource(r.Context(), cluster)
 	if err != nil {
-		logger.Error(err, "failed to list crds")
+		logger.Error(err, "failed to get dynamic resources")
 		http.Error(w, "internal error", http.StatusInternalServerError)
 		return
 	}
-	sort.SliceStable(crds.Items, func(i, j int) bool {
-		return crds.Items[i].Name < crds.Items[j].Name
-	})
-	rightScopedCRDs := []*apiextensionsv1.CustomResourceDefinition{}
-	for _, crd := range crds.Items {
-		if h.scope == kubebindv1alpha2.ClusterScope || crd.Spec.Scope == apiextensionsv1.NamespaceScoped {
-			rightScopedCRDs = append(rightScopedCRDs, &crd)
+
+	var result []UISchema
+	for _, item := range apiResourceSchemas.Items {
+		scope := item.UnstructuredContent()["spec"].(map[string]interface{})["scope"]
+		if scope == nil {
+			scope = "-"
+		}
+		group := item.UnstructuredContent()["spec"].(map[string]interface{})["group"]
+		if group == nil {
+			group = "-"
+		}
+		resource := item.UnstructuredContent()["spec"].(map[string]interface{})["names"].(map[string]interface{})["plural"]
+		if resource == nil {
+			resource = "-"
 		}
-	}
 
-	apiResourceSchemas, err := h.kubeManager.ListAPIResourceSchemas(r.Context(), cluster)
-	if err != nil {
-		logger.Error(err, "failed to get api resource schemas")
-		http.Error(w, "internal error", http.StatusInternalServerError)
-		return
+		kind := item.UnstructuredContent()["spec"].(map[string]interface{})["names"].(map[string]interface{})["kind"]
+		if kind == nil {
+			kind = "-"
+		}
+		namespace := item.GetNamespace()
+		if namespace == "" {
+			namespace = "-"
+		}
+
+		versions := item.UnstructuredContent()["spec"].(map[string]interface{})["versions"]
+		if versions == nil {
+			versions = []interface{}{""}
+			result = append(result, UISchema{
+				Name:     item.GetName(),
+				Scope:    scope.(string),
+				Version:  "-", // we can't parse it.
+				Group:    group.(string),
+				Resource: resource.(string),
+			})
+			continue
+		}
+		for _, v := range versions.([]interface{}) {
+			version := v.(map[string]interface{})["name"]
+			result = append(result, UISchema{
+				Name:     item.GetName(),
+				Kind:     kind.(string),
+				Scope:    scope.(string),
+				Version:  version.(string),
+				Group:    group.(string),
+				Resource: resource.(string),
+			})
+		}
 	}
+
 	bs := bytes.Buffer{}
 	if err := resourcesTemplate.Execute(&bs, struct {
-		Cluster            string
-		CRDs               []*apiextensionsv1.CustomResourceDefinition
-		APIResourceSchemas []kubebindv1alpha2.APIResourceSchema
+		Cluster string
+		Schemas []UISchema
 	}{
-		Cluster:            cluster,
-		CRDs:               rightScopedCRDs,
-		APIResourceSchemas: apiResourceSchemas.Items,
+		Cluster: cluster,
+		Schemas: result,
 	}); err != nil {
 		logger.Error(err, "failed to execute template")
 		http.Error(w, "internal error", http.StatusInternalServerError)
@@ -393,8 +435,10 @@ func (h *handler) handleResources(w http.ResponseWriter, r *http.Request) {
 
 func (h *handler) handleBind(w http.ResponseWriter, r *http.Request) {
 	logger := getLogger(r)
+	name := r.URL.Query().Get("name")
 	group := r.URL.Query().Get("group")
 	resource := r.URL.Query().Get("resource")
+	version := r.URL.Query().Get("version")
 	cluster := mux.Vars(r)["cluster"]
 
 	prepareNoCache(w)
@@ -415,7 +459,38 @@ func (h *handler) handleBind(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	kfg, err := h.kubeManager.HandleResources(r.Context(), state.Token.Subject+"#"+state.ClusterID, cluster, resource, group)
+	// There is an intent to bind. We need to create APIResourceSchema if one does not exists.
+	{
+		apiResourceSchemas, err := h.getBackendDynamicResource(r.Context(), cluster)
+		if err != nil {
+			logger.Error(err, "failed to get dynamic resources")
+			http.Error(w, "internal error", http.StatusInternalServerError)
+			return
+		}
+
+		schema := &unstructured.Unstructured{}
+		for _, item := range apiResourceSchemas.Items {
+			if item.GetName() == name {
+				schema = &item
+				break
+			}
+		}
+		if schema == nil || schema.GetName() != name {
+			logger.Error(nil, "no APIResourceSchema found", "name", name, "group", group, "resource", resource, "version", version)
+			http.Error(w, fmt.Sprintf("no APIResourceSchema found for %s.%s.%s/%s", group, resource, version, name), http.StatusNotFound)
+			return
+		}
+
+		// create apiResourceSchema if not exists
+		err = h.kubeManager.CreateAPIResourceSchema(r.Context(), cluster, name, schema)
+		if err != nil {
+			logger.Error(err, "failed to create APIResourceSchema")
+			http.Error(w, "internal error", http.StatusInternalServerError)
+			return
+		}
+	}
+
+	kfg, err := h.kubeManager.HandleResources(r.Context(), state.Token.Subject+"#"+state.ClusterID, cluster)
 	if err != nil {
 		logger.Error(err, "failed to handle resources")
 		http.Error(w, "internal error", http.StatusInternalServerError)
@@ -435,7 +510,10 @@ func (h *handler) handleBind(w http.ResponseWriter, r *http.Request) {
 		},
 		Spec: kubebindv1alpha2.APIServiceExportRequestSpec{
 			Resources: []kubebindv1alpha2.APIServiceExportRequestResource{
-				{GroupResource: kubebindv1alpha2.GroupResource{Group: group, Resource: resource}},
+				{
+					GroupResource: kubebindv1alpha2.GroupResource{Group: group, Resource: resource},
+					Versions:      []string{version},
+				},
 			},
 		},
 	}
@@ -495,3 +573,28 @@ func mustRead(f func(name string) ([]byte, error), name string) string {
 	}
 	return string(bs)
 }
+
+func (h *handler) getBackendDynamicResource(ctx context.Context, cluster string) (*unstructured.UnstructuredList, error) {
+	labelSelector := labels.Set{
+		resources.ExportedCRDsLabel: "true",
+	}
+
+	parts := strings.SplitN(h.schemaSource, ".", 3)
+	if len(parts) != 3 {
+		return nil, fmt.Errorf("invalid schema source: %q", h.schemaSource)
+	}
+
+	gvk := schema.GroupVersionKind{
+		Kind:    parts[0],
+		Version: parts[1],
+		Group:   parts[2],
+	}
+	apiResourceSchemas, err := h.kubeManager.ListDynamicResources(ctx, cluster, gvk, labelSelector.AsSelector())
+	if err != nil {
+		return nil, fmt.Errorf("failed to list crds: %w", err)
+	}
+	sort.SliceStable(apiResourceSchemas.Items, func(i, j int) bool {
+		return apiResourceSchemas.Items[i].GetName() < apiResourceSchemas.Items[j].GetName()
+	})
+	return apiResourceSchemas, nil
+}

backend/kubernetes/manager.go

@@ -19,11 +19,15 @@ package kubernetes
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	corev1 "k8s.io/api/core/v1"
 	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
+	"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/types"
 	"k8s.io/klog/v2"
 	"sigs.k8s.io/controller-runtime/pkg/client"
@@ -71,8 +75,8 @@ func NewKubernetesManager(
 	return m, nil
 }
 
-func (m *Manager) HandleResources(ctx context.Context, identity, cluster, resource, group string) ([]byte, error) {
-	logger := klog.FromContext(ctx).WithValues("identity", identity, "resource", resource, "group", group)
+func (m *Manager) HandleResources(ctx context.Context, identity, cluster string) ([]byte, error) {
+	logger := klog.FromContext(ctx).WithValues("identity", identity)
 	ctx = klog.NewContext(ctx, logger)
 
 	cl, err := m.manager.GetCluster(ctx, cluster)
@@ -173,3 +177,55 @@ func (m *Manager) ListCustomResourceDefinitions(ctx context.Context, cluster str
 
 	return &crds, nil
 }
+
+func (m *Manager) ListDynamicResources(ctx context.Context, cluster string, gvk schema.GroupVersionKind, selector labels.Selector) (*unstructured.UnstructuredList, error) {
+	cl, err := m.manager.GetCluster(ctx, cluster)
+	if err != nil {
+		return nil, err
+	}
+	c := cl.GetClient()
+
+	// Ensure we have the List kind
+	listGVK := gvk
+	if !strings.HasSuffix(listGVK.Kind, "List") {
+		listGVK.Kind = listGVK.Kind + "List"
+	}
+
+	list := &unstructured.UnstructuredList{}
+	list.SetGroupVersionKind(listGVK)
+
+	listOpts := []client.ListOption{}
+	if selector != nil {
+		listOpts = append(listOpts, client.MatchingLabelsSelector{Selector: selector})
+	}
+
+	if err := c.List(ctx, list, listOpts...); err != nil {
+		return nil, err
+	}
+
+	return list, nil
+}
+
+func (m *Manager) CreateAPIResourceSchema(ctx context.Context, cluster string, name string, u *unstructured.Unstructured) error {
+	cl, err := m.manager.GetCluster(ctx, cluster)
+	if err != nil {
+		return err
+	}
+	c := cl.GetClient()
+
+	apiResourceSchema := &kubebindv1alpha2.APIResourceSchema{}
+	err = runtime.DefaultUnstructuredConverter.FromUnstructured(u.UnstructuredContent(), apiResourceSchema)
+	if err != nil {
+		return err
+	}
+
+	apiResourceSchema.ResourceVersion = ""
+	apiResourceSchema.Name = name
+	apiResourceSchema.Spec.InformerScope = kubebindv1alpha2.ClusterScope // TODO: This is wrong!!!!!!
+
+	if err := c.Create(ctx, apiResourceSchema); err != nil {
+		return err
+	}
+
+	return nil
+}

backend/options/options.go

@@ -53,6 +53,11 @@ type ExtraOptions struct {
 	ExternalCAFile         string
 	ExternalCA             []byte
 	TLSExternalServerName  string
+	// Defines the source of the schema for the bind screen.
+	// Options are:
+	// CustomResourceDefinitions.v1.apiextensions.k8s.io
+	// APIResourceSchemas.v1alpha2.kube-bind.io
+	SchemaSource string
 
 	TestingAutoSelect         string
 	TestingSkipNameValidation bool
@@ -89,6 +94,7 @@ func NewOptions() *Options {
 			ConsumerScope:          string(kubebindv1alpha2.NamespacedScope),
 			ClusterScopedIsolation: string(kubebindv1alpha2.IsolationPrefixed),
 			ServerURL:              "",
+			SchemaSource:           "crd",
 		},
 	}
 }
@@ -99,6 +105,12 @@ var providerAliases = map[string]string{
 	"":           "kubernetes",
 }
 
+var schemaSourceAliases = map[string]string{
+	"crd":                       "CustomResourceDefinition.v1.apiextensions.k8s.io",
+	"apiresourceschemas":        "APIResourceSchema.v1alpha2.kube-bind.io",
+	"customresourcedefinitions": "CustomResourceDefinition.v1.apiextensions.k8s.io",
+}
+
 func (options *Options) AddFlags(fs *pflag.FlagSet) {
 	logsv1.AddFlags(options.Logs, fs)
 	options.OIDC.AddFlags(fs)
@@ -118,6 +130,11 @@ func (options *Options) AddFlags(fs *pflag.FlagSet) {
 		fmt.Sprintf("The multicluster runtime provider. Possible values are: %v", sets.List(sets.Set[string](sets.StringKeySet(providerAliases)))),
 	)
 
+	fs.StringVar(&options.SchemaSource, "schema-source", options.SchemaSource,
+		fmt.Sprintf("Defines the source of the schema in KindVersionGroup format for the bind screen. Defaults to CustomResourceDefinition.v1.apiextensions.k8s.io. Possible values are: %v",
+			sets.List(sets.Set[string](sets.StringKeySet(schemaSourceAliases)))),
+	)
+
 	fs.StringVar(&options.ServerURL, "server-url", options.ServerURL, "The URL of the backend server. If not specified, it will be derived from the kubeconfig or service account's hosts.")
 
 	fs.StringVar(&options.TestingAutoSelect, "testing-auto-select", options.TestingAutoSelect, "<resource>.<group> that is automatically selected on th bind screen for testing")
@@ -206,5 +223,11 @@ func (options *CompletedOptions) Validate() error {
 	}
 	options.Provider = provider
 
+	schemaSource := schemaSourceAliases[options.SchemaSource]
+	if schemaSource == "" {
+		return fmt.Errorf("unknown schema source %q, must be one of %v", options.SchemaSource, sets.List(sets.Set[string](sets.StringKeySet(schemaSourceAliases))))
+	}
+	options.SchemaSource = schemaSource
+
 	return nil
 }