github
/
k3s
mirror of https://github.com/k3s-io/k3s
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #18459 from deads2k/gv-group-registration 

Auto commit by PR queue bot
pull/6/head
k8s-merge-robot 2015-12-15 07:41:14 -08:00
parent 7d139684e3 7a83ce60e6
commit 7de177b8b5
6 changed files with 185 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
cmd/libs/go2idl/client-gen/testdata/apis/testgroup/install/install.go vendored
View File

@ -37,33 +37,39 @@ const importPrefix = "k8s.io/kubernetes/pkg/apis/testgroup"
var accessor = meta.NewAccessor()
const groupName = "testgroup"
// availableVersions lists all known external versions for this group from most preferred to least preferred
var availableVersions = []unversioned.GroupVersion{{Group: groupName, Version: "v1"}}
func init() {
registered.RegisteredGroupVersions = append(registered.RegisteredGroupVersions, v1.SchemeGroupVersion)
groupMeta, err := latest.RegisterGroup("testgroup")
if err != nil {
externalVersions := availableVersions
preferredExternalVersion := externalVersions[0]
groupMeta := latest.GroupMeta{
GroupVersion: preferredExternalVersion,
GroupVersions: externalVersions,
Codec: runtime.CodecFor(api.Scheme, preferredExternalVersion.String()),
RESTMapper: newRESTMapper(externalVersions),
SelfLinker: runtime.SelfLinker(accessor),
InterfacesFor: interfacesFor,
}
if err := latest.RegisterGroup(groupMeta); err != nil {
glog.V(4).Infof("%v", err)
return
}
registeredGroupVersions := []unversioned.GroupVersion{
{
"testgroup",
"v1",
},
}
groupVersion := registeredGroupVersions[0]
*groupMeta = latest.GroupMeta{
GroupVersion: groupVersion,
Codec: runtime.CodecFor(api.Scheme, groupVersion.String()),
api.RegisterRESTMapper(groupMeta.RESTMapper)
}
func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
worstToBestGroupVersions := []unversioned.GroupVersion{}
for i := len(registeredGroupVersions) - 1; i >= 0; i-- {
worstToBestGroupVersions = append(worstToBestGroupVersions, registeredGroupVersions[i])
for i := len(externalVersions) - 1; i >= 0; i-- {
worstToBestGroupVersions = append(worstToBestGroupVersions, externalVersions[i])
}
groupMeta.GroupVersions = registeredGroupVersions
groupMeta.SelfLinker = runtime.SelfLinker(accessor)
// the list of kinds that are scoped at the root of the api hierarchy
// if a kind is not enumerated here, it is assumed to have a namespace scope
@ -71,9 +77,7 @@ func init() {
ignoredKinds := sets.NewString()
groupMeta.RESTMapper = api.NewDefaultRESTMapper(worstToBestGroupVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
api.RegisterRESTMapper(groupMeta.RESTMapper)
groupMeta.InterfacesFor = interfacesFor
return api.NewDefaultRESTMapper(worstToBestGroupVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
}
// InterfacesFor returns the default Codec and ResourceVersioner for a given version
@ -87,7 +91,7 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
MetadataAccessor: accessor,
}, nil
default:
g, _ := latest.Group("testgroup")
g, _ := latest.Group(groupName)
return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
}
}

59
pkg/api/install/install.go
View File

@ -34,35 +34,55 @@ import (
"k8s.io/kubernetes/pkg/runtime"
)
// userResources is a group of resources mostly used by a kubectl user
var userResources = []string{"rc", "svc", "pods", "pvc"}
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 = []unversioned.GroupVersion{v1.SchemeGroupVersion}
func init() {
groupMeta, err := latest.RegisterGroup(api.GroupName)
if err != nil {
externalVersions := []unversioned.GroupVersion{}
for _, allowedVersion := range registered.GroupVersionsForGroup(api.GroupName) {
for _, externalVersion := range availableVersions {
if externalVersion == allowedVersion {
externalVersions = append(externalVersions, externalVersion)
}
}
}
if len(externalVersions) == 0 {
glog.V(4).Infof("No version is registered for group %v", api.GroupName)
return
}
preferredExternalVersion := externalVersions[0]
groupMeta := latest.GroupMeta{
GroupVersion: preferredExternalVersion,
GroupVersions: externalVersions,
Codec: runtime.CodecFor(api.Scheme, preferredExternalVersion.String()),
RESTMapper: newRESTMapper(externalVersions),
SelfLinker: runtime.SelfLinker(accessor),
InterfacesFor: interfacesFor,
}
if err := latest.RegisterGroup(groupMeta); err != nil {
glog.V(4).Infof("%v", err)
return
}
// Use the first API version in the list of registered versions as the latest.
registeredGroupVersions := registered.GroupVersionsForGroup(api.GroupName)
groupVersion := registeredGroupVersions[0]
*groupMeta = latest.GroupMeta{
GroupVersion: groupVersion,
Codec: runtime.CodecFor(api.Scheme, groupVersion.String()),
api.RegisterRESTMapper(groupMeta.RESTMapper)
}
// userResources is a group of resources mostly used by a kubectl user
var userResources = []string{"rc", "svc", "pods", "pvc"}
func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
worstToBestGroupVersions := []unversioned.GroupVersion{}
for i := len(registeredGroupVersions) - 1; i >= 0; i-- {
worstToBestGroupVersions = append(worstToBestGroupVersions, registeredGroupVersions[i])
for i := len(externalVersions) - 1; i >= 0; i-- {
worstToBestGroupVersions = append(worstToBestGroupVersions, externalVersions[i])
}
groupMeta.GroupVersions = registeredGroupVersions
groupMeta.SelfLinker = runtime.SelfLinker(accessor)
// the list of kinds that are scoped at the root of the api hierarchy
// if a kind is not enumerated here, it is assumed to have a namespace scope
@ -89,9 +109,8 @@ func init() {
mapper := api.NewDefaultRESTMapper(worstToBestGroupVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
// setup aliases for groups of resources
mapper.AddResourceAlias("all", userResources...)
groupMeta.RESTMapper = mapper
api.RegisterRESTMapper(groupMeta.RESTMapper)
groupMeta.InterfacesFor = interfacesFor
return mapper
}
// InterfacesFor returns the default Codec and ResourceVersioner for a given version
@ -105,9 +124,7 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
MetadataAccessor: accessor,
}, nil
default:
{
g, _ := latest.Group(api.GroupName)
return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
}
}
}

23
pkg/api/latest/latest.go
View File

@ -22,7 +22,6 @@ import (
"strings"
"k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/registered"
"k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/runtime"
)
@ -52,16 +51,14 @@ var ExternalVersions = []unversioned.GroupVersion{
type GroupMetaMap map[string]*GroupMeta
// RegisterGroup registers a group to GroupMetaMap.
func (g GroupMetaMap) RegisterGroup(group string) (*GroupMeta, error) {
_, found := g[group]
if found {
return nil, fmt.Errorf("group %v is already registered", g)
func (g GroupMetaMap) RegisterGroup(groupMeta GroupMeta) error {
groupName := groupMeta.GroupVersion.Group
if _, found := g[groupName]; found {
return fmt.Errorf("group %v is already registered", g)
}
if len(registered.GroupVersionsForGroup(group)) == 0 {
return nil, fmt.Errorf("No version is registered for group %v", group)
}
g[group] = &GroupMeta{}
return g[group], nil
g[groupName] = &groupMeta
return nil
}
// Group returns the metadata of a group if the gruop is registered, otherwise
@ -71,7 +68,8 @@ func (g GroupMetaMap) Group(group string) (*GroupMeta, error) {
if !found {
return nil, fmt.Errorf("no version is registered for group %v", group)
}
return groupMeta, nil
groupMetaCopy := *groupMeta
return &groupMetaCopy, nil
}
// IsRegistered takes a string and determines if it's one of the registered groups
@ -93,7 +91,8 @@ func (g GroupMetaMap) GroupOrDie(group string) *GroupMeta {
panic(fmt.Sprintf("No version is registered for group %s. ", group) + msg)
}
}
return groupMeta
groupMetaCopy := *groupMeta
return &groupMetaCopy
}
// AllPreferredGroupVersions returns the preferred versions of all registered

49
pkg/apis/componentconfig/install/install.go
View File

@ -38,27 +38,48 @@ const importPrefix = "k8s.io/kubernetes/pkg/apis/componentconfig"
var accessor = meta.NewAccessor()
// availableVersions lists all known external versions for this group from most preferred to least preferred
var availableVersions = []unversioned.GroupVersion{v1alpha1.SchemeGroupVersion}
func init() {
groupMeta, err := latest.RegisterGroup(componentconfig.GroupName)
if err != nil {
externalVersions := []unversioned.GroupVersion{}
for _, allowedVersion := range registered.GroupVersionsForGroup(componentconfig.GroupName) {
for _, externalVersion := range availableVersions {
if externalVersion == allowedVersion {
externalVersions = append(externalVersions, externalVersion)
}
}
}
if len(externalVersions) == 0 {
glog.V(4).Infof("No version is registered for group %v", componentconfig.GroupName)
return
}
preferredExternalVersion := externalVersions[0]
groupMeta := latest.GroupMeta{
GroupVersion: preferredExternalVersion,
GroupVersions: externalVersions,
Codec: runtime.CodecFor(api.Scheme, preferredExternalVersion.String()),
RESTMapper: newRESTMapper(externalVersions),
SelfLinker: runtime.SelfLinker(accessor),
InterfacesFor: interfacesFor,
}
if err := latest.RegisterGroup(groupMeta); err != nil {
glog.V(4).Infof("%v", err)
return
}
registeredGroupVersions := registered.GroupVersionsForGroup(componentconfig.GroupName)
groupVersion := registeredGroupVersions[0]
*groupMeta = latest.GroupMeta{
GroupVersion: groupVersion,
Codec: runtime.CodecFor(api.Scheme, groupVersion.String()),
api.RegisterRESTMapper(groupMeta.RESTMapper)
}
func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
worstToBestGroupVersions := []unversioned.GroupVersion{}
for i := len(registeredGroupVersions) - 1; i >= 0; i-- {
worstToBestGroupVersions = append(worstToBestGroupVersions, registeredGroupVersions[i])
for i := len(externalVersions) - 1; i >= 0; i-- {
worstToBestGroupVersions = append(worstToBestGroupVersions, externalVersions[i])
}
groupMeta.GroupVersions = registeredGroupVersions
groupMeta.SelfLinker = runtime.SelfLinker(accessor)
// the list of kinds that are scoped at the root of the api hierarchy
// if a kind is not enumerated here, it is assumed to have a namespace scope
@ -66,9 +87,7 @@ func init() {
ignoredKinds := sets.NewString()
groupMeta.RESTMapper = api.NewDefaultRESTMapper(worstToBestGroupVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
api.RegisterRESTMapper(groupMeta.RESTMapper)
groupMeta.InterfacesFor = interfacesFor
return api.NewDefaultRESTMapper(worstToBestGroupVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
}
// interfacesFor returns the default Codec and ResourceVersioner for a given version

51
pkg/apis/extensions/install/install.go
View File

@ -38,27 +38,48 @@ const importPrefix = "k8s.io/kubernetes/pkg/apis/extensions"
var accessor = meta.NewAccessor()
// availableVersions lists all known external versions for this group from most preferred to least preferred
var availableVersions = []unversioned.GroupVersion{v1beta1.SchemeGroupVersion}
func init() {
groupMeta, err := latest.RegisterGroup(extensions.GroupName)
if err != nil {
externalVersions := []unversioned.GroupVersion{}
for _, allowedVersion := range registered.GroupVersionsForGroup(extensions.GroupName) {
for _, externalVersion := range availableVersions {
if externalVersion == allowedVersion {
externalVersions = append(externalVersions, externalVersion)
}
}
}
if len(externalVersions) == 0 {
glog.V(4).Infof("No version is registered for group %v", extensions.GroupName)
return
}
preferredExternalVersion := externalVersions[0]
groupMeta := latest.GroupMeta{
GroupVersion: preferredExternalVersion,
GroupVersions: externalVersions,
Codec: runtime.CodecFor(api.Scheme, preferredExternalVersion.String()),
RESTMapper: newRESTMapper(externalVersions),
SelfLinker: runtime.SelfLinker(accessor),
InterfacesFor: interfacesFor,
}
if err := latest.RegisterGroup(groupMeta); err != nil {
glog.V(4).Infof("%v", err)
return
}
registeredGroupVersions := registered.GroupVersionsForGroup(extensions.GroupName)
groupVersion := registeredGroupVersions[0]
*groupMeta = latest.GroupMeta{
GroupVersion: groupVersion,
Codec: runtime.CodecFor(api.Scheme, groupVersion.String()),
api.RegisterRESTMapper(groupMeta.RESTMapper)
}
func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
worstToBestGroupVersions := []unversioned.GroupVersion{}
for i := len(registeredGroupVersions) - 1; i >= 0; i-- {
worstToBestGroupVersions = append(worstToBestGroupVersions, registeredGroupVersions[i])
for i := len(externalVersions) - 1; i >= 0; i-- {
worstToBestGroupVersions = append(worstToBestGroupVersions, externalVersions[i])
}
groupMeta.GroupVersions = registeredGroupVersions
groupMeta.SelfLinker = runtime.SelfLinker(accessor)
// the list of kinds that are scoped at the root of the api hierarchy
// if a kind is not enumerated here, it is assumed to have a namespace scope
@ -66,12 +87,10 @@ func init() {
ignoredKinds := sets.NewString()
groupMeta.RESTMapper = api.NewDefaultRESTMapper(worstToBestGroupVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
api.RegisterRESTMapper(groupMeta.RESTMapper)
groupMeta.InterfacesFor = interfacesFor
return api.NewDefaultRESTMapper(worstToBestGroupVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
}
// InterfacesFor returns the default Codec and ResourceVersioner for a given version
// interfacesFor returns the default Codec and ResourceVersioner for a given version
// string, or an error if the version is not known.
func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
switch version {

51
pkg/apis/metrics/install/install.go
View File

@ -38,27 +38,48 @@ const importPrefix = "k8s.io/kubernetes/pkg/apis/metrics"
var accessor = meta.NewAccessor()
// availableVersions lists all known external versions for this group from most preferred to least preferred
var availableVersions = []unversioned.GroupVersion{v1alpha1.SchemeGroupVersion}
func init() {
groupMeta, err := latest.RegisterGroup(metrics.GroupName)
if err != nil {
externalVersions := []unversioned.GroupVersion{}
for _, allowedVersion := range registered.GroupVersionsForGroup(metrics.GroupName) {
for _, externalVersion := range availableVersions {
if externalVersion == allowedVersion {
externalVersions = append(externalVersions, externalVersion)
}
}
}
if len(externalVersions) == 0 {
glog.V(4).Infof("No version is registered for group %v", metrics.GroupName)
return
}
preferredExternalVersion := externalVersions[0]
groupMeta := latest.GroupMeta{
GroupVersion: preferredExternalVersion,
GroupVersions: externalVersions,
Codec: runtime.CodecFor(api.Scheme, preferredExternalVersion.String()),
RESTMapper: newRESTMapper(externalVersions),
SelfLinker: runtime.SelfLinker(accessor),
InterfacesFor: interfacesFor,
}
if err := latest.RegisterGroup(groupMeta); err != nil {
glog.V(4).Infof("%v", err)
return
}
registeredGroupVersions := registered.GroupVersionsForGroup(metrics.GroupName)
groupVersion := registeredGroupVersions[0]
*groupMeta = latest.GroupMeta{
GroupVersion: groupVersion,
Codec: runtime.CodecFor(api.Scheme, groupVersion.String()),
api.RegisterRESTMapper(groupMeta.RESTMapper)
}
func newRESTMapper(externalVersions []unversioned.GroupVersion) meta.RESTMapper {
worstToBestGroupVersions := []unversioned.GroupVersion{}
for i := len(registeredGroupVersions) - 1; i >= 0; i-- {
worstToBestGroupVersions = append(worstToBestGroupVersions, registeredGroupVersions[i])
for i := len(externalVersions) - 1; i >= 0; i-- {
worstToBestGroupVersions = append(worstToBestGroupVersions, externalVersions[i])
}
groupMeta.GroupVersions = registeredGroupVersions
groupMeta.SelfLinker = runtime.SelfLinker(accessor)
// the list of kinds that are scoped at the root of the api hierarchy
// if a kind is not enumerated here, it is assumed to have a namespace scope
@ -66,12 +87,10 @@ func init() {
ignoredKinds := sets.NewString()
groupMeta.RESTMapper = api.NewDefaultRESTMapper(worstToBestGroupVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
api.RegisterRESTMapper(groupMeta.RESTMapper)
groupMeta.InterfacesFor = interfacesFor
return api.NewDefaultRESTMapper(worstToBestGroupVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
}
// InterfacesFor returns the default Codec and ResourceVersioner for a given version
// interfacesFor returns the default Codec and ResourceVersioner for a given version
// string, or an error if the version is not known.
func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, error) {
switch version {