From 2f6f4d85d80b3f39d66e7e1674aeff71f8a68b3d Mon Sep 17 00:00:00 2001 From: David Eads Date: Tue, 3 Jul 2018 16:05:09 -0400 Subject: [PATCH] create install functions based on new runtime.Scheme --- .travis.yml | 2 +- Makefile | 17 +------ apps/install.go | 26 +++++++++++ apps/v1/legacy.go | 28 +++++++++++ apps/v1/register.go | 49 ++++++++------------ authorization/install.go | 26 +++++++++++ authorization/v1/legacy.go | 43 +++++++++++++++++ authorization/v1/register.go | 64 ++++++++------------------ build/install.go | 26 +++++++++++ build/v1/legacy.go | 28 +++++++++++ build/v1/register.go | 48 +++++++------------ config/install.go | 26 +++++++++++ config/v1/register.go | 26 +++++++---- image/install.go | 26 +++++++++++ image/v1/legacy.go | 33 +++++++++++++ image/v1/register.go | 51 +++++++------------- install.go | 42 +++++++++++++++++ network/install.go | 26 +++++++++++ network/v1/legacy.go | 27 +++++++++++ network/v1/register.go | 50 +++++++------------- oauth/install.go | 26 +++++++++++ oauth/v1/legacy.go | 30 ++++++++++++ oauth/v1/register.go | 50 +++++++------------- operator/install.go | 26 +++++++++++ operator/v1alpha1/register.go | 28 ++++++++--- pkg/testing/deepcopy_test.go | 30 ++++++------ pkg/testing/doc.go | 1 + project/install.go | 26 +++++++++++ project/v1/legacy.go | 23 +++++++++ project/v1/register.go | 45 ++++++++---------- quota/install.go | 26 +++++++++++ quota/v1/legacy.go | 24 ++++++++++ quota/v1/register.go | 52 ++++++++------------- route/install.go | 26 +++++++++++ route/v1/legacy.go | 22 +++++++++ route/v1/register.go | 44 ++++++++---------- security/install.go | 26 +++++++++++ security/v1/legacy.go | 25 ++++++++++ security/v1/register.go | 47 ++++++++----------- servicecertsigner/install.go | 26 +++++++++++ servicecertsigner/v1alpha1/register.go | 27 +++++++---- template/install.go | 26 +++++++++++ template/v1/legacy.go | 24 ++++++++++ template/v1/register.go | 46 ++++++++---------- user/install.go | 26 +++++++++++ user/v1/legacy.go | 27 +++++++++++ user/v1/register.go | 50 ++++++++------------ webconsole/install.go | 26 +++++++++++ webconsole/v1/register.go | 29 +++++++----- 49 files changed, 1097 insertions(+), 451 deletions(-) create mode 100644 apps/install.go create mode 100644 apps/v1/legacy.go create mode 100644 authorization/install.go create mode 100644 authorization/v1/legacy.go create mode 100644 build/install.go create mode 100644 build/v1/legacy.go create mode 100644 config/install.go create mode 100644 image/install.go create mode 100644 image/v1/legacy.go create mode 100644 install.go create mode 100644 network/install.go create mode 100644 network/v1/legacy.go create mode 100644 oauth/install.go create mode 100644 oauth/v1/legacy.go create mode 100644 operator/install.go create mode 100644 pkg/testing/doc.go create mode 100644 project/install.go create mode 100644 project/v1/legacy.go create mode 100644 quota/install.go create mode 100644 quota/v1/legacy.go create mode 100644 route/install.go create mode 100644 route/v1/legacy.go create mode 100644 security/install.go create mode 100644 security/v1/legacy.go create mode 100644 servicecertsigner/install.go create mode 100644 template/install.go create mode 100644 template/v1/legacy.go create mode 100644 user/install.go create mode 100644 user/v1/legacy.go create mode 100644 webconsole/install.go diff --git a/.travis.yml b/.travis.yml index 38c4f1bf955..11cca1b0cd6 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,7 +1,7 @@ language: go go: - - 1.8 + - "1.10" install: - wget https://github.com/google/protobuf/releases/download/v3.0.2/protoc-3.0.2-linux-x86_64.zip diff --git a/Makefile b/Makefile index 9380b6e2d27..c4980b81676 100644 --- a/Makefile +++ b/Makefile @@ -2,22 +2,7 @@ all: build .PHONY: all build: - go build github.com/openshift/api/authorization/... - go build github.com/openshift/api/apps/... - go build github.com/openshift/api/build/... - go build github.com/openshift/api/config/... - go build github.com/openshift/api/image/... - go build github.com/openshift/api/network/... - go build github.com/openshift/api/oauth/... - go build github.com/openshift/api/operator/... - go build github.com/openshift/api/project/... - go build github.com/openshift/api/quota/... - go build github.com/openshift/api/route/... - go build github.com/openshift/api/security/... - go build github.com/openshift/api/servicecertsigner/... - go build github.com/openshift/api/template/... - go build github.com/openshift/api/user/... - go build github.com/openshift/api/webconsole/... + go build github.com/openshift/api/... .PHONY: build test: diff --git a/apps/install.go b/apps/install.go new file mode 100644 index 00000000000..80f7ba2b2c9 --- /dev/null +++ b/apps/install.go @@ -0,0 +1,26 @@ +package apps + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + appsv1 "github.com/openshift/api/apps/v1" +) + +const ( + GroupName = "apps.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(appsv1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/apps/v1/legacy.go b/apps/v1/legacy.go new file mode 100644 index 00000000000..c8fa0ed999f --- /dev/null +++ b/apps/v1/legacy.go @@ -0,0 +1,28 @@ +package v1 + +import ( + corev1 "k8s.io/api/core/v1" + extensionsv1beta1 "k8s.io/api/extensions/v1beta1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + legacyGroupVersion = schema.GroupVersion{Group: "", Version: "v1"} + legacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes, corev1.AddToScheme, extensionsv1beta1.AddToScheme) + DeprecatedInstallWithoutGroup = legacySchemeBuilder.AddToScheme +) + +func addLegacyKnownTypes(scheme *runtime.Scheme) error { + types := []runtime.Object{ + &DeploymentConfig{}, + &DeploymentConfigList{}, + &DeploymentConfigRollback{}, + &DeploymentRequest{}, + &DeploymentLog{}, + &DeploymentLogOptions{}, + &extensionsv1beta1.Scale{}, + } + scheme.AddKnownTypes(legacyGroupVersion, types...) + return nil +} diff --git a/apps/v1/register.go b/apps/v1/register.go index 88e40b4d4a2..0c1e47e6d46 100644 --- a/apps/v1/register.go +++ b/apps/v1/register.go @@ -1,50 +1,37 @@ package v1 import ( + corev1 "k8s.io/api/core/v1" extensionsv1beta1 "k8s.io/api/extensions/v1beta1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" ) -const ( - LegacyGroupName = "" - GroupName = "apps.openshift.io" -) - var ( - SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} - LegacySchemeGroupVersion = schema.GroupVersion{Group: LegacyGroupName, Version: "v1"} - - LegacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes) - AddToSchemeInCoreGroup = LegacySchemeBuilder.AddToScheme - - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "apps.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, corev1.AddToScheme, extensionsv1beta1.AddToScheme) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() -} - -// Adds the list of known types to api.Scheme. -func addLegacyKnownTypes(scheme *runtime.Scheme) error { - types := []runtime.Object{ - &DeploymentConfig{}, - &DeploymentConfigList{}, - &DeploymentConfigRollback{}, - &DeploymentRequest{}, - &DeploymentLog{}, - &DeploymentLogOptions{}, - &extensionsv1beta1.Scale{}, - } - scheme.AddKnownTypes(LegacySchemeGroupVersion, types...) - return nil + return schema.GroupResource{Group: GroupName, Resource: resource} } // Adds the list of known types to api.Scheme. func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &DeploymentConfig{}, &DeploymentConfigList{}, &DeploymentConfigRollback{}, @@ -53,6 +40,6 @@ func addKnownTypes(scheme *runtime.Scheme) error { &DeploymentLogOptions{}, &extensionsv1beta1.Scale{}, ) - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) + metav1.AddToGroupVersion(scheme, GroupVersion) return nil } diff --git a/authorization/install.go b/authorization/install.go new file mode 100644 index 00000000000..2cb6e4369a4 --- /dev/null +++ b/authorization/install.go @@ -0,0 +1,26 @@ +package apps + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + authorizationv1 "github.com/openshift/api/authorization/v1" +) + +const ( + GroupName = "authorization.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(authorizationv1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/authorization/v1/legacy.go b/authorization/v1/legacy.go new file mode 100644 index 00000000000..f437a242ea8 --- /dev/null +++ b/authorization/v1/legacy.go @@ -0,0 +1,43 @@ +package v1 + +import ( + corev1 "k8s.io/api/core/v1" + rbacv1 "k8s.io/api/rbac/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + legacyGroupVersion = schema.GroupVersion{Group: "", Version: "v1"} + legacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes, corev1.AddToScheme, rbacv1.AddToScheme) + DeprecatedInstallWithoutGroup = legacySchemeBuilder.AddToScheme +) + +func addLegacyKnownTypes(scheme *runtime.Scheme) error { + types := []runtime.Object{ + &Role{}, + &RoleBinding{}, + &RoleBindingList{}, + &RoleList{}, + + &SelfSubjectRulesReview{}, + &SubjectRulesReview{}, + &ResourceAccessReview{}, + &SubjectAccessReview{}, + &LocalResourceAccessReview{}, + &LocalSubjectAccessReview{}, + &ResourceAccessReviewResponse{}, + &SubjectAccessReviewResponse{}, + &IsPersonalSubjectAccessReview{}, + + &ClusterRole{}, + &ClusterRoleBinding{}, + &ClusterRoleBindingList{}, + &ClusterRoleList{}, + + &RoleBindingRestriction{}, + &RoleBindingRestrictionList{}, + } + scheme.AddKnownTypes(legacyGroupVersion, types...) + return nil +} diff --git a/authorization/v1/register.go b/authorization/v1/register.go index 662322e8959..f1e12477b65 100644 --- a/authorization/v1/register.go +++ b/authorization/v1/register.go @@ -1,34 +1,37 @@ package v1 import ( + corev1 "k8s.io/api/core/v1" + rbacv1 "k8s.io/api/rbac/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" ) -const ( - GroupName = "authorization.openshift.io" - LegacyGroupName = "" -) - var ( - SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} - LegacySchemeGroupVersion = schema.GroupVersion{Group: LegacyGroupName, Version: "v1"} - - LegacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes) - AddToSchemeInCoreGroup = LegacySchemeBuilder.AddToScheme - - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "authorization.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, corev1.AddToScheme, rbacv1.AddToScheme) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() + return schema.GroupResource{Group: GroupName, Resource: resource} } // Adds the list of known types to api.Scheme. func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &Role{}, &RoleBinding{}, &RoleBindingList{}, @@ -52,35 +55,6 @@ func addKnownTypes(scheme *runtime.Scheme) error { &RoleBindingRestriction{}, &RoleBindingRestrictionList{}, ) - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) - return nil -} - -func addLegacyKnownTypes(scheme *runtime.Scheme) error { - types := []runtime.Object{ - &Role{}, - &RoleBinding{}, - &RoleBindingList{}, - &RoleList{}, - - &SelfSubjectRulesReview{}, - &SubjectRulesReview{}, - &ResourceAccessReview{}, - &SubjectAccessReview{}, - &LocalResourceAccessReview{}, - &LocalSubjectAccessReview{}, - &ResourceAccessReviewResponse{}, - &SubjectAccessReviewResponse{}, - &IsPersonalSubjectAccessReview{}, - - &ClusterRole{}, - &ClusterRoleBinding{}, - &ClusterRoleBindingList{}, - &ClusterRoleList{}, - - &RoleBindingRestriction{}, - &RoleBindingRestrictionList{}, - } - scheme.AddKnownTypes(LegacySchemeGroupVersion, types...) + metav1.AddToGroupVersion(scheme, GroupVersion) return nil } diff --git a/build/install.go b/build/install.go new file mode 100644 index 00000000000..87e2c26b0f1 --- /dev/null +++ b/build/install.go @@ -0,0 +1,26 @@ +package build + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + buildv1 "github.com/openshift/api/build/v1" +) + +const ( + GroupName = "build.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(buildv1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/build/v1/legacy.go b/build/v1/legacy.go new file mode 100644 index 00000000000..a74627d2cda --- /dev/null +++ b/build/v1/legacy.go @@ -0,0 +1,28 @@ +package v1 + +import ( + corev1 "k8s.io/api/core/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + legacyGroupVersion = schema.GroupVersion{Group: "", Version: "v1"} + legacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes, corev1.AddToScheme) + DeprecatedInstallWithoutGroup = legacySchemeBuilder.AddToScheme +) + +func addLegacyKnownTypes(scheme *runtime.Scheme) error { + types := []runtime.Object{ + &Build{}, + &BuildList{}, + &BuildConfig{}, + &BuildConfigList{}, + &BuildLog{}, + &BuildRequest{}, + &BuildLogOptions{}, + &BinaryBuildRequestOptions{}, + } + scheme.AddKnownTypes(legacyGroupVersion, types...) + return nil +} diff --git a/build/v1/register.go b/build/v1/register.go index d9e7e60360f..16f68ea8cd6 100644 --- a/build/v1/register.go +++ b/build/v1/register.go @@ -7,27 +7,30 @@ import ( "k8s.io/apimachinery/pkg/runtime/schema" ) -const GroupName = "build.openshift.io" -const LegacyGroupName = "" - var ( - SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} - LegacySchemeGroupVersion = schema.GroupVersion{Group: LegacyGroupName, Version: "v1"} - - LegacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes) - AddToSchemeInCoreGroup = LegacySchemeBuilder.AddToScheme - - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "build.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, corev1.AddToScheme) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() + return schema.GroupResource{Group: GroupName, Resource: resource} } // addKnownTypes adds types to API group func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &Build{}, &BuildList{}, &BuildConfig{}, @@ -39,23 +42,6 @@ func addKnownTypes(scheme *runtime.Scheme) error { // This is needed for webhooks &corev1.PodProxyOptions{}, ) - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) - return nil -} - -// addLegacyKnownTypes adds types to legacy API group -// DEPRECATED: This will be deprecated and should not be modified. -func addLegacyKnownTypes(scheme *runtime.Scheme) error { - types := []runtime.Object{ - &Build{}, - &BuildList{}, - &BuildConfig{}, - &BuildConfigList{}, - &BuildLog{}, - &BuildRequest{}, - &BuildLogOptions{}, - &BinaryBuildRequestOptions{}, - } - scheme.AddKnownTypes(LegacySchemeGroupVersion, types...) + metav1.AddToGroupVersion(scheme, GroupVersion) return nil } diff --git a/config/install.go b/config/install.go new file mode 100644 index 00000000000..9acfa4203bc --- /dev/null +++ b/config/install.go @@ -0,0 +1,26 @@ +package config + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + configv1 "github.com/openshift/api/config/v1" +) + +const ( + GroupName = "config.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(configv1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/config/v1/register.go b/config/v1/register.go index 348bcb021c9..22a9208c234 100644 --- a/config/v1/register.go +++ b/config/v1/register.go @@ -5,23 +5,29 @@ import ( "k8s.io/apimachinery/pkg/runtime/schema" ) -const ( - GroupName = "config.openshift.io" -) - -// SchemeGroupVersion is group version used to register these objects var ( - SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "config.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() + return schema.GroupResource{Group: GroupName, Resource: resource} } // Adds the list of known types to api.Scheme. func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion) + scheme.AddKnownTypes(GroupVersion) return nil } diff --git a/image/install.go b/image/install.go new file mode 100644 index 00000000000..5b146faa7ee --- /dev/null +++ b/image/install.go @@ -0,0 +1,26 @@ +package image + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + imagev1 "github.com/openshift/api/image/v1" +) + +const ( + GroupName = "image.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(imagev1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/image/v1/legacy.go b/image/v1/legacy.go new file mode 100644 index 00000000000..02bbaa2906f --- /dev/null +++ b/image/v1/legacy.go @@ -0,0 +1,33 @@ +package v1 + +import ( + "github.com/openshift/api/image/docker10" + "github.com/openshift/api/image/dockerpre012" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + legacyGroupVersion = schema.GroupVersion{Group: "", Version: "v1"} + legacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes, docker10.AddToSchemeInCoreGroup, dockerpre012.AddToSchemeInCoreGroup, corev1.AddToScheme) + DeprecatedInstallWithoutGroup = legacySchemeBuilder.AddToScheme +) + +// Adds the list of known types to api.Scheme. +func addLegacyKnownTypes(scheme *runtime.Scheme) error { + types := []runtime.Object{ + &Image{}, + &ImageList{}, + &ImageSignature{}, + &ImageStream{}, + &ImageStreamList{}, + &ImageStreamMapping{}, + &ImageStreamTag{}, + &ImageStreamTagList{}, + &ImageStreamImage{}, + &ImageStreamImport{}, + } + scheme.AddKnownTypes(legacyGroupVersion, types...) + return nil +} diff --git a/image/v1/register.go b/image/v1/register.go index d7189603b18..5377b4cade6 100644 --- a/image/v1/register.go +++ b/image/v1/register.go @@ -10,47 +10,30 @@ import ( "github.com/openshift/api/image/dockerpre012" ) -const ( - GroupName = "image.openshift.io" - LegacyGroupName = "" -) - var ( - SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} - LegacySchemeGroupVersion = schema.GroupVersion{Group: LegacyGroupName, Version: "v1"} - - LegacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes, docker10.AddToSchemeInCoreGroup, dockerpre012.AddToSchemeInCoreGroup) - AddToSchemeInCoreGroup = LegacySchemeBuilder.AddToScheme - - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, docker10.AddToScheme, dockerpre012.AddToScheme) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "image.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, docker10.AddToScheme, dockerpre012.AddToScheme, corev1.AddToScheme) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() -} - -// Adds the list of known types to api.Scheme. -func addLegacyKnownTypes(scheme *runtime.Scheme) error { - types := []runtime.Object{ - &Image{}, - &ImageList{}, - &ImageSignature{}, - &ImageStream{}, - &ImageStreamList{}, - &ImageStreamMapping{}, - &ImageStreamTag{}, - &ImageStreamTagList{}, - &ImageStreamImage{}, - &ImageStreamImport{}, - } - scheme.AddKnownTypes(LegacySchemeGroupVersion, types...) - return nil + return schema.GroupResource{Group: GroupName, Resource: resource} } // Adds the list of known types to api.Scheme. func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &Image{}, &ImageList{}, &ImageSignature{}, @@ -63,6 +46,6 @@ func addKnownTypes(scheme *runtime.Scheme) error { &ImageStreamImport{}, &corev1.SecretList{}, ) - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) + metav1.AddToGroupVersion(scheme, GroupVersion) return nil } diff --git a/install.go b/install.go new file mode 100644 index 00000000000..ede14235405 --- /dev/null +++ b/install.go @@ -0,0 +1,42 @@ +package api + +import ( + "k8s.io/apimachinery/pkg/runtime" + + "github.com/openshift/api/apps" + "github.com/openshift/api/build" + "github.com/openshift/api/config" + "github.com/openshift/api/image" + "github.com/openshift/api/network" + "github.com/openshift/api/oauth" + "github.com/openshift/api/operator" + "github.com/openshift/api/project" + "github.com/openshift/api/route" + "github.com/openshift/api/security" + "github.com/openshift/api/servicecertsigner" + "github.com/openshift/api/template" + "github.com/openshift/api/user" + "github.com/openshift/api/webconsole" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder( + apps.Install, + build.Install, + config.Install, + image.Install, + network.Install, + oauth.Install, + operator.Install, + project.Install, + oauth.Install, + route.Install, + security.Install, + servicecertsigner.Install, + template.Install, + user.Install, + webconsole.Install, + ) + // Install is a function which adds every version of every openshift group to a scheme + Install = schemeBuilder.AddToScheme +) diff --git a/network/install.go b/network/install.go new file mode 100644 index 00000000000..85bc706236e --- /dev/null +++ b/network/install.go @@ -0,0 +1,26 @@ +package network + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + networkv1 "github.com/openshift/api/network/v1" +) + +const ( + GroupName = "network.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(networkv1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/network/v1/legacy.go b/network/v1/legacy.go new file mode 100644 index 00000000000..4395ebf8e56 --- /dev/null +++ b/network/v1/legacy.go @@ -0,0 +1,27 @@ +package v1 + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + legacyGroupVersion = schema.GroupVersion{Group: "", Version: "v1"} + legacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes) + DeprecatedInstallWithoutGroup = legacySchemeBuilder.AddToScheme +) + +func addLegacyKnownTypes(scheme *runtime.Scheme) error { + types := []runtime.Object{ + &ClusterNetwork{}, + &ClusterNetworkList{}, + &HostSubnet{}, + &HostSubnetList{}, + &NetNamespace{}, + &NetNamespaceList{}, + &EgressNetworkPolicy{}, + &EgressNetworkPolicyList{}, + } + scheme.AddKnownTypes(legacyGroupVersion, types...) + return nil +} diff --git a/network/v1/register.go b/network/v1/register.go index 7351d610463..80defa76427 100644 --- a/network/v1/register.go +++ b/network/v1/register.go @@ -6,30 +6,30 @@ import ( "k8s.io/apimachinery/pkg/runtime/schema" ) -const ( - GroupName = "network.openshift.io" - LegacyGroupName = "" -) - -// SchemeGroupVersion is group version used to register these objects var ( - SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} - LegacySchemeGroupVersion = schema.GroupVersion{Group: LegacyGroupName, Version: "v1"} - - LegacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes) - AddToSchemeInCoreGroup = LegacySchemeBuilder.AddToScheme - - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "network.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() + return schema.GroupResource{Group: GroupName, Resource: resource} } // Adds the list of known types to api.Scheme. func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &ClusterNetwork{}, &ClusterNetworkList{}, &HostSubnet{}, @@ -39,22 +39,6 @@ func addKnownTypes(scheme *runtime.Scheme) error { &EgressNetworkPolicy{}, &EgressNetworkPolicyList{}, ) - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) - return nil -} - -// Adds the list of known types to api.Scheme. -func addLegacyKnownTypes(scheme *runtime.Scheme) error { - types := []runtime.Object{ - &ClusterNetwork{}, - &ClusterNetworkList{}, - &HostSubnet{}, - &HostSubnetList{}, - &NetNamespace{}, - &NetNamespaceList{}, - &EgressNetworkPolicy{}, - &EgressNetworkPolicyList{}, - } - scheme.AddKnownTypes(LegacySchemeGroupVersion, types...) + metav1.AddToGroupVersion(scheme, GroupVersion) return nil } diff --git a/oauth/install.go b/oauth/install.go new file mode 100644 index 00000000000..6bf63539d9f --- /dev/null +++ b/oauth/install.go @@ -0,0 +1,26 @@ +package oauth + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + oauthv1 "github.com/openshift/api/oauth/v1" +) + +const ( + GroupName = "oauth.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(oauthv1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/oauth/v1/legacy.go b/oauth/v1/legacy.go new file mode 100644 index 00000000000..65b57d24312 --- /dev/null +++ b/oauth/v1/legacy.go @@ -0,0 +1,30 @@ +package v1 + +import ( + corev1 "k8s.io/api/core/v1" + extensionsv1beta1 "k8s.io/api/extensions/v1beta1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + legacyGroupVersion = schema.GroupVersion{Group: "", Version: "v1"} + legacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes, corev1.AddToScheme, extensionsv1beta1.AddToScheme) + DeprecatedInstallWithoutGroup = legacySchemeBuilder.AddToScheme +) + +func addLegacyKnownTypes(scheme *runtime.Scheme) error { + types := []runtime.Object{ + &OAuthAccessToken{}, + &OAuthAccessTokenList{}, + &OAuthAuthorizeToken{}, + &OAuthAuthorizeTokenList{}, + &OAuthClient{}, + &OAuthClientList{}, + &OAuthClientAuthorization{}, + &OAuthClientAuthorizationList{}, + &OAuthRedirectReference{}, + } + scheme.AddKnownTypes(legacyGroupVersion, types...) + return nil +} diff --git a/oauth/v1/register.go b/oauth/v1/register.go index a1e97c4d3e6..37278c64147 100644 --- a/oauth/v1/register.go +++ b/oauth/v1/register.go @@ -6,30 +6,30 @@ import ( "k8s.io/apimachinery/pkg/runtime/schema" ) -const ( - GroupName = "oauth.openshift.io" - LegacyGroupName = "" -) - -// SchemeGroupVersion is group version used to register these objects var ( - SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} - LegacySchemeGroupVersion = schema.GroupVersion{Group: LegacyGroupName, Version: "v1"} - - LegacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes) - AddToSchemeInCoreGroup = LegacySchemeBuilder.AddToScheme - - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "oauth.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() + return schema.GroupResource{Group: GroupName, Resource: resource} } // Adds the list of known types to api.Scheme. func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &OAuthAccessToken{}, &OAuthAccessTokenList{}, &OAuthAuthorizeToken{}, @@ -40,22 +40,6 @@ func addKnownTypes(scheme *runtime.Scheme) error { &OAuthClientAuthorizationList{}, &OAuthRedirectReference{}, ) - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) - return nil -} - -func addLegacyKnownTypes(scheme *runtime.Scheme) error { - types := []runtime.Object{ - &OAuthAccessToken{}, - &OAuthAccessTokenList{}, - &OAuthAuthorizeToken{}, - &OAuthAuthorizeTokenList{}, - &OAuthClient{}, - &OAuthClientList{}, - &OAuthClientAuthorization{}, - &OAuthClientAuthorizationList{}, - &OAuthRedirectReference{}, - } - scheme.AddKnownTypes(LegacySchemeGroupVersion, types...) + metav1.AddToGroupVersion(scheme, GroupVersion) return nil } diff --git a/operator/install.go b/operator/install.go new file mode 100644 index 00000000000..0cc76ff5557 --- /dev/null +++ b/operator/install.go @@ -0,0 +1,26 @@ +package operator + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + operatorv1alpha1 "github.com/openshift/api/operator/v1alpha1" +) + +const ( + GroupName = "operator.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(operatorv1alpha1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/operator/v1alpha1/register.go b/operator/v1alpha1/register.go index 5aa0333c194..5ddbdeb0e64 100644 --- a/operator/v1alpha1/register.go +++ b/operator/v1alpha1/register.go @@ -1,23 +1,37 @@ package v1alpha1 import ( + configv1 "github.com/openshift/api/config/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" ) -// SchemeGroupVersion is group version used to register these objects -var SchemeGroupVersion = schema.GroupVersion{Group: "operator.openshift.io", Version: "v1alpha1"} - var ( - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "operator.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, configv1.Install) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + func addKnownTypes(scheme *runtime.Scheme) error { - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) + metav1.AddToGroupVersion(scheme, GroupVersion) - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &GenericOperatorConfig{}, ) diff --git a/pkg/testing/deepcopy_test.go b/pkg/testing/deepcopy_test.go index 3b5b6c2bd9c..596d311cd0f 100644 --- a/pkg/testing/deepcopy_test.go +++ b/pkg/testing/deepcopy_test.go @@ -27,31 +27,31 @@ import ( user "github.com/openshift/api/user/v1" ) -var groups = map[schema.GroupVersion]runtime.SchemeBuilder{ - apps.SchemeGroupVersion: apps.SchemeBuilder, - authorization.SchemeGroupVersion: authorization.SchemeBuilder, - build.SchemeGroupVersion: build.SchemeBuilder, - image.SchemeGroupVersion: image.SchemeBuilder, - network.SchemeGroupVersion: network.SchemeBuilder, - oauth.SchemeGroupVersion: oauth.SchemeBuilder, - project.SchemeGroupVersion: project.SchemeBuilder, - quota.SchemeGroupVersion: quota.SchemeBuilder, - route.SchemeGroupVersion: route.SchemeBuilder, - security.SchemeGroupVersion: security.SchemeBuilder, - template.SchemeGroupVersion: template.SchemeBuilder, - user.SchemeGroupVersion: user.SchemeBuilder, +var groups = map[schema.GroupVersion]func(*runtime.Scheme) error{ + apps.GroupVersion: apps.Install, + authorization.GroupVersion: authorization.Install, + build.GroupVersion: build.Install, + image.GroupVersion: image.Install, + network.GroupVersion: network.Install, + oauth.GroupVersion: oauth.Install, + project.GroupVersion: project.Install, + quota.GroupVersion: quota.Install, + route.GroupVersion: route.Install, + security.GroupVersion: security.Install, + template.GroupVersion: template.Install, + user.GroupVersion: user.Install, } // TestRoundTripTypesWithoutProtobuf applies the round-trip test to all round-trippable Kinds // in the scheme. func TestRoundTripTypesWithoutProtobuf(t *testing.T) { // TODO upstream this loop - for gv, builder := range groups { + for gv, install := range groups { t.Logf("starting group %q", gv) scheme := runtime.NewScheme() codecs := serializer.NewCodecFactory(scheme) - builder.AddToScheme(scheme) + install(scheme) seed := rand.Int63() // I'm only using the generic fuzzer funcs, but at some point in time we might need to // switch to specialized. For now we're happy with the current serialization test. diff --git a/pkg/testing/doc.go b/pkg/testing/doc.go new file mode 100644 index 00000000000..7603f836a00 --- /dev/null +++ b/pkg/testing/doc.go @@ -0,0 +1 @@ +package testing diff --git a/project/install.go b/project/install.go new file mode 100644 index 00000000000..c96c7aa2653 --- /dev/null +++ b/project/install.go @@ -0,0 +1,26 @@ +package project + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + projectv1 "github.com/openshift/api/project/v1" +) + +const ( + GroupName = "project.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(projectv1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/project/v1/legacy.go b/project/v1/legacy.go new file mode 100644 index 00000000000..186f905f3a8 --- /dev/null +++ b/project/v1/legacy.go @@ -0,0 +1,23 @@ +package v1 + +import ( + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + legacyGroupVersion = schema.GroupVersion{Group: "", Version: "v1"} + legacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes, corev1.AddToScheme) + DeprecatedInstallWithoutGroup = legacySchemeBuilder.AddToScheme +) + +func addLegacyKnownTypes(scheme *runtime.Scheme) error { + types := []runtime.Object{ + &Project{}, + &ProjectList{}, + &ProjectRequest{}, + } + scheme.AddKnownTypes(legacyGroupVersion, types...) + return nil +} diff --git a/project/v1/register.go b/project/v1/register.go index 07f86689792..e471716ce8e 100644 --- a/project/v1/register.go +++ b/project/v1/register.go @@ -1,49 +1,40 @@ package v1 import ( + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" ) -const ( - GroupName = "project.openshift.io" - LegacyGroupName = "" -) - -// SchemeGroupVersion is group version used to register these objects var ( - SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} - LegacySchemeGroupVersion = schema.GroupVersion{Group: LegacyGroupName, Version: "v1"} - - LegacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes) - AddToSchemeInCoreGroup = LegacySchemeBuilder.AddToScheme - - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "project.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, corev1.AddToScheme) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() + return schema.GroupResource{Group: GroupName, Resource: resource} } // Adds the list of known types to api.Scheme. func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &Project{}, &ProjectList{}, &ProjectRequest{}, ) - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) - return nil -} - -func addLegacyKnownTypes(scheme *runtime.Scheme) error { - types := []runtime.Object{ - &Project{}, - &ProjectList{}, - &ProjectRequest{}, - } - scheme.AddKnownTypes(LegacySchemeGroupVersion, types...) + metav1.AddToGroupVersion(scheme, GroupVersion) return nil } diff --git a/quota/install.go b/quota/install.go new file mode 100644 index 00000000000..2a88e7d0a4f --- /dev/null +++ b/quota/install.go @@ -0,0 +1,26 @@ +package quota + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + quotav1 "github.com/openshift/api/quota/v1" +) + +const ( + GroupName = "quota.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(quotav1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/quota/v1/legacy.go b/quota/v1/legacy.go new file mode 100644 index 00000000000..402690b5d60 --- /dev/null +++ b/quota/v1/legacy.go @@ -0,0 +1,24 @@ +package v1 + +import ( + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + legacyGroupVersion = schema.GroupVersion{Group: "", Version: "v1"} + legacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes, corev1.AddToScheme) + DeprecatedInstallWithoutGroup = legacySchemeBuilder.AddToScheme +) + +func addLegacyKnownTypes(scheme *runtime.Scheme) error { + types := []runtime.Object{ + &ClusterResourceQuota{}, + &ClusterResourceQuotaList{}, + &AppliedClusterResourceQuota{}, + &AppliedClusterResourceQuotaList{}, + } + scheme.AddKnownTypes(legacyGroupVersion, types...) + return nil +} diff --git a/quota/v1/register.go b/quota/v1/register.go index 31950f4cc6e..47c774ef23e 100644 --- a/quota/v1/register.go +++ b/quota/v1/register.go @@ -1,57 +1,41 @@ package v1 import ( + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" ) -const ( - GroupName = "quota.openshift.io" - LegacyGroupName = "" -) - -// SchemeGroupVersion is group version used to register these objects var ( - SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} - LegacySchemeGroupVersion = schema.GroupVersion{Group: LegacyGroupName, Version: "v1"} - - LegacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes) - AddToSchemeInCoreGroup = LegacySchemeBuilder.AddToScheme - - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "quota.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, corev1.AddToScheme) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) -// Kind takes an unqualified kind and returns back a Group qualified GroupKind -func Kind(kind string) schema.GroupKind { - return SchemeGroupVersion.WithKind(kind).GroupKind() -} - -// Resource takes an unqualified resource and returns back a Group qualified GroupResource +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() + return schema.GroupResource{Group: GroupName, Resource: resource} } // Adds the list of known types to api.Scheme. func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &ClusterResourceQuota{}, &ClusterResourceQuotaList{}, &AppliedClusterResourceQuota{}, &AppliedClusterResourceQuotaList{}, ) - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) - return nil -} - -func addLegacyKnownTypes(scheme *runtime.Scheme) error { - types := []runtime.Object{ - &ClusterResourceQuota{}, - &ClusterResourceQuotaList{}, - &AppliedClusterResourceQuota{}, - &AppliedClusterResourceQuotaList{}, - } - scheme.AddKnownTypes(LegacySchemeGroupVersion, types...) + metav1.AddToGroupVersion(scheme, GroupVersion) return nil } diff --git a/route/install.go b/route/install.go new file mode 100644 index 00000000000..a08536283be --- /dev/null +++ b/route/install.go @@ -0,0 +1,26 @@ +package route + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + routev1 "github.com/openshift/api/route/v1" +) + +const ( + GroupName = "route.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(routev1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/route/v1/legacy.go b/route/v1/legacy.go new file mode 100644 index 00000000000..498f5dd0f06 --- /dev/null +++ b/route/v1/legacy.go @@ -0,0 +1,22 @@ +package v1 + +import ( + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + legacyGroupVersion = schema.GroupVersion{Group: "", Version: "v1"} + legacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes, corev1.AddToScheme) + DeprecatedInstallWithoutGroup = legacySchemeBuilder.AddToScheme +) + +func addLegacyKnownTypes(scheme *runtime.Scheme) error { + types := []runtime.Object{ + &Route{}, + &RouteList{}, + } + scheme.AddKnownTypes(legacyGroupVersion, types...) + return nil +} diff --git a/route/v1/register.go b/route/v1/register.go index 7257f023586..6f99ef5c96a 100644 --- a/route/v1/register.go +++ b/route/v1/register.go @@ -1,47 +1,39 @@ package v1 import ( + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" ) -const ( - GroupName = "route.openshift.io" - LegacyGroupName = "" -) - -// SchemeGroupVersion is group version used to register these objects var ( - SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} - LegacySchemeGroupVersion = schema.GroupVersion{Group: LegacyGroupName, Version: "v1"} - - LegacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes) - AddToSchemeInCoreGroup = LegacySchemeBuilder.AddToScheme - - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "route.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, corev1.AddToScheme) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() + return schema.GroupResource{Group: GroupName, Resource: resource} } // Adds the list of known types to api.Scheme. func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &Route{}, &RouteList{}, ) - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) - return nil -} - -func addLegacyKnownTypes(scheme *runtime.Scheme) error { - types := []runtime.Object{ - &Route{}, - &RouteList{}, - } - scheme.AddKnownTypes(LegacySchemeGroupVersion, types...) + metav1.AddToGroupVersion(scheme, GroupVersion) return nil } diff --git a/security/install.go b/security/install.go new file mode 100644 index 00000000000..c2b04c43298 --- /dev/null +++ b/security/install.go @@ -0,0 +1,26 @@ +package security + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + securityv1 "github.com/openshift/api/security/v1" +) + +const ( + GroupName = "security.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(securityv1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/security/v1/legacy.go b/security/v1/legacy.go new file mode 100644 index 00000000000..34f609a07b0 --- /dev/null +++ b/security/v1/legacy.go @@ -0,0 +1,25 @@ +package v1 + +import ( + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + legacyGroupVersion = schema.GroupVersion{Group: "", Version: "v1"} + legacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes, corev1.AddToScheme) + DeprecatedInstallWithoutGroup = legacySchemeBuilder.AddToScheme +) + +func addLegacyKnownTypes(scheme *runtime.Scheme) error { + types := []runtime.Object{ + &SecurityContextConstraints{}, + &SecurityContextConstraintsList{}, + &PodSecurityPolicySubjectReview{}, + &PodSecurityPolicySelfSubjectReview{}, + &PodSecurityPolicyReview{}, + } + scheme.AddKnownTypes(legacyGroupVersion, types...) + return nil +} diff --git a/security/v1/register.go b/security/v1/register.go index a923b86f0e8..431c3b53978 100644 --- a/security/v1/register.go +++ b/security/v1/register.go @@ -1,35 +1,36 @@ package v1 import ( + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" ) -const ( - GroupName = "security.openshift.io" - LegacyGroupName = "" -) - -// SchemeGroupVersion is group version used to register these objects var ( - SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} - LegacySchemeGroupVersion = schema.GroupVersion{Group: LegacyGroupName, Version: "v1"} - - LegacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes) - AddToSchemeInCoreGroup = LegacySchemeBuilder.AddToScheme - - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "security.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, corev1.AddToScheme) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() + return schema.GroupResource{Group: GroupName, Resource: resource} } // Adds the list of known types to api.Scheme. func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &SecurityContextConstraints{}, &SecurityContextConstraintsList{}, &PodSecurityPolicySubjectReview{}, @@ -38,18 +39,6 @@ func addKnownTypes(scheme *runtime.Scheme) error { &RangeAllocation{}, &RangeAllocationList{}, ) - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) - return nil -} - -func addLegacyKnownTypes(scheme *runtime.Scheme) error { - types := []runtime.Object{ - &SecurityContextConstraints{}, - &SecurityContextConstraintsList{}, - &PodSecurityPolicySubjectReview{}, - &PodSecurityPolicySelfSubjectReview{}, - &PodSecurityPolicyReview{}, - } - scheme.AddKnownTypes(LegacySchemeGroupVersion, types...) + metav1.AddToGroupVersion(scheme, GroupVersion) return nil } diff --git a/servicecertsigner/install.go b/servicecertsigner/install.go new file mode 100644 index 00000000000..98d891d34de --- /dev/null +++ b/servicecertsigner/install.go @@ -0,0 +1,26 @@ +package servicecertsigner + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + servicecertsignerv1alpha1 "github.com/openshift/api/servicecertsigner/v1alpha1" +) + +const ( + GroupName = "servicecertsigner.config.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(servicecertsignerv1alpha1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/servicecertsigner/v1alpha1/register.go b/servicecertsigner/v1alpha1/register.go index 718e47bc1ba..8350b49c0c4 100644 --- a/servicecertsigner/v1alpha1/register.go +++ b/servicecertsigner/v1alpha1/register.go @@ -1,32 +1,43 @@ package v1alpha1 import ( + configv1 "github.com/openshift/api/config/v1" + operatorsv1alpha1api "github.com/openshift/api/operator/v1alpha1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" ) -// SchemeGroupVersion is group version used to register these objects -var SchemeGroupVersion = schema.GroupVersion{Group: "servicecertsigner.config.openshift.io", Version: "v1alpha1"} - var ( - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "servicecertsigner.config.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, configv1.Install, operatorsv1alpha1api.Install) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() + return schema.GroupResource{Group: GroupName, Resource: resource} } func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &ServiceServingCertSignerConfig{}, &APIServiceCABundleInjectorConfig{}, &ConfigMapCABundleInjectorConfig{}, &ServiceCertSignerOperatorConfig{}, &ServiceCertSignerOperatorConfigList{}, ) - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) + metav1.AddToGroupVersion(scheme, GroupVersion) return nil } diff --git a/template/install.go b/template/install.go new file mode 100644 index 00000000000..8a69398dd09 --- /dev/null +++ b/template/install.go @@ -0,0 +1,26 @@ +package template + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + templatev1 "github.com/openshift/api/template/v1" +) + +const ( + GroupName = "template.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(templatev1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/template/v1/legacy.go b/template/v1/legacy.go new file mode 100644 index 00000000000..9266f3ac9e6 --- /dev/null +++ b/template/v1/legacy.go @@ -0,0 +1,24 @@ +package v1 + +import ( + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + legacyGroupVersion = schema.GroupVersion{Group: "", Version: "v1"} + legacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes, corev1.AddToScheme) + DeprecatedInstallWithoutGroup = legacySchemeBuilder.AddToScheme +) + +func addLegacyKnownTypes(scheme *runtime.Scheme) error { + types := []runtime.Object{ + &Template{}, + &TemplateList{}, + } + scheme.AddKnownTypes(legacyGroupVersion, types...) + scheme.AddKnownTypeWithName(legacyGroupVersion.WithKind("TemplateConfig"), &Template{}) + scheme.AddKnownTypeWithName(legacyGroupVersion.WithKind("ProcessedTemplate"), &Template{}) + return nil +} diff --git a/template/v1/register.go b/template/v1/register.go index 4c67af7457f..e34ff5610b6 100644 --- a/template/v1/register.go +++ b/template/v1/register.go @@ -1,35 +1,36 @@ package v1 import ( + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" ) -const ( - GroupName = "template.openshift.io" - LegacyGroupName = "" -) - -// SchemeGroupVersion is group version used to register these objects var ( - SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} - LegacySchemeGroupVersion = schema.GroupVersion{Group: LegacyGroupName, Version: "v1"} - - LegacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes) - AddToSchemeInCoreGroup = LegacySchemeBuilder.AddToScheme - - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "template.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, corev1.AddToScheme) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() + return schema.GroupResource{Group: GroupName, Resource: resource} } // Adds the list of known types to api.Scheme. func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &Template{}, &TemplateList{}, &TemplateInstance{}, @@ -37,17 +38,6 @@ func addKnownTypes(scheme *runtime.Scheme) error { &BrokerTemplateInstance{}, &BrokerTemplateInstanceList{}, ) - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) - return nil -} - -func addLegacyKnownTypes(scheme *runtime.Scheme) error { - types := []runtime.Object{ - &Template{}, - &TemplateList{}, - } - scheme.AddKnownTypes(LegacySchemeGroupVersion, types...) - scheme.AddKnownTypeWithName(LegacySchemeGroupVersion.WithKind("TemplateConfig"), &Template{}) - scheme.AddKnownTypeWithName(LegacySchemeGroupVersion.WithKind("ProcessedTemplate"), &Template{}) + metav1.AddToGroupVersion(scheme, GroupVersion) return nil } diff --git a/user/install.go b/user/install.go new file mode 100644 index 00000000000..28d49806214 --- /dev/null +++ b/user/install.go @@ -0,0 +1,26 @@ +package user + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + userv1 "github.com/openshift/api/user/v1" +) + +const ( + GroupName = "user.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(userv1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/user/v1/legacy.go b/user/v1/legacy.go new file mode 100644 index 00000000000..6817a9f1f3e --- /dev/null +++ b/user/v1/legacy.go @@ -0,0 +1,27 @@ +package v1 + +import ( + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +var ( + legacyGroupVersion = schema.GroupVersion{Group: "", Version: "v1"} + legacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes, corev1.AddToScheme) + DeprecatedInstallWithoutGroup = legacySchemeBuilder.AddToScheme +) + +func addLegacyKnownTypes(scheme *runtime.Scheme) error { + types := []runtime.Object{ + &User{}, + &UserList{}, + &Identity{}, + &IdentityList{}, + &UserIdentityMapping{}, + &Group{}, + &GroupList{}, + } + scheme.AddKnownTypes(legacyGroupVersion, types...) + return nil +} diff --git a/user/v1/register.go b/user/v1/register.go index bd431b5c2be..11341d72a98 100644 --- a/user/v1/register.go +++ b/user/v1/register.go @@ -1,35 +1,36 @@ package v1 import ( + corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" ) -const ( - GroupName = "user.openshift.io" - LegacyGroupName = "" -) - -// SchemeGroupVersion is group version used to register these objects var ( - SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} - LegacySchemeGroupVersion = schema.GroupVersion{Group: LegacyGroupName, Version: "v1"} - - LegacySchemeBuilder = runtime.NewSchemeBuilder(addLegacyKnownTypes) - AddToSchemeInCoreGroup = LegacySchemeBuilder.AddToScheme - - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "user.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, corev1.AddToScheme) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() + return schema.GroupResource{Group: GroupName, Resource: resource} } // Adds the list of known types to api.Scheme. func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &User{}, &UserList{}, &Identity{}, @@ -38,21 +39,6 @@ func addKnownTypes(scheme *runtime.Scheme) error { &Group{}, &GroupList{}, ) - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) - return nil -} - -// Adds the list of known types to api.Scheme. -func addLegacyKnownTypes(scheme *runtime.Scheme) error { - types := []runtime.Object{ - &User{}, - &UserList{}, - &Identity{}, - &IdentityList{}, - &UserIdentityMapping{}, - &Group{}, - &GroupList{}, - } - scheme.AddKnownTypes(LegacySchemeGroupVersion, types...) + metav1.AddToGroupVersion(scheme, GroupVersion) return nil } diff --git a/webconsole/install.go b/webconsole/install.go new file mode 100644 index 00000000000..645e5275e1a --- /dev/null +++ b/webconsole/install.go @@ -0,0 +1,26 @@ +package webconsole + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + webconsolev1 "github.com/openshift/api/webconsole/v1" +) + +const ( + GroupName = "webconsole.openshift.io" +) + +var ( + schemeBuilder = runtime.NewSchemeBuilder(webconsolev1.Install) + // Install is a function which adds every version of this group to a scheme + Install = schemeBuilder.AddToScheme +) + +func Resource(resource string) schema.GroupResource { + return schema.GroupResource{Group: GroupName, Resource: resource} +} + +func Kind(kind string) schema.GroupKind { + return schema.GroupKind{Group: GroupName, Kind: kind} +} diff --git a/webconsole/v1/register.go b/webconsole/v1/register.go index 7ba1ad75d6a..de85ae1111e 100644 --- a/webconsole/v1/register.go +++ b/webconsole/v1/register.go @@ -1,31 +1,38 @@ package v1 import ( + configv1 "github.com/openshift/api/config/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime/schema" ) -const ( - GroupName = "webconsole.config.openshift.io" -) - -// SchemeGroupVersion is group version used to register these objects var ( - SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} - SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) - AddToScheme = SchemeBuilder.AddToScheme + GroupName = "webconsole.config.openshift.io" + GroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"} + schemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, configv1.Install) + // Install is a function which adds this version to a scheme + Install = schemeBuilder.AddToScheme + + // SchemeGroupVersion generated code relies on this name + // Deprecated + SchemeGroupVersion = GroupVersion + // AddToScheme exists solely to keep the old generators creating valid code + // DEPRECATED + AddToScheme = schemeBuilder.AddToScheme ) +// Resource generated code relies on this being here, but it logically belongs to the group +// DEPRECATED func Resource(resource string) schema.GroupResource { - return SchemeGroupVersion.WithResource(resource).GroupResource() + return schema.GroupResource{Group: GroupName, Resource: resource} } // Adds the list of known types to api.Scheme. func addKnownTypes(scheme *runtime.Scheme) error { - scheme.AddKnownTypes(SchemeGroupVersion, + scheme.AddKnownTypes(GroupVersion, &WebConsoleConfiguration{}, ) - metav1.AddToGroupVersion(scheme, SchemeGroupVersion) + metav1.AddToGroupVersion(scheme, GroupVersion) return nil }