Merge pull request #41544 from sttts/sttts-core-group-announce-registered

Automatic merge from submit-queue (batch tested with PRs 41505, 41484, 41544, 41514, 41022)

pkg/api/install: use apimachinery/announce+registered

Make core group a little bit less special.

pkg/api/install/BUILD

@@ -15,11 +15,9 @@ go_library(
     deps = [
         "//pkg/api:go_default_library",
         "//pkg/api/v1:go_default_library",
-        "//vendor:github.com/golang/glog",
+        "//vendor:k8s.io/apimachinery/pkg/apimachinery/announced",
-        "//vendor:k8s.io/apimachinery/pkg/api/meta",
+        "//vendor:k8s.io/apimachinery/pkg/apimachinery/registered",
-        "//vendor:k8s.io/apimachinery/pkg/apimachinery",
         "//vendor:k8s.io/apimachinery/pkg/runtime",
-        "//vendor:k8s.io/apimachinery/pkg/runtime/schema",
         "//vendor:k8s.io/apimachinery/pkg/util/sets",
     ],
 )
@@ -31,6 +29,7 @@ go_test(
     tags = ["automanaged"],
     deps = [
         "//pkg/api:go_default_library",
+        "//pkg/api/v1:go_default_library",
         "//vendor:k8s.io/apimachinery/pkg/apis/meta/v1",
         "//vendor:k8s.io/apimachinery/pkg/runtime",
         "//vendor:k8s.io/apimachinery/pkg/runtime/schema",

pkg/api/install/install.go

@@ -19,135 +19,52 @@ limitations under the License.
 package install
 
 import (
-	"fmt"
+	"k8s.io/apimachinery/pkg/apimachinery/announced"
-
+	"k8s.io/apimachinery/pkg/apimachinery/registered"
-	"github.com/golang/glog"
-
-	"k8s.io/apimachinery/pkg/api/meta"
-	"k8s.io/apimachinery/pkg/apimachinery"
 	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/v1"
 )
 
-const importPrefix = "k8s.io/kubernetes/pkg/api"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []schema.GroupVersion{v1.SchemeGroupVersion}
-
 func init() {
-	api.Registry.RegisterVersions(availableVersions)
+	Install(api.GroupFactoryRegistry, api.Registry, api.Scheme)
-	externalVersions := []schema.GroupVersion{}
-	for _, v := range availableVersions {
-		if api.Registry.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.V(4).Infof("No version is registered for group %v", api.GroupName)
-		return
-	}
-
-	if err := api.Registry.EnableVersions(externalVersions...); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		glog.V(4).Infof("%v", err)
-		return
-	}
 }
 
-// TODO: enableVersions should be centralized rather than spread in each API
+// Install registers the API group and adds types to a scheme
-// group.
+func Install(groupFactoryRegistry announced.APIGroupFactoryRegistry, registry *registered.APIRegistrationManager, scheme *runtime.Scheme) {
-// We can combine api.Registry.RegisterVersions, api.Registry.EnableVersions and
+	if err := announced.NewGroupMetaFactory(
-// api.Registry.RegisterGroup once we have moved enableVersions there.
+		&announced.GroupMetaFactoryArgs{
-func enableVersions(externalVersions []schema.GroupVersion) error {
+			GroupName:                  api.GroupName,
-	addVersionsToScheme(externalVersions...)
+			VersionPreferenceOrder:     []string{v1.SchemeGroupVersion.Version},
-	preferredExternalVersion := externalVersions[0]
+			ImportPrefix:               "k8s.io/kubernetes/pkg/api",
-
+			AddInternalObjectsToScheme: api.AddToScheme,
-	groupMeta := apimachinery.GroupMeta{
+			RootScopedKinds: sets.NewString(
-		GroupVersion:  preferredExternalVersion,
+				"Node",
-		GroupVersions: externalVersions,
+				"Namespace",
-		RESTMapper:    newRESTMapper(externalVersions),
+				"PersistentVolume",
-		SelfLinker:    runtime.SelfLinker(accessor),
+				"ComponentStatus",
-		InterfacesFor: interfacesFor,
+			),
-	}
+			IgnoredKinds: sets.NewString(
-
+				"ListOptions",
-	if err := api.Registry.RegisterGroup(groupMeta); err != nil {
+				"DeleteOptions",
-		return err
+				"Status",
-	}
+				"PodLogOptions",
-	return nil
+				"PodExecOptions",
-}
+				"PodAttachOptions",
-
+				"PodPortForwardOptions",
-func newRESTMapper(externalVersions []schema.GroupVersion) meta.RESTMapper {
+				"PodProxyOptions",
-	// the list of kinds that are scoped at the root of the api hierarchy
+				"NodeProxyOptions",
-	// if a kind is not enumerated here, it is assumed to have a namespace scope
+				"ServiceProxyOptions",
-	rootScoped := sets.NewString(
+				"ThirdPartyResource",
-		"Node",
+				"ThirdPartyResourceData",
-		"Namespace",
+				"ThirdPartyResourceList",
-		"PersistentVolume",
+			),
-		"ComponentStatus",
+		},
-	)
+		announced.VersionToSchemeFunc{
-
+			v1.SchemeGroupVersion.Version: v1.AddToScheme,
-	// these kinds should be excluded from the list of resources
+		},
-	ignoredKinds := sets.NewString(
+	).Announce(groupFactoryRegistry).RegisterAndEnable(registry, scheme); err != nil {
-		"ListOptions",
-		"DeleteOptions",
-		"Status",
-		"PodLogOptions",
-		"PodExecOptions",
-		"PodAttachOptions",
-		"PodPortForwardOptions",
-		"PodProxyOptions",
-		"NodeProxyOptions",
-		"ServiceProxyOptions",
-		"ThirdPartyResource",
-		"ThirdPartyResourceData",
-		"ThirdPartyResourceList")
-
-	mapper := meta.NewDefaultRESTMapperFromScheme(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped, api.Scheme)
-
-	return mapper
-}
-
-// InterfacesFor returns the default Codec and ResourceVersioner for a given version
-// string, or an error if the version is not known.
-func interfacesFor(version schema.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case v1.SchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  api.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-	default:
-		g, _ := api.Registry.Group(api.GroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
-	}
-}
-
-func addVersionsToScheme(externalVersions ...schema.GroupVersion) {
-	// add the internal version to Scheme
-	if err := api.AddToScheme(api.Scheme); err != nil {
-		// Programmer error, detect immediately
 		panic(err)
 	}
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !api.Registry.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case v1.SchemeGroupVersion:
-			if err := v1.AddToScheme(api.Scheme); err != nil {
-				// Programmer error, detect immediately
-				panic(err)
-			}
-		}
-	}
 }

pkg/api/install/install_test.go

@@ -25,9 +25,20 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	internal "k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/api/v1"
 )
 
 func TestResourceVersioner(t *testing.T) {
+	g, err := internal.Registry.Group(v1.GroupName)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	intf, err := g.DefaultInterfacesFor(v1.SchemeGroupVersion)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	accessor := intf.MetadataAccessor
+
 	pod := internal.Pod{ObjectMeta: metav1.ObjectMeta{ResourceVersion: "10"}}
 	version, err := accessor.ResourceVersion(&pod)
 	if err != nil {