K8s/Storage: add a reusable generic storage builder (#93778)

pkg/apiserver/registry/generic/storage.go

@@ -0,0 +1,31 @@
+package generic
+
+import (
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apiserver/pkg/registry/generic"
+	"k8s.io/apiserver/pkg/registry/generic/registry"
+
+	"github.com/grafana/grafana/pkg/apimachinery/utils"
+)
+
+func NewRegistryStore(scheme *runtime.Scheme, resourceInfo utils.ResourceInfo, optsGetter generic.RESTOptionsGetter) (*registry.Store, error) {
+	strategy := NewStrategy(scheme, resourceInfo.GroupVersion())
+	store := &registry.Store{
+		NewFunc:                   resourceInfo.NewFunc,
+		NewListFunc:               resourceInfo.NewListFunc,
+		KeyRootFunc:               KeyRootFunc(resourceInfo.GroupResource()),
+		KeyFunc:                   NamespaceKeyFunc(resourceInfo.GroupResource()),
+		PredicateFunc:             Matcher,
+		DefaultQualifiedResource:  resourceInfo.GroupResource(),
+		SingularQualifiedResource: resourceInfo.SingularGroupResource(),
+		TableConvertor:            resourceInfo.TableConverter(),
+		CreateStrategy:            strategy,
+		UpdateStrategy:            strategy,
+		DeleteStrategy:            strategy,
+	}
+	options := &generic.StoreOptions{RESTOptions: optsGetter, AttrFunc: GetAttrs}
+	if err := store.CompleteWithOptions(options); err != nil {
+		return nil, err
+	}
+	return store, nil
+}

pkg/registry/apis/alerting/notifications/receiver/storage.go

@@ -43,23 +43,11 @@ func NewStorage(
 		metadata:       metadata,
 	}
 	if optsGetter != nil && dualWriteBuilder != nil {
-		strategy := grafanaregistry.NewStrategy(scheme, resourceInfo.GroupVersion())
+		store, err := grafanaregistry.NewRegistryStore(scheme, resourceInfo, optsGetter)
-		s := &genericregistry.Store{
+		if err != nil {
-			NewFunc:                   resourceInfo.NewFunc,
-			NewListFunc:               resourceInfo.NewListFunc,
-			PredicateFunc:             Matcher,
-			DefaultQualifiedResource:  resourceInfo.GroupResource(),
-			SingularQualifiedResource: resourceInfo.SingularGroupResource(),
-			TableConvertor:            legacyStore.tableConverter,
-			CreateStrategy:            strategy,
-			UpdateStrategy:            strategy,
-			DeleteStrategy:            strategy,
-		}
-		options := &generic.StoreOptions{RESTOptions: optsGetter, AttrFunc: grafanaregistry.GetAttrs}
-		if err := s.CompleteWithOptions(options); err != nil {
 			return nil, err
 		}
-		return dualWriteBuilder(resourceInfo.GroupResource(), legacyStore, storage{Store: s})
+		return dualWriteBuilder(resourceInfo.GroupResource(), legacyStore, store)
 	}
 	return legacyStore, nil
 }

pkg/registry/apis/alerting/notifications/template_group/storage.go

@@ -41,25 +41,11 @@ func NewStorage(
 		tableConverter: resourceInfo.TableConverter(),
 	}
 	if optsGetter != nil && dualWriteBuilder != nil {
-		strategy := grafanaregistry.NewStrategy(scheme, resourceInfo.GroupVersion())
+		store, err := grafanaregistry.NewRegistryStore(scheme, resourceInfo, optsGetter)
-		s := &genericregistry.Store{
+		if err != nil {
-			NewFunc:                   resourceInfo.NewFunc,
-			NewListFunc:               resourceInfo.NewListFunc,
-			KeyRootFunc:               grafanaregistry.KeyRootFunc(resourceInfo.GroupResource()),
-			KeyFunc:                   grafanaregistry.NamespaceKeyFunc(resourceInfo.GroupResource()),
-			PredicateFunc:             Matcher,
-			DefaultQualifiedResource:  resourceInfo.GroupResource(),
-			SingularQualifiedResource: resourceInfo.SingularGroupResource(),
-			TableConvertor:            legacyStore.tableConverter,
-			CreateStrategy:            strategy,
-			UpdateStrategy:            strategy,
-			DeleteStrategy:            strategy,
-		}
-		options := &generic.StoreOptions{RESTOptions: optsGetter, AttrFunc: GetAttrs}
-		if err := s.CompleteWithOptions(options); err != nil {
 			return nil, err
 		}
-		return dualWriteBuilder(resourceInfo.GroupResource(), legacyStore, storage{Store: s})
+		return dualWriteBuilder(resourceInfo.GroupResource(), legacyStore, store)
 	}
 	return legacyStore, nil
 }

pkg/registry/apis/alerting/notifications/timeinterval/storage.go

@@ -41,25 +41,11 @@ func NewStorage(
 		tableConverter: resourceInfo.TableConverter(),
 	}
 	if optsGetter != nil && dualWriteBuilder != nil {
-		strategy := grafanaregistry.NewStrategy(scheme, resourceInfo.GroupVersion())
+		store, err := grafanaregistry.NewRegistryStore(scheme, resourceInfo, optsGetter)
-		s := &genericregistry.Store{
+		if err != nil {
-			NewFunc:                   resourceInfo.NewFunc,
-			NewListFunc:               resourceInfo.NewListFunc,
-			KeyRootFunc:               grafanaregistry.KeyRootFunc(resourceInfo.GroupResource()),
-			KeyFunc:                   grafanaregistry.NamespaceKeyFunc(resourceInfo.GroupResource()),
-			PredicateFunc:             Matcher,
-			DefaultQualifiedResource:  resourceInfo.GroupResource(),
-			SingularQualifiedResource: resourceInfo.SingularGroupResource(),
-			TableConvertor:            legacyStore.tableConverter,
-			CreateStrategy:            strategy,
-			UpdateStrategy:            strategy,
-			DeleteStrategy:            strategy,
-		}
-		options := &generic.StoreOptions{RESTOptions: optsGetter, AttrFunc: GetAttrs}
-		if err := s.CompleteWithOptions(options); err != nil {
 			return nil, err
 		}
-		return dualWriteBuilder(resourceInfo.GroupResource(), legacyStore, storage{Store: s})
+		return dualWriteBuilder(resourceInfo.GroupResource(), legacyStore, store)
 	}
 	return legacyStore, nil
 }

pkg/registry/apis/dashboard/legacy_storage.go

@@ -1,16 +1,16 @@
 package dashboard
 
 import (
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apiserver/pkg/registry/generic"
+	"k8s.io/apiserver/pkg/registry/rest"
+
 	"github.com/grafana/grafana/pkg/apimachinery/utils"
 	grafanaregistry "github.com/grafana/grafana/pkg/apiserver/registry/generic"
 	grafanarest "github.com/grafana/grafana/pkg/apiserver/rest"
 	"github.com/grafana/grafana/pkg/registry/apis/dashboard/legacy"
 	"github.com/grafana/grafana/pkg/storage/unified/apistore"
 	"github.com/grafana/grafana/pkg/storage/unified/resource"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apiserver/pkg/registry/generic"
-	genericregistry "k8s.io/apiserver/pkg/registry/generic/registry"
-	"k8s.io/apiserver/pkg/registry/rest"
 )
 
 type dashboardStorage struct {
@@ -46,24 +46,5 @@ func (s *dashboardStorage) newStore(scheme *runtime.Scheme, defaultOptsGetter ge
 		defaultOpts.StorageConfig.Config,
 	)
 
-	strategy := grafanaregistry.NewStrategy(scheme, resourceInfo.GroupVersion())
+	return grafanaregistry.NewRegistryStore(scheme, resourceInfo, optsGetter)
-	store := &genericregistry.Store{
-		NewFunc:                   resourceInfo.NewFunc,
-		NewListFunc:               resourceInfo.NewListFunc,
-		KeyRootFunc:               grafanaregistry.KeyRootFunc(resourceInfo.GroupResource()),
-		KeyFunc:                   grafanaregistry.NamespaceKeyFunc(resourceInfo.GroupResource()),
-		PredicateFunc:             grafanaregistry.Matcher,
-		DefaultQualifiedResource:  resourceInfo.GroupResource(),
-		SingularQualifiedResource: resourceInfo.SingularGroupResource(),
-		CreateStrategy:            strategy,
-		UpdateStrategy:            strategy,
-		DeleteStrategy:            strategy,
-		TableConvertor:            s.tableConverter,
-	}
-
-	options := &generic.StoreOptions{RESTOptions: optsGetter}
-	if err := store.CompleteWithOptions(options); err != nil {
-		return nil, err
-	}
-	return store, err
 }

pkg/registry/apis/dashboard/register.go

@@ -140,15 +140,10 @@ func (b *DashboardsAPIBuilder) UpdateAPIGroupInfo(apiGroupInfo *genericapiserver
 
 	// Dual writes if a RESTOptionsGetter is provided
 	if optsGetter != nil && dualWriteBuilder != nil {
-		store, err := newStorage(scheme)
+		store, err := grafanaregistry.NewRegistryStore(scheme, dash, optsGetter)
 		if err != nil {
 			return err
 		}
-
-		options := &generic.StoreOptions{RESTOptions: optsGetter, AttrFunc: grafanaregistry.GetAttrs}
-		if err := store.CompleteWithOptions(options); err != nil {
-			return err
-		}
 		storage[dash.StoragePath()], err = dualWriteBuilder(dash.GroupResource(), legacyStore, store)
 		if err != nil {
 			return err

pkg/registry/apis/dashboard/storage.go

@@ -1,35 +0,0 @@
-package dashboard
-
-import (
-	dashboard "github.com/grafana/grafana/pkg/apis/dashboard/v0alpha1"
-	grafanaregistry "github.com/grafana/grafana/pkg/apiserver/registry/generic"
-	grafanarest "github.com/grafana/grafana/pkg/apiserver/rest"
-	"k8s.io/apimachinery/pkg/runtime"
-	genericregistry "k8s.io/apiserver/pkg/registry/generic/registry"
-)
-
-var _ grafanarest.Storage = (*storage)(nil)
-
-type storage struct {
-	*genericregistry.Store
-}
-
-func newStorage(scheme *runtime.Scheme) (*storage, error) {
-	resourceInfo := dashboard.DashboardResourceInfo
-	strategy := grafanaregistry.NewStrategy(scheme, resourceInfo.GroupVersion())
-	store := &genericregistry.Store{
-		NewFunc:                   resourceInfo.NewFunc,
-		NewListFunc:               resourceInfo.NewListFunc,
-		KeyRootFunc:               grafanaregistry.KeyRootFunc(resourceInfo.GroupResource()),
-		KeyFunc:                   grafanaregistry.NamespaceKeyFunc(resourceInfo.GroupResource()),
-		PredicateFunc:             grafanaregistry.Matcher,
-		DefaultQualifiedResource:  resourceInfo.GroupResource(),
-		SingularQualifiedResource: resourceInfo.SingularGroupResource(),
-		CreateStrategy:            strategy,
-		UpdateStrategy:            strategy,
-		DeleteStrategy:            strategy,
-		TableConvertor:            resourceInfo.TableConverter(),
-	}
-
-	return &storage{Store: store}, nil
-}

pkg/registry/apis/folders/register.go

@@ -16,6 +16,7 @@ import (
 
 	"github.com/grafana/grafana/pkg/apimachinery/identity"
 	"github.com/grafana/grafana/pkg/apis/folder/v0alpha1"
+	grafanaregistry "github.com/grafana/grafana/pkg/apiserver/registry/generic"
 	grafanarest "github.com/grafana/grafana/pkg/apiserver/rest"
 	"github.com/grafana/grafana/pkg/services/accesscontrol"
 	"github.com/grafana/grafana/pkg/services/apiserver/builder"
@@ -109,7 +110,7 @@ func (b *FolderAPIBuilder) UpdateAPIGroupInfo(apiGroupInfo *genericapiserver.API
 
 	// enable dual writer
 	if optsGetter != nil && dualWriteBuilder != nil {
-		store, err := newStorage(scheme, optsGetter, legacyStore)
+		store, err := grafanaregistry.NewRegistryStore(scheme, resourceInfo, optsGetter)
 		if err != nil {
 			return err
 		}

pkg/registry/apis/folders/storage.go

@@ -1,40 +0,0 @@
-package folders
-
-import (
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apiserver/pkg/registry/generic"
-	genericregistry "k8s.io/apiserver/pkg/registry/generic/registry"
-
-	grafanaregistry "github.com/grafana/grafana/pkg/apiserver/registry/generic"
-	grafanarest "github.com/grafana/grafana/pkg/apiserver/rest"
-)
-
-var _ grafanarest.Storage = (*storage)(nil)
-
-type storage struct {
-	*genericregistry.Store
-}
-
-func newStorage(scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter, legacy *legacyStorage) (*storage, error) {
-	strategy := grafanaregistry.NewStrategy(scheme, resourceInfo.GroupVersion())
-
-	store := &genericregistry.Store{
-		NewFunc:                   resourceInfo.NewFunc,
-		NewListFunc:               resourceInfo.NewListFunc,
-		KeyRootFunc:               grafanaregistry.KeyRootFunc(resourceInfo.GroupResource()),
-		KeyFunc:                   grafanaregistry.NamespaceKeyFunc(resourceInfo.GroupResource()),
-		PredicateFunc:             grafanaregistry.Matcher,
-		DefaultQualifiedResource:  resourceInfo.GroupResource(),
-		SingularQualifiedResource: resourceInfo.SingularGroupResource(),
-		TableConvertor:            legacy.tableConverter,
-
-		CreateStrategy: strategy,
-		UpdateStrategy: strategy,
-		DeleteStrategy: strategy,
-	}
-	options := &generic.StoreOptions{RESTOptions: optsGetter, AttrFunc: grafanaregistry.GetAttrs}
-	if err := store.CompleteWithOptions(options); err != nil {
-		return nil, err
-	}
-	return &storage{Store: store}, nil
-}

pkg/registry/apis/peakq/register.go

@@ -1,6 +1,7 @@
 package peakq
 
 import (
+	"github.com/prometheus/client_golang/prometheus"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -12,9 +13,8 @@ import (
 	"k8s.io/kube-openapi/pkg/spec3"
 	"k8s.io/kube-openapi/pkg/validation/spec"
 
-	"github.com/prometheus/client_golang/prometheus"
-
 	peakq "github.com/grafana/grafana/pkg/apis/peakq/v0alpha1"
+	grafanaregistry "github.com/grafana/grafana/pkg/apiserver/registry/generic"
 	grafanarest "github.com/grafana/grafana/pkg/apiserver/rest"
 	"github.com/grafana/grafana/pkg/services/apiserver/builder"
 	"github.com/grafana/grafana/pkg/services/featuremgmt"
@@ -68,10 +68,12 @@ func (b *PeakQAPIBuilder) InstallSchema(scheme *runtime.Scheme) error {
 func (b *PeakQAPIBuilder) UpdateAPIGroupInfo(apiGroupInfo *genericapiserver.APIGroupInfo, scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter, _ grafanarest.DualWriteBuilder) error {
 	resourceInfo := peakq.QueryTemplateResourceInfo
 	storage := map[string]rest.Storage{}
-	peakqStorage, err := newStorage(scheme, optsGetter)
+
+	peakqStorage, err := grafanaregistry.NewRegistryStore(scheme, resourceInfo, optsGetter)
 	if err != nil {
 		return err
 	}
+
 	storage[resourceInfo.StoragePath()] = peakqStorage
 	storage[resourceInfo.StoragePath("render")] = &renderREST{
 		getter: peakqStorage,

pkg/registry/apis/peakq/storage.go

@@ -1,41 +0,0 @@
-package peakq
-
-import (
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apiserver/pkg/registry/generic"
-	genericregistry "k8s.io/apiserver/pkg/registry/generic/registry"
-
-	peakq "github.com/grafana/grafana/pkg/apis/peakq/v0alpha1"
-	grafanaregistry "github.com/grafana/grafana/pkg/apiserver/registry/generic"
-	grafanarest "github.com/grafana/grafana/pkg/apiserver/rest"
-)
-
-var _ grafanarest.Storage = (*storage)(nil)
-
-type storage struct {
-	*genericregistry.Store
-}
-
-func newStorage(scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter) (*storage, error) {
-	resourceInfo := peakq.QueryTemplateResourceInfo
-	strategy := grafanaregistry.NewStrategy(scheme, resourceInfo.GroupVersion())
-
-	store := &genericregistry.Store{
-		NewFunc:                   resourceInfo.NewFunc,
-		NewListFunc:               resourceInfo.NewListFunc,
-		KeyRootFunc:               grafanaregistry.KeyRootFunc(resourceInfo.GroupResource()),
-		KeyFunc:                   grafanaregistry.NamespaceKeyFunc(resourceInfo.GroupResource()),
-		PredicateFunc:             grafanaregistry.Matcher,
-		DefaultQualifiedResource:  resourceInfo.GroupResource(),
-		SingularQualifiedResource: resourceInfo.SingularGroupResource(),
-		TableConvertor:            resourceInfo.TableConverter(),
-		CreateStrategy:            strategy,
-		UpdateStrategy:            strategy,
-		DeleteStrategy:            strategy,
-	}
-	options := &generic.StoreOptions{RESTOptions: optsGetter, AttrFunc: grafanaregistry.GetAttrs}
-	if err := store.CompleteWithOptions(options); err != nil {
-		return nil, err
-	}
-	return &storage{Store: store}, nil
-}

pkg/registry/apis/playlist/storage.go

@@ -4,52 +4,28 @@ import (
 	"strings"
 
 	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apiserver/pkg/registry/generic"
 	genericregistry "k8s.io/apiserver/pkg/registry/generic/registry"
 
 	playlist "github.com/grafana/grafana/apps/playlist/apis/playlist/v0alpha1"
+	"github.com/grafana/grafana/pkg/apimachinery/utils"
 	grafanaregistry "github.com/grafana/grafana/pkg/apiserver/registry/generic"
-	grafanarest "github.com/grafana/grafana/pkg/apiserver/rest"
 )
 
-var _ grafanarest.Storage = (*storage)(nil)
+func newStorage(scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter, legacy *legacyStorage) (*genericregistry.Store, error) {
-
+	kind := playlist.PlaylistKind()
-type storage struct {
+	singular := strings.ToLower(kind.Kind()) // ???
-	*genericregistry.Store
+	resourceInfo := utils.NewResourceInfo(
-}
+		kind.Group(), kind.Version(),
-
+		kind.GroupVersionResource().Resource, singular,
-func newStorage(scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter, legacy *legacyStorage) (*storage, error) {
+		kind.Kind(),
-	gr := schema.GroupResource{
+		func() runtime.Object {
-		Group:    playlist.PlaylistKind().Group(),
+			return kind.ZeroValue()
-		Resource: playlist.PlaylistKind().Plural(),
-	}
-	singularGR := schema.GroupResource{
-		Group:    playlist.PlaylistKind().Group(),
-		Resource: strings.ToLower(playlist.PlaylistKind().Kind()),
-	}
-	strategy := grafanaregistry.NewStrategy(scheme, gr.WithVersion(playlist.PlaylistKind().Version()).GroupVersion())
-	store := &genericregistry.Store{
-		NewFunc: func() runtime.Object {
-			return playlist.PlaylistKind().ZeroValue()
 		},
-		NewListFunc: func() runtime.Object {
+		func() runtime.Object {
-			return playlist.PlaylistKind().ZeroListValue()
+			return kind.ZeroListValue()
 		},
-		KeyRootFunc:               grafanaregistry.KeyRootFunc(gr),
+		utils.TableColumns{}, // will use default columns... TODO? legacy.tableConverter.,
-		KeyFunc:                   grafanaregistry.NamespaceKeyFunc(gr),
+	)
-		PredicateFunc:             grafanaregistry.Matcher,
+	return grafanaregistry.NewRegistryStore(scheme, resourceInfo, optsGetter)
-		DefaultQualifiedResource:  gr,
-		SingularQualifiedResource: singularGR,
-		TableConvertor:            legacy.tableConverter,
-
-		CreateStrategy: strategy,
-		UpdateStrategy: strategy,
-		DeleteStrategy: strategy,
-	}
-	options := &generic.StoreOptions{RESTOptions: optsGetter, AttrFunc: grafanaregistry.GetAttrs}
-	if err := store.CompleteWithOptions(options); err != nil {
-		return nil, err
-	}
-	return &storage{Store: store}, nil
 }

pkg/registry/apis/service/register.go

@@ -1,6 +1,7 @@
 package service
 
 import (
+	"github.com/prometheus/client_golang/prometheus"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -10,9 +11,8 @@ import (
 	genericapiserver "k8s.io/apiserver/pkg/server"
 	"k8s.io/kube-openapi/pkg/common"
 
-	"github.com/prometheus/client_golang/prometheus"
-
 	service "github.com/grafana/grafana/pkg/apis/service/v0alpha1"
+	grafanaregistry "github.com/grafana/grafana/pkg/apiserver/registry/generic"
 	grafanarest "github.com/grafana/grafana/pkg/apiserver/rest"
 	"github.com/grafana/grafana/pkg/services/apiserver/builder"
 	"github.com/grafana/grafana/pkg/services/featuremgmt"
@@ -73,10 +73,12 @@ func (b *ServiceAPIBuilder) InstallSchema(scheme *runtime.Scheme) error {
 func (b *ServiceAPIBuilder) UpdateAPIGroupInfo(apiGroupInfo *genericapiserver.APIGroupInfo, scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter, _ grafanarest.DualWriteBuilder) error {
 	resourceInfo := service.ExternalNameResourceInfo
 	storage := map[string]rest.Storage{}
-	serviceStorage, err := newStorage(scheme, optsGetter)
+
+	serviceStorage, err := grafanaregistry.NewRegistryStore(scheme, resourceInfo, optsGetter)
 	if err != nil {
 		return err
 	}
+
 	storage[resourceInfo.StoragePath()] = serviceStorage
 	apiGroupInfo.VersionedResourcesStorageMap[service.VERSION] = storage
 	return nil

pkg/registry/apis/service/storage.go

@@ -1,41 +0,0 @@
-package service
-
-import (
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apiserver/pkg/registry/generic"
-	genericregistry "k8s.io/apiserver/pkg/registry/generic/registry"
-
-	service "github.com/grafana/grafana/pkg/apis/service/v0alpha1"
-	grafanaregistry "github.com/grafana/grafana/pkg/apiserver/registry/generic"
-	grafanarest "github.com/grafana/grafana/pkg/apiserver/rest"
-)
-
-var _ grafanarest.Storage = (*storage)(nil)
-
-type storage struct {
-	*genericregistry.Store
-}
-
-func newStorage(scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter) (*storage, error) {
-	resourceInfo := service.ExternalNameResourceInfo
-	strategy := grafanaregistry.NewStrategy(scheme, resourceInfo.GroupVersion())
-
-	store := &genericregistry.Store{
-		NewFunc:                   resourceInfo.NewFunc,
-		NewListFunc:               resourceInfo.NewListFunc,
-		KeyRootFunc:               grafanaregistry.KeyRootFunc(resourceInfo.GroupResource()),
-		KeyFunc:                   grafanaregistry.NamespaceKeyFunc(resourceInfo.GroupResource()),
-		PredicateFunc:             grafanaregistry.Matcher,
-		DefaultQualifiedResource:  resourceInfo.GroupResource(),
-		SingularQualifiedResource: resourceInfo.SingularGroupResource(),
-		TableConvertor:            resourceInfo.TableConverter(),
-		CreateStrategy:            strategy,
-		UpdateStrategy:            strategy,
-		DeleteStrategy:            strategy,
-	}
-	options := &generic.StoreOptions{RESTOptions: optsGetter, AttrFunc: grafanaregistry.GetAttrs}
-	if err := store.CompleteWithOptions(options); err != nil {
-		return nil, err
-	}
-	return &storage{Store: store}, nil
-}