import prefix

pkg/api/legacy/install.go

@@ -0,0 +1,78 @@
+package legacy
+
+import (
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/apimachinery"
+	"k8s.io/apimachinery/pkg/apimachinery/registered"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/sets"
+	kapi "k8s.io/kubernetes/pkg/api"
+)
+
+var (
+	accessor = meta.NewAccessor()
+	coreV1   = schema.GroupVersion{Group: "", Version: "v1"}
+)
+
+func InstallLegacy(group string, addToCore, addToCoreV1 func(*runtime.Scheme) error, rootScopedKinds sets.String, registry *registered.APIRegistrationManager, scheme *runtime.Scheme) {
+	interfacesFor := interfacesForGroup(group)
+
+	// install core V1 types temporarily into a local scheme to enumerate them
+	mapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{coreV1}, interfacesFor)
+	localScheme := runtime.NewScheme()
+	if err := addToCoreV1(localScheme); err != nil {
+		panic(err)
+	}
+	for kind := range localScheme.KnownTypes(coreV1) {
+		scope := meta.RESTScopeNamespace
+		if rootScopedKinds.Has(kind) {
+			scope = meta.RESTScopeRoot
+		}
+		mapper.Add(coreV1.WithKind(kind), scope)
+	}
+
+	// register core v1 version. Should be done by kube (if the import dependencies are right).
+	registry.RegisterVersions([]schema.GroupVersion{coreV1})
+	if err := registry.EnableVersions(coreV1); err != nil {
+		panic(err)
+	}
+
+	// register types as core v1
+	if err := addToCore(scheme); err != nil {
+		panic(err)
+	}
+	if err := addToCoreV1(scheme); err != nil {
+		panic(err)
+	}
+
+	// add to group
+	legacyGroupMeta := apimachinery.GroupMeta{
+		GroupVersion:  coreV1,
+		GroupVersions: []schema.GroupVersion{coreV1},
+		RESTMapper:    mapper,
+		SelfLinker:    runtime.SelfLinker(accessor),
+		InterfacesFor: interfacesFor,
+	}
+	if err := registry.RegisterGroup(legacyGroupMeta); err != nil {
+		panic(err)
+	}
+}
+
+func interfacesForGroup(group string) func(version schema.GroupVersion) (*meta.VersionInterfaces, error) {
+	return func(version schema.GroupVersion) (*meta.VersionInterfaces, error) {
+		switch version {
+		case coreV1:
+			return &meta.VersionInterfaces{
+				ObjectConvertor:  kapi.Scheme,
+				MetadataAccessor: accessor,
+			}, nil
+
+		default:
+			g, _ := kapi.Registry.Group(group)
+			return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
+		}
+	}
+}

pkg/apps/apis/apps/install/install.go

@@ -1,109 +1,34 @@
 package install
 
 import (
-	"fmt"
-
-	"github.com/golang/glog"
-
-	"k8s.io/apimachinery/pkg/api/meta"
-	"k8s.io/apimachinery/pkg/apimachinery"
+	"k8s.io/apimachinery/pkg/apimachinery/announced"
+	"k8s.io/apimachinery/pkg/apimachinery/registered"
 	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/sets"
 	kapi "k8s.io/kubernetes/pkg/api"
 
+	legacy "github.com/openshift/origin/pkg/api/legacy"
 	deployapi "github.com/openshift/origin/pkg/apps/apis/apps"
 	deployapiv1 "github.com/openshift/origin/pkg/apps/apis/apps/v1"
+	"k8s.io/apimachinery/pkg/util/sets"
 )
 
-const importPrefix = "github.com/openshift/origin/pkg/apps/apis/apps"
-
-var accessor = meta.NewAccessor()
-
-// availableVersions lists all known external versions for this group from most preferred to least preferred
-var availableVersions = []schema.GroupVersion{deployapiv1.LegacySchemeGroupVersion}
-
 func init() {
-	kapi.Registry.RegisterVersions(availableVersions)
-	externalVersions := []schema.GroupVersion{}
-	for _, v := range availableVersions {
-		if kapi.Registry.IsAllowedVersion(v) {
-			externalVersions = append(externalVersions, v)
-		}
-	}
-	if len(externalVersions) == 0 {
-		glog.Infof("No version is registered for group %v", deployapi.LegacyGroupName)
-		return
-	}
-
-	if err := kapi.Registry.EnableVersions(externalVersions...); err != nil {
-		panic(err)
-	}
-	if err := enableVersions(externalVersions); err != nil {
-		panic(err)
-	}
-
-	installApiGroup()
+	legacy.InstallLegacy(deployapi.GroupName, deployapi.AddToSchemeInCoreGroup, deployapiv1.AddToSchemeInCoreGroup, sets.NewString(), kapi.Registry, kapi.Scheme)
+	Install(kapi.GroupFactoryRegistry, kapi.Registry, kapi.Scheme)
 }
 
-// TODO: enableVersions should be centralized rather than spread in each API
-// group.
-// We can combine kapi.Registry.RegisterVersions, kapi.Registry.EnableVersions and
-// kapi.Registry.RegisterGroup once we have moved enableVersions there.
-func enableVersions(externalVersions []schema.GroupVersion) error {
-	addVersionsToScheme(externalVersions...)
-	preferredExternalVersion := externalVersions[0]
-
-	groupMeta := apimachinery.GroupMeta{
-		GroupVersion:  preferredExternalVersion,
-		GroupVersions: externalVersions,
-		RESTMapper:    newRESTMapper(externalVersions),
-		SelfLinker:    runtime.SelfLinker(accessor),
-		InterfacesFor: interfacesFor,
-	}
-
-	if err := kapi.Registry.RegisterGroup(groupMeta); err != nil {
-		return err
-	}
-	return nil
-}
-
-func addVersionsToScheme(externalVersions ...schema.GroupVersion) {
-	// add the internal version to Scheme
-	deployapi.AddToSchemeInCoreGroup(kapi.Scheme)
-	// add the enabled external versions to Scheme
-	for _, v := range externalVersions {
-		if !kapi.Registry.IsEnabledVersion(v) {
-			glog.Errorf("Version %s is not enabled, so it will not be added to the Scheme.", v)
-			continue
-		}
-		switch v {
-		case deployapiv1.LegacySchemeGroupVersion:
-			deployapiv1.AddToSchemeInCoreGroup(kapi.Scheme)
-
-		default:
-			glog.Errorf("Version %s is not known, so it will not be added to the Scheme.", v)
-			continue
-		}
-	}
-}
-
-func newRESTMapper(externalVersions []schema.GroupVersion) meta.RESTMapper {
-	rootScoped := sets.NewString()
-	ignoredKinds := sets.NewString()
-	return meta.NewDefaultRESTMapperFromScheme(externalVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped, kapi.Scheme)
-}
-
-func interfacesFor(version schema.GroupVersion) (*meta.VersionInterfaces, error) {
-	switch version {
-	case deployapiv1.LegacySchemeGroupVersion:
-		return &meta.VersionInterfaces{
-			ObjectConvertor:  kapi.Scheme,
-			MetadataAccessor: accessor,
-		}, nil
-
-	default:
-		g, _ := kapi.Registry.Group(deployapi.LegacyGroupName)
-		return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
+// Install registers the API group and adds types to a scheme
+func Install(groupFactoryRegistry announced.APIGroupFactoryRegistry, registry *registered.APIRegistrationManager, scheme *runtime.Scheme) {
+	if err := announced.NewGroupMetaFactory(
+		&announced.GroupMetaFactoryArgs{
+			GroupName:                  deployapi.GroupName,
+			VersionPreferenceOrder:     []string{deployapiv1.SchemeGroupVersion.Version},
+			AddInternalObjectsToScheme: deployapi.AddToScheme,
+		},
+		announced.VersionToSchemeFunc{
+			deployapiv1.SchemeGroupVersion.Version: deployapiv1.AddToScheme,
+		},
+	).Announce(groupFactoryRegistry).RegisterAndEnable(registry, scheme); err != nil {
+		panic(err)
 	}
 }