API Server Poc

apiserver/connector.go

@@ -0,0 +1,153 @@
+package apiserver
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/grafana/grafana-app-sdk/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/conversion"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apiserver/pkg/endpoints/request"
+	"k8s.io/apiserver/pkg/registry/rest"
+	"k8s.io/kube-openapi/pkg/common"
+	"k8s.io/kube-openapi/pkg/validation/spec"
+)
+
+type ResourceCallOptions struct {
+	metav1.TypeMeta
+
+	// Path is the URL path to use for the current proxy request
+	Path string
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ResourceCallOptions) DeepCopyInto(out *ResourceCallOptions) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceCallOptions.
+func (in *ResourceCallOptions) DeepCopy() *ResourceCallOptions {
+	if in == nil {
+		return nil
+	}
+	out := new(ResourceCallOptions)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *ResourceCallOptions) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+var _ = rest.Connecter(&SubresourceConnector{})
+
+// TODO: customize rather than hard-code?
+var methods = []string{"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"}
+
+type SubresourceConnector struct {
+	Routes []SubresourceRoute
+}
+
+func (r *SubresourceConnector) New() runtime.Object {
+	return &ResourceCallOptions{}
+}
+
+func (r *SubresourceConnector) Destroy() {
+}
+
+func (r *SubresourceConnector) ConnectMethods() []string {
+	return methods
+}
+
+func (r *SubresourceConnector) NewConnectOptions() (runtime.Object, bool, string) {
+	return &ResourceCallOptions{}, true, "path"
+}
+
+func (r *SubresourceConnector) Connect(ctx context.Context, id string, opts runtime.Object, responder rest.Responder) (http.Handler, error) {
+	resourceCallOpts, ok := opts.(*ResourceCallOptions)
+	if !ok {
+		return nil, fmt.Errorf("invalid options object: %#v", opts)
+	}
+	fmt.Println("ResourceCallREST.Connect() called with id:", id, "and opts:", resourceCallOpts)
+	// TODO: map instead?
+	info, ok := request.RequestInfoFrom(ctx)
+	if !ok {
+		return nil, fmt.Errorf("unable to retrieve request info from context")
+	}
+	identifier := resource.Identifier{
+		Name:      info.Name,
+		Namespace: info.Namespace,
+	}
+	for _, route := range r.Routes {
+		if route.Path == info.Subresource {
+			return &handlerWrapper{
+				id:      identifier,
+				handler: route.Handler,
+			}, nil
+		}
+	}
+	return nil, fmt.Errorf("no matching route for id '%s'", id)
+}
+
+type handlerWrapper struct {
+	id      resource.Identifier
+	handler AdditionalRouteHandler
+}
+
+func (h *handlerWrapper) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	h.handler(w, req, h.id)
+}
+
+// CovertURLValuesToResourceCallOptions reads from the input *url.Values and assigns fields in the out *ResourceCallOptions
+func CovertURLValuesToResourceCallOptions(in *url.Values, out *ResourceCallOptions, s conversion.Scope) error {
+	if values, ok := map[string][]string(*in)["path"]; ok && len(values) > 0 {
+		if err := runtime.Convert_Slice_string_To_string(&values, &out.Path, s); err != nil {
+			return err
+		}
+	} else {
+		out.Path = ""
+	}
+	return nil
+}
+
+func GetResourceCallOptionsOpenAPIDefinition() map[string]common.OpenAPIDefinition {
+	return map[string]common.OpenAPIDefinition{
+		"github.com/grafana/grafana-app-sdk/apiserver.ResourceCallOptions": common.OpenAPIDefinition{
+			Schema: spec.Schema{
+				SchemaProps: spec.SchemaProps{
+					Description: "ExternalNameFoo defines model for ExternalNameFoo.",
+					Type:        []string{"object"},
+					Properties: map[string]spec.Schema{
+						"kind": {
+							SchemaProps: spec.SchemaProps{
+								Type: []string{"string"},
+							},
+						},
+						"apiVersion": {
+							SchemaProps: spec.SchemaProps{
+								Type: []string{"string"},
+							},
+						},
+						"path": {
+							SchemaProps: spec.SchemaProps{
+								Default: "",
+								Type:    []string{"string"},
+								Format:  "",
+							},
+						},
+					},
+					Required: []string{"foo"},
+				},
+			},
+		},
+	}
+}

apiserver/conversion.go

@@ -0,0 +1,128 @@
+package apiserver
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/grafana/grafana-app-sdk/resource"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+// ResourceConverter is an interface which describes a type which can convert an object to and from its internal representation.
+// Kubernetes API Server kind version conversion will always convert to and from the internal version when converting between versions,
+// so converting from version v1 to v2 will go v1 -> internal -> v2, calling
+// ToInternal(v1Obj, internalObj) then FromInternal(internalObj, v2Obj)
+type ResourceConverter interface {
+	FromInternal(src any, dst any) error
+	ToInternal(src any, dst any) error
+}
+
+// TypedResourceConverter is an implementation of ResourceConverter which allows the user to work with typed inputs
+type TypedResourceConverter[InternalType, ResourceType resource.Object] struct {
+	FromInternalFunc func(src InternalType, dst ResourceType) error
+	ToInternalFunc   func(src ResourceType, dst InternalType) error
+}
+
+// FromInternal attempts to convert src into InternalType and dst into ResourceType (returning an error if either of
+// these operations fail), and then calls FromInternalFunc using the converted types.
+// If FromInternalFunc is nil, it will call DefaultConversionFunc instead.
+func (t *TypedResourceConverter[InternalType, ResourceType]) FromInternal(src, dst any) error {
+	s, ok := src.(InternalType)
+	if !ok {
+		return fmt.Errorf("src is not of type InternalType")
+	}
+	d, ok := dst.(ResourceType)
+	if !ok {
+		return fmt.Errorf("dst is not of type ResourceType")
+	}
+	if t.FromInternalFunc == nil {
+		return DefaultConversionFunc(s, d)
+	}
+	return t.FromInternalFunc(s, d)
+}
+
+// ToInternal attempts to convert src into ResourceType and dst into InternalType (returning an error if either of
+// these operations fail), and then calls ToInternalFunc using the converted types.
+// If ToInternalFunc is nil, it will call DefaultConversionFunc instead.
+func (t *TypedResourceConverter[InternalType, ResourceType]) ToInternal(src, dst any) error {
+	s, ok := src.(ResourceType)
+	if !ok {
+		return fmt.Errorf("src is not of type ResourceType")
+	}
+	d, ok := dst.(InternalType)
+	if !ok {
+		return fmt.Errorf("dst is not of type InternalType")
+	}
+	if t.FromInternalFunc == nil {
+		return DefaultConversionFunc(s, d)
+	}
+	return t.ToInternalFunc(s, d)
+}
+
+var codec = resource.NewJSONCodec()
+
+// DefaultConversionFunc is a default conversion function which translates src into dst by using a resource.JSONCodec
+// to write src to JSON, then read the JSON bytes into dst.
+func DefaultConversionFunc(src, dst resource.Object) error {
+	buf := bytes.Buffer{}
+	err := codec.Write(&buf, src)
+	if err != nil {
+		return err
+	}
+	err = codec.Read(bytes.NewReader(buf.Bytes()), dst)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GenericObjectConverter implements ResourceConverter and calls DefaultConversionFunc for its conversion process.
+// It uses the GVK value to set GroupVersionKind when converting.
+type GenericObjectConverter struct {
+	GVK schema.GroupVersionKind
+}
+
+// FromInternal attempts to convert src and dst into resource.Object, returning an error if this fails,
+// then calls DefaultConversionFunc on the converted src and dst. It sets the GroupVersionKind on dst
+// to the value of GenericObjectConverter.GVK.
+func (g *GenericObjectConverter) FromInternal(src, dst any) error {
+	a, ok := src.(resource.Object)
+	if !ok {
+		return fmt.Errorf("src does not implement resource.Object")
+	}
+	b, ok := dst.(resource.Object)
+	if !ok {
+		return fmt.Errorf("dst does not implement resource.Object")
+	}
+	err := DefaultConversionFunc(a, b)
+	if err != nil {
+		return err
+	}
+	b.SetGroupVersionKind(g.GVK)
+	return nil
+}
+
+// ToInternal attempts to convert src and dst into resource.Object, returning an error if this fails,
+// then calls DefaultConversionFunc on the converted src and dst. It sets the Group and Kind on dst
+// to the value of GenericObjectConverter.GVK, and Version to runtime.APIVersionInternal.
+func (g *GenericObjectConverter) ToInternal(src, dst any) error {
+	a, ok := src.(resource.Object)
+	if !ok {
+		return fmt.Errorf("src does not implement resource.Object")
+	}
+	b, ok := dst.(resource.Object)
+	if !ok {
+		return fmt.Errorf("dst does not implement resource.Object")
+	}
+	err := DefaultConversionFunc(a, b)
+	if err != nil {
+		return err
+	}
+	b.SetGroupVersionKind(schema.GroupVersionKind{
+		Group:   g.GVK.Group,
+		Version: runtime.APIVersionInternal,
+		Kind:    g.GVK.Kind,
+	})
+	return nil
+}