Plugins: Add app (#108422)

apps/plugins/pkg/app/app.go

@@ -0,0 +1,65 @@
+package app
+
+import (
+	"context"
+
+	"github.com/grafana/grafana-app-sdk/app"
+	"github.com/grafana/grafana-app-sdk/resource"
+	"github.com/grafana/grafana-app-sdk/simple"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/klog/v2"
+
+	pluginsapi "github.com/grafana/grafana/apps/plugins/pkg/apis"
+)
+
+func New(cfg app.Config) (app.App, error) {
+	managedKinds := []simple.AppManagedKind{}
+	for _, kinds := range GetKinds() {
+		for _, k := range kinds {
+			managedKinds = append(managedKinds, simple.AppManagedKind{
+				Kind: k,
+			})
+		}
+	}
+
+	simpleConfig := simple.AppConfig{
+		Name:       "plugins",
+		KubeConfig: cfg.KubeConfig,
+		InformerConfig: simple.AppInformerConfig{
+			ErrorHandler: func(ctx context.Context, err error) {
+				klog.ErrorS(err, "Informer processing error")
+			},
+		},
+		ManagedKinds: managedKinds,
+	}
+
+	a, err := simple.NewApp(simpleConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	err = a.ValidateManifest(cfg.ManifestData)
+	if err != nil {
+		return nil, err
+	}
+
+	return a, nil
+}
+
+func GetKinds() map[schema.GroupVersion][]resource.Kind {
+	kinds := make(map[schema.GroupVersion][]resource.Kind)
+	manifest := pluginsapi.LocalManifest()
+	for _, v := range manifest.ManifestData.Versions {
+		gv := schema.GroupVersion{
+			Group:   manifest.ManifestData.Group,
+			Version: v.Name,
+		}
+		for _, k := range v.Kinds {
+			kind, ok := pluginsapi.ManifestGoTypeAssociator(k.Kind, v.Name)
+			if ok {
+				kinds[gv] = append(kinds[gv], kind)
+			}
+		}
+	}
+	return kinds
+}

apps/plugins/pkg/app/authorizer.go

@@ -0,0 +1,32 @@
+package app
+
+import (
+	"context"
+
+	"k8s.io/apiserver/pkg/authorization/authorizer"
+
+	"github.com/grafana/grafana/pkg/apimachinery/identity"
+)
+
+func GetAuthorizer() authorizer.Authorizer {
+	return authorizer.AuthorizerFunc(func(
+		ctx context.Context, attr authorizer.Attributes,
+	) (authorized authorizer.Decision, reason string, err error) {
+		if !attr.IsResourceRequest() {
+			return authorizer.DecisionNoOpinion, "", nil
+		}
+
+		// require a user
+		u, err := identity.GetRequester(ctx)
+		if err != nil {
+			return authorizer.DecisionDeny, "valid user is required", err
+		}
+
+		// check if is admin
+		if u.HasRole(identity.RoleAdmin) {
+			return authorizer.DecisionAllow, "", nil
+		}
+
+		return authorizer.DecisionDeny, "forbidden", nil
+	})
+}

apps/plugins/pkg/app/storage.go

@@ -0,0 +1,75 @@
+package app
+
+import (
+	"context"
+	"strings"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/apis/meta/internalversion"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apiserver/pkg/registry/rest"
+
+	claims "github.com/grafana/authlib/types"
+	pluginsv0alpha1 "github.com/grafana/grafana/apps/plugins/pkg/apis/plugins/v0alpha1"
+)
+
+var (
+	_ rest.Scoper               = (*PluginMetaStorage)(nil)
+	_ rest.SingularNameProvider = (*PluginMetaStorage)(nil)
+	_ rest.Getter               = (*PluginMetaStorage)(nil)
+	_ rest.Lister               = (*PluginMetaStorage)(nil)
+	_ rest.Storage              = (*PluginMetaStorage)(nil)
+	_ rest.TableConvertor       = (*PluginMetaStorage)(nil)
+)
+
+type PluginMetaStorage struct {
+	gr             schema.GroupResource
+	namespacer     claims.NamespaceFormatter
+	tableConverter rest.TableConvertor
+}
+
+func NewPluginMetaStorage(
+	namespacer claims.NamespaceFormatter,
+) *PluginMetaStorage {
+	gr := schema.GroupResource{
+		Group:    pluginsv0alpha1.PluginMetaKind().Group(),
+		Resource: strings.ToLower(pluginsv0alpha1.PluginMetaKind().Plural()),
+	}
+	return &PluginMetaStorage{
+		gr:             gr,
+		namespacer:     namespacer,
+		tableConverter: rest.NewDefaultTableConvertor(gr),
+	}
+}
+
+func (s *PluginMetaStorage) New() runtime.Object {
+	return pluginsv0alpha1.PluginMetaKind().ZeroValue()
+}
+
+func (s *PluginMetaStorage) Destroy() {}
+
+func (s *PluginMetaStorage) NamespaceScoped() bool {
+	return true
+}
+
+func (s *PluginMetaStorage) GetSingularName() string {
+	return strings.ToLower(pluginsv0alpha1.PluginMetaKind().Kind())
+}
+
+func (s *PluginMetaStorage) NewList() runtime.Object {
+	return pluginsv0alpha1.PluginMetaKind().ZeroListValue()
+}
+
+func (s *PluginMetaStorage) ConvertToTable(ctx context.Context, object runtime.Object, tableOptions runtime.Object) (*metav1.Table, error) {
+	return s.tableConverter.ConvertToTable(ctx, object, tableOptions)
+}
+
+func (s *PluginMetaStorage) List(ctx context.Context, options *internalversion.ListOptions) (runtime.Object, error) {
+	return s.NewList(), nil
+}
+
+func (s *PluginMetaStorage) Get(ctx context.Context, name string, options *metav1.GetOptions) (runtime.Object, error) {
+	return nil, apierrors.NewNotFound(s.gr, name)
+}