K8s: Add explicit table converter (#77098)

pkg/apis/playlist/v0alpha1/legacy_storage.go

@@ -22,8 +22,9 @@ var (
 )
 
 type legacyStorage struct {
-	service    playlist.Service
-	namespacer namespaceMapper
+	service        playlist.Service
+	namespacer     namespaceMapper
+	tableConverter rest.TableConvertor
 }
 
 func (s *legacyStorage) New() runtime.Object {
@@ -45,7 +46,7 @@ func (s *legacyStorage) NewList() runtime.Object {
 }
 
 func (s *legacyStorage) ConvertToTable(ctx context.Context, object runtime.Object, tableOptions runtime.Object) (*metav1.Table, error) {
-	return rest.NewDefaultTableConvertor(Resource("playlists")).ConvertToTable(ctx, object, tableOptions)
+	return s.tableConverter.ConvertToTable(ctx, object, tableOptions)
 }
 
 func (s *legacyStorage) List(ctx context.Context, options *internalversion.ListOptions) (runtime.Object, error) {

pkg/apis/playlist/v0alpha1/register.go

@@ -1,6 +1,9 @@
 package v0alpha1
 
 import (
+	"fmt"
+	"time"
+
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -12,6 +15,7 @@ import (
 
 	grafanaapiserver "github.com/grafana/grafana/pkg/services/grafana-apiserver"
 	grafanarest "github.com/grafana/grafana/pkg/services/grafana-apiserver/rest"
+	"github.com/grafana/grafana/pkg/services/grafana-apiserver/utils"
 	"github.com/grafana/grafana/pkg/services/playlist"
 	"github.com/grafana/grafana/pkg/setting"
 )
@@ -26,6 +30,7 @@ var _ grafanaapiserver.APIGroupBuilder = (*PlaylistAPIBuilder)(nil)
 type PlaylistAPIBuilder struct {
 	service    playlist.Service
 	namespacer namespaceMapper
+	gv         schema.GroupVersion
 }
 
 func RegisterAPIService(p playlist.Service,
@@ -35,22 +40,23 @@ func RegisterAPIService(p playlist.Service,
 	builder := &PlaylistAPIBuilder{
 		service:    p,
 		namespacer: getNamespaceMapper(cfg),
+		gv:         schema.GroupVersion{Group: GroupName, Version: VersionID},
 	}
 	apiregistration.RegisterAPI(builder)
 	return builder
 }
 
 func (b *PlaylistAPIBuilder) GetGroupVersion() schema.GroupVersion {
-	return SchemeGroupVersion
+	return b.gv
 }
 
 func (b *PlaylistAPIBuilder) InstallSchema(scheme *runtime.Scheme) error {
-	scheme.AddKnownTypes(SchemeGroupVersion,
+	scheme.AddKnownTypes(b.gv,
 		&Playlist{},
 		&PlaylistList{},
 	)
-	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
-	return scheme.SetVersionPriority(SchemeGroupVersion)
+	metav1.AddToGroupVersion(scheme, b.gv)
+	return scheme.SetVersionPriority(b.gv)
 }
 
 func (b *PlaylistAPIBuilder) GetAPIGroupInfo(
@@ -64,12 +70,34 @@ func (b *PlaylistAPIBuilder) GetAPIGroupInfo(
 	legacyStore := &legacyStorage{
 		service:    b.service,
 		namespacer: b.namespacer,
+		tableConverter: utils.NewTableConverter(
+			b.gv.WithResource("playlists").GroupResource(),
+			[]metav1.TableColumnDefinition{
+				{Name: "Name", Type: "string", Format: "name"},
+				{Name: "Title", Type: "string", Format: "string", Description: "The playlist name"},
+				{Name: "Interval", Type: "string", Format: "string", Description: "How often the playlist will update"},
+				{Name: "Created At", Type: "date"},
+			},
+			func(obj runtime.Object) ([]interface{}, error) {
+				m, ok := obj.(*Playlist)
+				if !ok {
+					return nil, fmt.Errorf("expected playlist")
+				}
+				return []interface{}{
+					m.Name,
+					m.Spec.Title,
+					m.Spec.Interval,
+					m.CreationTimestamp.UTC().Format(time.RFC3339),
+				}, nil
+			},
+		),
 	}
 	storage["playlists"] = legacyStore
 
 	// enable dual writes if a RESTOptionsGetter is provided
 	if optsGetter != nil {
-		store, err := newStorage(scheme, optsGetter)
+		store, err := newStorage(scheme, optsGetter, b.gv)
+		store.TableConvertor = legacyStore.tableConverter
 		if err != nil {
 			return nil, err
 		}
@@ -87,11 +115,3 @@ func (b *PlaylistAPIBuilder) GetOpenAPIDefinitions() common.GetOpenAPIDefinition
 func (b *PlaylistAPIBuilder) GetAPIRoutes() *grafanaapiserver.APIRoutes {
 	return nil // no custom API routes
 }
-
-// SchemeGroupVersion is group version used to register these objects
-var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: VersionID}
-
-// Resource takes an unqualified resource and returns a Group qualified GroupResource
-func Resource(resource string) schema.GroupResource {
-	return SchemeGroupVersion.WithResource(resource).GroupResource()
-}

pkg/apis/playlist/v0alpha1/storage.go

@@ -2,9 +2,9 @@ package v0alpha1
 
 import (
 	"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"
-	"k8s.io/apiserver/pkg/registry/rest"
 
 	grafanaregistry "github.com/grafana/grafana/pkg/services/grafana-apiserver/registry/generic"
 	grafanarest "github.com/grafana/grafana/pkg/services/grafana-apiserver/rest"
@@ -16,21 +16,19 @@ type storage struct {
 	*genericregistry.Store
 }
 
-func newStorage(scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter) (*storage, error) {
+func newStorage(scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter, gv schema.GroupVersion) (*storage, error) {
 	strategy := grafanaregistry.NewStrategy(scheme)
 
 	store := &genericregistry.Store{
 		NewFunc:                   func() runtime.Object { return &Playlist{} },
 		NewListFunc:               func() runtime.Object { return &PlaylistList{} },
 		PredicateFunc:             grafanaregistry.Matcher,
-		DefaultQualifiedResource:  Resource("playlists"),
-		SingularQualifiedResource: Resource("playlist"),
+		DefaultQualifiedResource:  gv.WithResource("playlists").GroupResource(),
+		SingularQualifiedResource: gv.WithResource("playlist").GroupResource(),
 
 		CreateStrategy: strategy,
 		UpdateStrategy: strategy,
 		DeleteStrategy: strategy,
-
-		TableConvertor: rest.NewDefaultTableConvertor(Resource("playlists")),
 	}
 	options := &generic.StoreOptions{RESTOptions: optsGetter, AttrFunc: grafanaregistry.GetAttrs}
 	if err := store.CompleteWithOptions(options); err != nil {