github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-29 14:37:00 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #18353 from deads2k/gv-use-constants

Browse Source 
Auto commit by PR queue bot
This commit is contained in:
k8s-merge-robot 2015-12-15 03:25:09 -08:00
commit 3680268c52
59 changed files with 191 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
cmd/kube-apiserver/app/server.go
View File

@ -39,6 +39,7 @@ import (
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
apiutil "k8s.io/kubernetes/pkg/api/util" apiutil "k8s.io/kubernetes/pkg/api/util"
"k8s.io/kubernetes/pkg/api/validation" "k8s.io/kubernetes/pkg/api/validation"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/apiserver" "k8s.io/kubernetes/pkg/apiserver"
"k8s.io/kubernetes/pkg/capabilities" "k8s.io/kubernetes/pkg/capabilities"
client "k8s.io/kubernetes/pkg/client/unversioned" client "k8s.io/kubernetes/pkg/client/unversioned"
@ -445,7 +446,7 @@ func (s *APIServer) Run(_ []string) error {
glog.Fatalf("Invalid server address: %v", err) glog.Fatalf("Invalid server address: %v", err)
} }
legacyV1Group, err := latest.Group("") legacyV1Group, err := latest.Group(api.GroupName)
if err != nil { if err != nil {
return err return err
} }
@ -463,7 +464,7 @@ func (s *APIServer) Run(_ []string) error {
storageDestinations.AddAPIGroup("", etcdStorage) storageDestinations.AddAPIGroup("", etcdStorage)
if !apiGroupVersionOverrides["extensions/v1beta1"].Disable { if !apiGroupVersionOverrides["extensions/v1beta1"].Disable {
expGroup, err := latest.Group("extensions") expGroup, err := latest.Group(extensions.GroupName)
if err != nil { if err != nil {
glog.Fatalf("Extensions API is enabled in runtime config, but not enabled in the environment variable KUBE_API_VERSIONS. Error: %v", err) glog.Fatalf("Extensions API is enabled in runtime config, but not enabled in the environment variable KUBE_API_VERSIONS. Error: %v", err)
} }
@ -474,7 +475,7 @@ func (s *APIServer) Run(_ []string) error {
if err != nil { if err != nil {
glog.Fatalf("Invalid extensions storage version or misconfigured etcd: %v", err) glog.Fatalf("Invalid extensions storage version or misconfigured etcd: %v", err)
} }
storageDestinations.AddAPIGroup("extensions", expEtcdStorage) storageDestinations.AddAPIGroup(extensions.GroupName, expEtcdStorage)
} }
updateEtcdOverrides(s.EtcdServersOverrides, storageVersions, s.EtcdPathPrefix, &storageDestinations, newEtcd) updateEtcdOverrides(s.EtcdServersOverrides, storageVersions, s.EtcdPathPrefix, &storageDestinations, newEtcd)

16
cmd/kube-apiserver/app/server_test.go
View File

@ -22,7 +22,9 @@ import (
"strings" "strings"
"testing" "testing"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/meta" "k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/master" "k8s.io/kubernetes/pkg/master"
"k8s.io/kubernetes/pkg/storage" "k8s.io/kubernetes/pkg/storage"
) )
@ -78,16 +80,16 @@ func TestGenerateStorageVersionMap(t *testing.T) {
legacyVersion: "v1", legacyVersion: "v1",
storageVersions: "v1,extensions/v1beta1", storageVersions: "v1,extensions/v1beta1",
expectedMap: map[string]string{ expectedMap: map[string]string{
"": "v1", api.GroupName: "v1",
"extensions": "extensions/v1beta1", extensions.GroupName: "extensions/v1beta1",
}, },
}, },
{ {
legacyVersion: "", legacyVersion: "",
storageVersions: "extensions/v1beta1,v1", storageVersions: "extensions/v1beta1,v1",
expectedMap: map[string]string{ expectedMap: map[string]string{
"": "v1", api.GroupName: "v1",
"extensions": "extensions/v1beta1", extensions.GroupName: "extensions/v1beta1",
}, },
}, },
{ {
@ -113,17 +115,17 @@ func TestUpdateEtcdOverrides(t *testing.T) {
servers []string servers []string
}{ }{
{ {
apigroup: "", apigroup: api.GroupName,
resource: "resource", resource: "resource",
servers: []string{"http://127.0.0.1:10000"}, servers: []string{"http://127.0.0.1:10000"},
}, },
{ {
apigroup: "", apigroup: api.GroupName,
resource: "resource", resource: "resource",
servers: []string{"http://127.0.0.1:10000", "http://127.0.0.1:20000"}, servers: []string{"http://127.0.0.1:10000", "http://127.0.0.1:20000"},
}, },
{ {
apigroup: "extensions", apigroup: extensions.GroupName,
resource: "resource", resource: "resource",
servers: []string{"http://127.0.0.1:10000"}, servers: []string{"http://127.0.0.1:10000"},
}, },

2
cmd/kube-version-change/version.go
View File

@ -39,7 +39,7 @@ var (
inputSource = flag.StringP("input", "i", "-", "Input source; '-' means stdin") inputSource = flag.StringP("input", "i", "-", "Input source; '-' means stdin")
outputDest = flag.StringP("output", "o", "-", "Output destination; '-' means stdout") outputDest = flag.StringP("output", "o", "-", "Output destination; '-' means stdout")
rewrite = flag.StringP("rewrite", "r", "", "If nonempty, use this as both input and output.") rewrite = flag.StringP("rewrite", "r", "", "If nonempty, use this as both input and output.")
outputVersion = flag.StringP("out-version", "v", latest.GroupOrDie("").GroupVersion.Version, "Version to convert input to") outputVersion = flag.StringP("out-version", "v", latest.GroupOrDie(api.GroupName).GroupVersion.Version, "Version to convert input to")
) )
// isYAML determines whether data is JSON or YAML formatted by seeing // isYAML determines whether data is JSON or YAML formatted by seeing

2
examples/https-nginx/make_secret.go
View File

@ -66,5 +66,5 @@ func main() {
"nginx.key": nginxKey, "nginx.key": nginxKey,
}, },
} }
fmt.Printf(runtime.EncodeOrDie(latest.GroupOrDie("").Codec, secret)) fmt.Printf(runtime.EncodeOrDie(latest.GroupOrDie(api.GroupName).Codec, secret))
} }

2
examples/sharing-clusters/make_secret.go
View File

@ -59,5 +59,5 @@ func main() {
"config": cfg, "config": cfg,
}, },
} }
fmt.Printf(runtime.EncodeOrDie(latest.GroupOrDie("").Codec, secret)) fmt.Printf(runtime.EncodeOrDie(latest.GroupOrDie(api.GroupName).Codec, secret))
} }

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

@ -23,10 +23,10 @@ import (
"github.com/golang/glog" "github.com/golang/glog"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/latest" "k8s.io/kubernetes/pkg/api/latest"
"k8s.io/kubernetes/pkg/util/sets" "k8s.io/kubernetes/pkg/util/sets"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/meta" "k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/registered" "k8s.io/kubernetes/pkg/api/registered"
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
@ -42,14 +42,14 @@ const importPrefix = "k8s.io/kubernetes/pkg/api"
var accessor = meta.NewAccessor() var accessor = meta.NewAccessor()
func init() { func init() {
groupMeta, err := latest.RegisterGroup("") groupMeta, err := latest.RegisterGroup(api.GroupName)
if err != nil { if err != nil {
glog.V(4).Infof("%v", err) glog.V(4).Infof("%v", err)
return return
} }
// Use the first API version in the list of registered versions as the latest. // Use the first API version in the list of registered versions as the latest.
registeredGroupVersions := registered.GroupVersionsForGroup("") registeredGroupVersions := registered.GroupVersionsForGroup(api.GroupName)
groupVersion := registeredGroupVersions[0] groupVersion := registeredGroupVersions[0]
*groupMeta = latest.GroupMeta{ *groupMeta = latest.GroupMeta{
GroupVersion: groupVersion, GroupVersion: groupVersion,
@ -106,7 +106,7 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
}, nil }, nil
default: default:
{ {
g, _ := latest.Group("") g, _ := latest.Group(api.GroupName)
return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions) return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
} }
} }

20
pkg/api/install/install_test.go
View File

@ -49,7 +49,7 @@ func TestCodec(t *testing.T) {
pod := internal.Pod{} pod := internal.Pod{}
// We do want to use package latest rather than testapi here, because we // We do want to use package latest rather than testapi here, because we
// want to test if the package install and package latest work as expected. // want to test if the package install and package latest work as expected.
data, err := latest.GroupOrDie("").Codec.Encode(&pod) data, err := latest.GroupOrDie(internal.GroupName).Codec.Encode(&pod)
if err != nil { if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
@ -57,17 +57,17 @@ func TestCodec(t *testing.T) {
if err := json.Unmarshal(data, &other); err != nil { if err := json.Unmarshal(data, &other); err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
if other.APIVersion != latest.GroupOrDie("").GroupVersion.Version || other.Kind != "Pod" { if other.APIVersion != latest.GroupOrDie(internal.GroupName).GroupVersion.Version || other.Kind != "Pod" {
t.Errorf("unexpected unmarshalled object %#v", other) t.Errorf("unexpected unmarshalled object %#v", other)
} }
} }
func TestInterfacesFor(t *testing.T) { func TestInterfacesFor(t *testing.T) {
if _, err := latest.GroupOrDie("").InterfacesFor(internal.SchemeGroupVersion); err == nil { if _, err := latest.GroupOrDie(internal.GroupName).InterfacesFor(internal.SchemeGroupVersion); err == nil {
t.Fatalf("unexpected non-error: %v", err) t.Fatalf("unexpected non-error: %v", err)
} }
for i, version := range latest.GroupOrDie("").GroupVersions { for i, version := range latest.GroupOrDie(internal.GroupName).GroupVersions {
if vi, err := latest.GroupOrDie("").InterfacesFor(version); err != nil || vi == nil { if vi, err := latest.GroupOrDie(internal.GroupName).InterfacesFor(version); err != nil || vi == nil {
t.Fatalf("%d: unexpected result: %v", i, err) t.Fatalf("%d: unexpected result: %v", i, err)
} }
} }
@ -78,16 +78,16 @@ func TestRESTMapper(t *testing.T) {
rcGVK := gv.WithKind("ReplicationController") rcGVK := gv.WithKind("ReplicationController")
podTemplateGVK := gv.WithKind("PodTemplate") podTemplateGVK := gv.WithKind("PodTemplate")
if gvk, err := latest.GroupOrDie("").RESTMapper.KindFor("replicationcontrollers"); err != nil || gvk != rcGVK { if gvk, err := latest.GroupOrDie(internal.GroupName).RESTMapper.KindFor("replicationcontrollers"); err != nil || gvk != rcGVK {
t.Errorf("unexpected version mapping: %v %v", gvk, err) t.Errorf("unexpected version mapping: %v %v", gvk, err)
} }
if m, err := latest.GroupOrDie("").RESTMapper.RESTMapping(podTemplateGVK.GroupKind(), ""); err != nil || m.GroupVersionKind != podTemplateGVK || m.Resource != "podtemplates" { if m, err := latest.GroupOrDie(internal.GroupName).RESTMapper.RESTMapping(podTemplateGVK.GroupKind(), ""); err != nil || m.GroupVersionKind != podTemplateGVK || m.Resource != "podtemplates" {
t.Errorf("unexpected version mapping: %#v %v", m, err) t.Errorf("unexpected version mapping: %#v %v", m, err)
} }
for _, version := range latest.GroupOrDie("").GroupVersions { for _, version := range latest.GroupOrDie(internal.GroupName).GroupVersions {
mapping, err := latest.GroupOrDie("").RESTMapper.RESTMapping(rcGVK.GroupKind(), version.Version) mapping, err := latest.GroupOrDie(internal.GroupName).RESTMapper.RESTMapping(rcGVK.GroupKind(), version.Version)
if err != nil { if err != nil {
t.Errorf("unexpected error: %v", err) t.Errorf("unexpected error: %v", err)
} }
@ -99,7 +99,7 @@ func TestRESTMapper(t *testing.T) {
t.Errorf("incorrect version: %v", mapping) t.Errorf("incorrect version: %v", mapping)
} }
interfaces, _ := latest.GroupOrDie("").InterfacesFor(version) interfaces, _ := latest.GroupOrDie(internal.GroupName).InterfacesFor(version)
if mapping.Codec != interfaces.Codec { if mapping.Codec != interfaces.Codec {
t.Errorf("unexpected codec: %#v, expected: %#v", mapping, interfaces) t.Errorf("unexpected codec: %#v, expected: %#v", mapping, interfaces)
} }

5
pkg/api/register.go
View File

@ -24,8 +24,11 @@ import (
// Scheme is the default instance of runtime.Scheme to which types in the Kubernetes API are already registered. // Scheme is the default instance of runtime.Scheme to which types in the Kubernetes API are already registered.
var Scheme = runtime.NewScheme() var Scheme = runtime.NewScheme()
// GroupName is the group name use in this package
const GroupName = ""
// SchemeGroupVersion is group version used to register these objects // SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = unversioned.GroupVersion{Group: "", Version: ""} var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: ""}
// Kind takes an unqualified kind and returns back a Group qualified GroupKind // Kind takes an unqualified kind and returns back a Group qualified GroupKind
func Kind(kind string) unversioned.GroupKind { func Kind(kind string) unversioned.GroupKind {

20
pkg/api/testapi/testapi.go
View File

@ -59,21 +59,21 @@ func init() {
} }
} }
if _, ok := Groups[api.SchemeGroupVersion.Group]; !ok { if _, ok := Groups[api.GroupName]; !ok {
Groups[api.SchemeGroupVersion.Group] = TestGroup{ Groups[api.GroupName] = TestGroup{
externalGroupVersion: unversioned.GroupVersion{Group: api.SchemeGroupVersion.Group, Version: latest.GroupOrDie(api.SchemeGroupVersion.Group).GroupVersion.Version}, externalGroupVersion: unversioned.GroupVersion{Group: api.GroupName, Version: latest.GroupOrDie(api.GroupName).GroupVersion.Version},
internalGroupVersion: api.SchemeGroupVersion, internalGroupVersion: api.SchemeGroupVersion,
} }
} }
if _, ok := Groups[extensions.SchemeGroupVersion.Group]; !ok { if _, ok := Groups[extensions.GroupName]; !ok {
Groups[extensions.SchemeGroupVersion.Group] = TestGroup{ Groups[extensions.GroupName] = TestGroup{
externalGroupVersion: unversioned.GroupVersion{Group: extensions.SchemeGroupVersion.Group, Version: latest.GroupOrDie(extensions.SchemeGroupVersion.Group).GroupVersion.Version}, externalGroupVersion: unversioned.GroupVersion{Group: extensions.GroupName, Version: latest.GroupOrDie(extensions.GroupName).GroupVersion.Version},
internalGroupVersion: extensions.SchemeGroupVersion, internalGroupVersion: extensions.SchemeGroupVersion,
} }
} }
Default = Groups[api.SchemeGroupVersion.Group] Default = Groups[api.GroupName]
Extensions = Groups[extensions.SchemeGroupVersion.Group] Extensions = Groups[extensions.GroupName]
} }
func (g TestGroup) GroupVersion() *unversioned.GroupVersion { func (g TestGroup) GroupVersion() *unversioned.GroupVersion {
@ -122,7 +122,7 @@ func (g TestGroup) MetadataAccessor() meta.MetadataAccessor {
// 'resource' should be the resource path, e.g. "pods" for the Pod type. 'name' should be // 'resource' should be the resource path, e.g. "pods" for the Pod type. 'name' should be
// empty for lists. // empty for lists.
func (g TestGroup) SelfLink(resource, name string) string { func (g TestGroup) SelfLink(resource, name string) string {
if g.externalGroupVersion.Group == api.SchemeGroupVersion.Group { if g.externalGroupVersion.Group == api.GroupName {
if name == "" { if name == "" {
return fmt.Sprintf("/api/%s/%s", g.externalGroupVersion.Version, resource) return fmt.Sprintf("/api/%s/%s", g.externalGroupVersion.Version, resource)
} }
@ -142,7 +142,7 @@ func (g TestGroup) SelfLink(resource, name string) string {
// /api/v1/watch/namespaces/foo/pods/pod0 for v1. // /api/v1/watch/namespaces/foo/pods/pod0 for v1.
func (g TestGroup) ResourcePathWithPrefix(prefix, resource, namespace, name string) string { func (g TestGroup) ResourcePathWithPrefix(prefix, resource, namespace, name string) string {
var path string var path string
if g.externalGroupVersion.Group == api.SchemeGroupVersion.Group { if g.externalGroupVersion.Group == api.GroupName {
path = "/api/" + g.externalGroupVersion.Version path = "/api/" + g.externalGroupVersion.Version
} else { } else {
// TODO: switch back once we have proper multiple group support // TODO: switch back once we have proper multiple group support

5
pkg/api/v1/register.go
View File

@ -23,8 +23,11 @@ import (
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
) )
// GroupName is the group name use in this package
const GroupName = ""
// SchemeGroupVersion is group version used to register these objects // SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = unversioned.GroupVersion{Group: "", Version: "v1"} var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1"}
// Codec encodes internal objects to the v1 scheme // Codec encodes internal objects to the v1 scheme
var Codec = runtime.CodecFor(api.Scheme, SchemeGroupVersion.String()) var Codec = runtime.CodecFor(api.Scheme, SchemeGroupVersion.String())

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

@ -28,7 +28,7 @@ import (
"k8s.io/kubernetes/pkg/api/meta" "k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/registered" "k8s.io/kubernetes/pkg/api/registered"
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
_ "k8s.io/kubernetes/pkg/apis/componentconfig" "k8s.io/kubernetes/pkg/apis/componentconfig"
"k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1" "k8s.io/kubernetes/pkg/apis/componentconfig/v1alpha1"
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/util/sets" "k8s.io/kubernetes/pkg/util/sets"
@ -39,13 +39,13 @@ const importPrefix = "k8s.io/kubernetes/pkg/apis/componentconfig"
var accessor = meta.NewAccessor() var accessor = meta.NewAccessor()
func init() { func init() {
groupMeta, err := latest.RegisterGroup("componentconfig") groupMeta, err := latest.RegisterGroup(componentconfig.GroupName)
if err != nil { if err != nil {
glog.V(4).Infof("%v", err) glog.V(4).Infof("%v", err)
return return
} }
registeredGroupVersions := registered.GroupVersionsForGroup("componentconfig") registeredGroupVersions := registered.GroupVersionsForGroup(componentconfig.GroupName)
groupVersion := registeredGroupVersions[0] groupVersion := registeredGroupVersions[0]
*groupMeta = latest.GroupMeta{ *groupMeta = latest.GroupMeta{
GroupVersion: groupVersion, GroupVersion: groupVersion,
@ -82,7 +82,7 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
MetadataAccessor: accessor, MetadataAccessor: accessor,
}, nil }, nil
default: default:
g, _ := latest.Group("componentconfig") g, _ := latest.Group(componentconfig.GroupName)
return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions) return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
} }
} }

22
pkg/apis/componentconfig/install/install_test.go
View File

@ -29,7 +29,7 @@ func TestCodec(t *testing.T) {
daemonSet := componentconfig.KubeProxyConfiguration{} daemonSet := componentconfig.KubeProxyConfiguration{}
// We do want to use package latest rather than testapi here, because we // We do want to use package latest rather than testapi here, because we
// want to test if the package install and package latest work as expected. // want to test if the package install and package latest work as expected.
data, err := latest.GroupOrDie("componentconfig").Codec.Encode(&daemonSet) data, err := latest.GroupOrDie(componentconfig.GroupName).Codec.Encode(&daemonSet)
if err != nil { if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
@ -37,36 +37,36 @@ func TestCodec(t *testing.T) {
if err := json.Unmarshal(data, &other); err != nil { if err := json.Unmarshal(data, &other); err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
if other.APIVersion != latest.GroupOrDie("componentconfig").GroupVersion.String() || other.Kind != "KubeProxyConfiguration" { if other.APIVersion != latest.GroupOrDie(componentconfig.GroupName).GroupVersion.String() || other.Kind != "KubeProxyConfiguration" {
t.Errorf("unexpected unmarshalled object %#v", other) t.Errorf("unexpected unmarshalled object %#v", other)
} }
} }
func TestInterfacesFor(t *testing.T) { func TestInterfacesFor(t *testing.T) {
if _, err := latest.GroupOrDie("componentconfig").InterfacesFor(componentconfig.SchemeGroupVersion); err == nil { if _, err := latest.GroupOrDie(componentconfig.GroupName).InterfacesFor(componentconfig.SchemeGroupVersion); err == nil {
t.Fatalf("unexpected non-error: %v", err) t.Fatalf("unexpected non-error: %v", err)
} }
for i, version := range latest.GroupOrDie("componentconfig").GroupVersions { for i, version := range latest.GroupOrDie(componentconfig.GroupName).GroupVersions {
if vi, err := latest.GroupOrDie("componentconfig").InterfacesFor(version); err != nil || vi == nil { if vi, err := latest.GroupOrDie(componentconfig.GroupName).InterfacesFor(version); err != nil || vi == nil {
t.Fatalf("%d: unexpected result: %v", i, err) t.Fatalf("%d: unexpected result: %v", i, err)
} }
} }
} }
func TestRESTMapper(t *testing.T) { func TestRESTMapper(t *testing.T) {
gv := unversioned.GroupVersion{Group: "componentconfig", Version: "v1alpha1"} gv := unversioned.GroupVersion{Group: componentconfig.GroupName, Version: "v1alpha1"}
proxyGVK := gv.WithKind("KubeProxyConfiguration") proxyGVK := gv.WithKind("KubeProxyConfiguration")
if gvk, err := latest.GroupOrDie("componentconfig").RESTMapper.KindFor("kubeproxyconfiguration"); err != nil || gvk != proxyGVK { if gvk, err := latest.GroupOrDie(componentconfig.GroupName).RESTMapper.KindFor("kubeproxyconfiguration"); err != nil || gvk != proxyGVK {
t.Errorf("unexpected version mapping: %v %v", gvk, err) t.Errorf("unexpected version mapping: %v %v", gvk, err)
} }
if m, err := latest.GroupOrDie("componentconfig").RESTMapper.RESTMapping(proxyGVK.GroupKind(), ""); err != nil || m.GroupVersionKind != proxyGVK || m.Resource != "kubeproxyconfigurations" { if m, err := latest.GroupOrDie(componentconfig.GroupName).RESTMapper.RESTMapping(proxyGVK.GroupKind(), ""); err != nil || m.GroupVersionKind != proxyGVK || m.Resource != "kubeproxyconfigurations" {
t.Errorf("unexpected version mapping: %#v %v", m, err) t.Errorf("unexpected version mapping: %#v %v", m, err)
} }
for _, version := range latest.GroupOrDie("componentconfig").GroupVersions { for _, version := range latest.GroupOrDie(componentconfig.GroupName).GroupVersions {
mapping, err := latest.GroupOrDie("componentconfig").RESTMapper.RESTMapping(proxyGVK.GroupKind(), version.Version) mapping, err := latest.GroupOrDie(componentconfig.GroupName).RESTMapper.RESTMapping(proxyGVK.GroupKind(), version.Version)
if err != nil { if err != nil {
t.Errorf("unexpected error: %v", err) t.Errorf("unexpected error: %v", err)
continue continue
@ -79,7 +79,7 @@ func TestRESTMapper(t *testing.T) {
t.Errorf("incorrect groupVersion: %v", mapping) t.Errorf("incorrect groupVersion: %v", mapping)
} }
interfaces, _ := latest.GroupOrDie("componentconfig").InterfacesFor(version) interfaces, _ := latest.GroupOrDie(componentconfig.GroupName).InterfacesFor(version)
if mapping.Codec != interfaces.Codec { if mapping.Codec != interfaces.Codec {
t.Errorf("unexpected codec: %#v, expected: %#v", mapping, interfaces) t.Errorf("unexpected codec: %#v, expected: %#v", mapping, interfaces)
} }

5
pkg/apis/componentconfig/register.go
View File

@ -25,8 +25,11 @@ func init() {
addKnownTypes() addKnownTypes()
} }
// GroupName is the group name use in this package
const GroupName = "componentconfig"
// SchemeGroupVersion is group version used to register these objects // SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = unversioned.GroupVersion{Group: "componentconfig", Version: ""} var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: ""}
// Kind takes an unqualified kind and returns back a Group qualified GroupKind // Kind takes an unqualified kind and returns back a Group qualified GroupKind
func Kind(kind string) unversioned.GroupKind { func Kind(kind string) unversioned.GroupKind {

5
pkg/apis/componentconfig/v1alpha1/register.go
View File

@ -22,8 +22,11 @@ import (
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
) )
// GroupName is the group name use in this package
const GroupName = "componentconfig"
// SchemeGroupVersion is group version used to register these objects // SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = unversioned.GroupVersion{Group: "componentconfig", Version: "v1alpha1"} var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1alpha1"}
var Codec = runtime.CodecFor(api.Scheme, SchemeGroupVersion.String()) var Codec = runtime.CodecFor(api.Scheme, SchemeGroupVersion.String())

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

@ -28,7 +28,7 @@ import (
"k8s.io/kubernetes/pkg/api/meta" "k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/registered" "k8s.io/kubernetes/pkg/api/registered"
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
_ "k8s.io/kubernetes/pkg/apis/extensions" "k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/apis/extensions/v1beta1" "k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/util/sets" "k8s.io/kubernetes/pkg/util/sets"
@ -39,13 +39,13 @@ const importPrefix = "k8s.io/kubernetes/pkg/apis/extensions"
var accessor = meta.NewAccessor() var accessor = meta.NewAccessor()
func init() { func init() {
groupMeta, err := latest.RegisterGroup("extensions") groupMeta, err := latest.RegisterGroup(extensions.GroupName)
if err != nil { if err != nil {
glog.V(4).Infof("%v", err) glog.V(4).Infof("%v", err)
return return
} }
registeredGroupVersions := registered.GroupVersionsForGroup("extensions") registeredGroupVersions := registered.GroupVersionsForGroup(extensions.GroupName)
groupVersion := registeredGroupVersions[0] groupVersion := registeredGroupVersions[0]
*groupMeta = latest.GroupMeta{ *groupMeta = latest.GroupMeta{
GroupVersion: groupVersion, GroupVersion: groupVersion,
@ -82,7 +82,7 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
MetadataAccessor: accessor, MetadataAccessor: accessor,
}, nil }, nil
default: default:
g, _ := latest.Group("extensions") g, _ := latest.Group(extensions.GroupName)
return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions) return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
} }
} }

23
pkg/apis/extensions/install/install_test.go
View File

@ -24,6 +24,7 @@ import (
"k8s.io/kubernetes/pkg/api/latest" "k8s.io/kubernetes/pkg/api/latest"
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/apis/extensions" "k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/apis/extensions/v1beta1"
) )
func TestResourceVersioner(t *testing.T) { func TestResourceVersioner(t *testing.T) {
@ -50,7 +51,7 @@ func TestCodec(t *testing.T) {
daemonSet := extensions.DaemonSet{} daemonSet := extensions.DaemonSet{}
// We do want to use package latest rather than testapi here, because we // We do want to use package latest rather than testapi here, because we
// want to test if the package install and package latest work as expected. // want to test if the package install and package latest work as expected.
data, err := latest.GroupOrDie("extensions").Codec.Encode(&daemonSet) data, err := latest.GroupOrDie(extensions.GroupName).Codec.Encode(&daemonSet)
if err != nil { if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
@ -58,37 +59,37 @@ func TestCodec(t *testing.T) {
if err := json.Unmarshal(data, &other); err != nil { if err := json.Unmarshal(data, &other); err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
if other.APIVersion != latest.GroupOrDie("extensions").GroupVersion.String() || other.Kind != "DaemonSet" { if other.APIVersion != latest.GroupOrDie(extensions.GroupName).GroupVersion.String() || other.Kind != "DaemonSet" {
t.Errorf("unexpected unmarshalled object %#v", other) t.Errorf("unexpected unmarshalled object %#v", other)
} }
} }
func TestInterfacesFor(t *testing.T) { func TestInterfacesFor(t *testing.T) {
if _, err := latest.GroupOrDie("extensions").InterfacesFor(extensions.SchemeGroupVersion); err == nil { if _, err := latest.GroupOrDie(extensions.GroupName).InterfacesFor(extensions.SchemeGroupVersion); err == nil {
t.Fatalf("unexpected non-error: %v", err) t.Fatalf("unexpected non-error: %v", err)
} }
for i, version := range latest.GroupOrDie("extensions").GroupVersions { for i, version := range latest.GroupOrDie(extensions.GroupName).GroupVersions {
if vi, err := latest.GroupOrDie("extensions").InterfacesFor(version); err != nil || vi == nil { if vi, err := latest.GroupOrDie(extensions.GroupName).InterfacesFor(version); err != nil || vi == nil {
t.Fatalf("%d: unexpected result: %v", i, err) t.Fatalf("%d: unexpected result: %v", i, err)
} }
} }
} }
func TestRESTMapper(t *testing.T) { func TestRESTMapper(t *testing.T) {
gv := unversioned.GroupVersion{Group: "extensions", Version: "v1beta1"} gv := v1beta1.SchemeGroupVersion
hpaGVK := gv.WithKind("HorizontalPodAutoscaler") hpaGVK := gv.WithKind("HorizontalPodAutoscaler")
daemonSetGVK := gv.WithKind("DaemonSet") daemonSetGVK := gv.WithKind("DaemonSet")
if gvk, err := latest.GroupOrDie("extensions").RESTMapper.KindFor("horizontalpodautoscalers"); err != nil || gvk != hpaGVK { if gvk, err := latest.GroupOrDie(extensions.GroupName).RESTMapper.KindFor("horizontalpodautoscalers"); err != nil || gvk != hpaGVK {
t.Errorf("unexpected version mapping: %v %v", gvk, err) t.Errorf("unexpected version mapping: %v %v", gvk, err)
} }
if m, err := latest.GroupOrDie("extensions").RESTMapper.RESTMapping(daemonSetGVK.GroupKind(), ""); err != nil || m.GroupVersionKind != daemonSetGVK || m.Resource != "daemonsets" { if m, err := latest.GroupOrDie(extensions.GroupName).RESTMapper.RESTMapping(daemonSetGVK.GroupKind(), ""); err != nil || m.GroupVersionKind != daemonSetGVK || m.Resource != "daemonsets" {
t.Errorf("unexpected version mapping: %#v %v", m, err) t.Errorf("unexpected version mapping: %#v %v", m, err)
} }
for _, version := range latest.GroupOrDie("extensions").GroupVersions { for _, version := range latest.GroupOrDie(extensions.GroupName).GroupVersions {
mapping, err := latest.GroupOrDie("extensions").RESTMapper.RESTMapping(hpaGVK.GroupKind(), version.Version) mapping, err := latest.GroupOrDie(extensions.GroupName).RESTMapper.RESTMapping(hpaGVK.GroupKind(), version.Version)
if err != nil { if err != nil {
t.Errorf("unexpected error: %v", err) t.Errorf("unexpected error: %v", err)
} }
@ -100,7 +101,7 @@ func TestRESTMapper(t *testing.T) {
t.Errorf("incorrect groupVersion: %v", mapping) t.Errorf("incorrect groupVersion: %v", mapping)
} }
interfaces, _ := latest.GroupOrDie("extensions").InterfacesFor(version) interfaces, _ := latest.GroupOrDie(extensions.GroupName).InterfacesFor(version)
if mapping.Codec != interfaces.Codec { if mapping.Codec != interfaces.Codec {
t.Errorf("unexpected codec: %#v, expected: %#v", mapping, interfaces) t.Errorf("unexpected codec: %#v, expected: %#v", mapping, interfaces)
} }

5
pkg/apis/extensions/register.go
View File

@ -21,8 +21,11 @@ import (
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
) )
// GroupName is the group name use in this package
const GroupName = "extensions"
// SchemeGroupVersion is group version used to register these objects // SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = unversioned.GroupVersion{Group: "extensions", Version: ""} var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: ""}
// Kind takes an unqualified kind and returns back a Group qualified GroupKind // Kind takes an unqualified kind and returns back a Group qualified GroupKind
func Kind(kind string) unversioned.GroupKind { func Kind(kind string) unversioned.GroupKind {

2
pkg/apis/extensions/v1beta1/defaults.go
View File

@ -25,7 +25,7 @@ func addDefaultingFuncs() {
api.Scheme.AddDefaultingFuncs( api.Scheme.AddDefaultingFuncs(
func(obj *APIVersion) { func(obj *APIVersion) {
if len(obj.APIGroup) == 0 { if len(obj.APIGroup) == 0 {
obj.APIGroup = "extensions" obj.APIGroup = GroupName
} }
}, },
func(obj *DaemonSet) { func(obj *DaemonSet) {

5
pkg/apis/extensions/v1beta1/register.go
View File

@ -22,8 +22,11 @@ import (
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
) )
// GroupName is the group name use in this package
const GroupName = "extensions"
// SchemeGroupVersion is group version used to register these objects // SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = unversioned.GroupVersion{Group: "extensions", Version: "v1beta1"} var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1beta1"}
var Codec = runtime.CodecFor(api.Scheme, SchemeGroupVersion.String()) var Codec = runtime.CodecFor(api.Scheme, SchemeGroupVersion.String())

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

@ -28,7 +28,7 @@ import (
"k8s.io/kubernetes/pkg/api/meta" "k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/registered" "k8s.io/kubernetes/pkg/api/registered"
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
_ "k8s.io/kubernetes/pkg/apis/metrics" "k8s.io/kubernetes/pkg/apis/metrics"
"k8s.io/kubernetes/pkg/apis/metrics/v1alpha1" "k8s.io/kubernetes/pkg/apis/metrics/v1alpha1"
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/util/sets" "k8s.io/kubernetes/pkg/util/sets"
@ -39,13 +39,13 @@ const importPrefix = "k8s.io/kubernetes/pkg/apis/metrics"
var accessor = meta.NewAccessor() var accessor = meta.NewAccessor()
func init() { func init() {
groupMeta, err := latest.RegisterGroup("metrics") groupMeta, err := latest.RegisterGroup(metrics.GroupName)
if err != nil { if err != nil {
glog.V(4).Infof("%v", err) glog.V(4).Infof("%v", err)
return return
} }
registeredGroupVersions := registered.GroupVersionsForGroup("metrics") registeredGroupVersions := registered.GroupVersionsForGroup(metrics.GroupName)
groupVersion := registeredGroupVersions[0] groupVersion := registeredGroupVersions[0]
*groupMeta = latest.GroupMeta{ *groupMeta = latest.GroupMeta{
GroupVersion: groupVersion, GroupVersion: groupVersion,
@ -82,7 +82,7 @@ func interfacesFor(version unversioned.GroupVersion) (*meta.VersionInterfaces, e
MetadataAccessor: accessor, MetadataAccessor: accessor,
}, nil }, nil
default: default:
g, _ := latest.Group("metrics") g, _ := latest.Group(metrics.GroupName)
return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions) return nil, fmt.Errorf("unsupported storage version: %s (valid: %v)", version, g.GroupVersions)
} }
} }

5
pkg/apis/metrics/register.go
View File

@ -26,8 +26,11 @@ func init() {
addKnownTypes() addKnownTypes()
} }
// GroupName is the group name use in this package
const GroupName = "metrics"
// SchemeGroupVersion is group version used to register these objects // SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = unversioned.GroupVersion{Group: "metrics", Version: ""} var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: ""}
// Kind takes an unqualified kind and returns back a Group qualified GroupKind // Kind takes an unqualified kind and returns back a Group qualified GroupKind
func Kind(kind string) unversioned.GroupKind { func Kind(kind string) unversioned.GroupKind {

5
pkg/apis/metrics/v1alpha1/register.go
View File

@ -22,8 +22,11 @@ import (
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
) )
// GroupName is the group name use in this package
const GroupName = "metrics"
// SchemeGroupVersion is group version used to register these objects // SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = unversioned.GroupVersion{Group: "metrics", Version: "v1alpha1"} var SchemeGroupVersion = unversioned.GroupVersion{Group: GroupName, Version: "v1alpha1"}
var Codec = runtime.CodecFor(api.Scheme, SchemeGroupVersion.String()) var Codec = runtime.CodecFor(api.Scheme, SchemeGroupVersion.String())

3
pkg/apiserver/api_installer.go
View File

@ -30,6 +30,7 @@ import (
"k8s.io/kubernetes/pkg/api/meta" "k8s.io/kubernetes/pkg/api/meta"
"k8s.io/kubernetes/pkg/api/rest" "k8s.io/kubernetes/pkg/api/rest"
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/conversion" "k8s.io/kubernetes/pkg/conversion"
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
watchjson "k8s.io/kubernetes/pkg/watch/json" watchjson "k8s.io/kubernetes/pkg/watch/json"
@ -136,7 +137,7 @@ func (a *APIInstaller) registerResourceHandlers(path string, storage rest.Storag
} }
// TODO This keeps it doing what it was doing before, but it doesn't feel right. // TODO This keeps it doing what it was doing before, but it doesn't feel right.
if fqKind.Group == "extensions" && fqKind.Kind == "ThirdPartyResourceData" { if fqKind.Group == extensions.GroupName && fqKind.Kind == "ThirdPartyResourceData" {
fqKindToRegister = fqKind fqKindToRegister = fqKind
fqKindToRegister.Group = a.group.GroupVersion.Group fqKindToRegister.Group = a.group.GroupVersion.Group
fqKindToRegister.Version = a.group.GroupVersion.Version fqKindToRegister.Version = a.group.GroupVersion.Version

4
pkg/apiserver/apiserver.go
View File

@ -211,7 +211,7 @@ func logStackOnRecover(panicReason interface{}, httpWriter http.ResponseWriter)
glog.Errorln(buffer.String()) glog.Errorln(buffer.String())
// TODO: make status unversioned or plumb enough of the request to deduce the requested API version // TODO: make status unversioned or plumb enough of the request to deduce the requested API version
errorJSON(apierrors.NewGenericServerResponse(http.StatusInternalServerError, "", "", "", "", 0, false), latest.GroupOrDie("").Codec, httpWriter) errorJSON(apierrors.NewGenericServerResponse(http.StatusInternalServerError, "", "", "", "", 0, false), latest.GroupOrDie(api.GroupName).Codec, httpWriter)
} }
func InstallServiceErrorHandler(container *restful.Container, requestResolver *RequestInfoResolver, apiVersions []string) { func InstallServiceErrorHandler(container *restful.Container, requestResolver *RequestInfoResolver, apiVersions []string) {
@ -222,7 +222,7 @@ func InstallServiceErrorHandler(container *restful.Container, requestResolver *R
func serviceErrorHandler(requestResolver *RequestInfoResolver, apiVersions []string, serviceErr restful.ServiceError, request *restful.Request, response *restful.Response) { func serviceErrorHandler(requestResolver *RequestInfoResolver, apiVersions []string, serviceErr restful.ServiceError, request *restful.Request, response *restful.Response) {
requestInfo, err := requestResolver.GetRequestInfo(request.Request) requestInfo, err := requestResolver.GetRequestInfo(request.Request)
codec := latest.GroupOrDie("").Codec codec := latest.GroupOrDie(api.GroupName).Codec
if err == nil && requestInfo.APIVersion != "" { if err == nil && requestInfo.APIVersion != "" {
// check if the api version is valid. // check if the api version is valid.
for _, version := range apiVersions { for _, version := range apiVersions {

3
pkg/apiserver/handlers_test.go
View File

@ -30,6 +30,7 @@ import (
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/api/errors"
"k8s.io/kubernetes/pkg/api/testapi" "k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/auth/authorizer" "k8s.io/kubernetes/pkg/auth/authorizer"
"k8s.io/kubernetes/pkg/util/sets" "k8s.io/kubernetes/pkg/util/sets"
) )
@ -281,7 +282,7 @@ func TestGetAttribs(t *testing.T) {
Verb: "list", Verb: "list",
Path: "/apis/extensions/v1beta1/namespaces/myns/jobs", Path: "/apis/extensions/v1beta1/namespaces/myns/jobs",
ResourceRequest: true, ResourceRequest: true,
APIGroup: "extensions", APIGroup: extensions.GroupName,
Namespace: "myns", Namespace: "myns",
Resource: "jobs", Resource: "jobs",
}, },

2
pkg/apiserver/resthandler_test.go
View File

@ -152,7 +152,7 @@ func (tc *patchTestCase) Run(t *testing.T) {
namespace := tc.startingPod.Namespace namespace := tc.startingPod.Namespace
name := tc.startingPod.Name name := tc.startingPod.Name
codec := latest.GroupOrDie("").Codec codec := latest.GroupOrDie(api.GroupName).Codec
testPatcher := &testPatcher{} testPatcher := &testPatcher{}
testPatcher.startingPod = tc.startingPod testPatcher.startingPod = tc.startingPod

5
pkg/client/unversioned/extensions.go
View File

@ -22,6 +22,7 @@ import (
"k8s.io/kubernetes/pkg/api/latest" "k8s.io/kubernetes/pkg/api/latest"
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/version" "k8s.io/kubernetes/pkg/version"
) )
@ -134,7 +135,7 @@ func NewExtensionsOrDie(c *Config) *ExtensionsClient {
func setExtensionsDefaults(config *Config) error { func setExtensionsDefaults(config *Config) error {
// if experimental group is not registered, return an error // if experimental group is not registered, return an error
g, err := latest.Group("extensions") g, err := latest.Group(extensions.GroupName)
if err != nil { if err != nil {
return err return err
} }
@ -151,7 +152,7 @@ func setExtensionsDefaults(config *Config) error {
versionInterfaces, err := g.InterfacesFor(*config.GroupVersion) versionInterfaces, err := g.InterfacesFor(*config.GroupVersion)
if err != nil { if err != nil {
return fmt.Errorf("Extensions API group/version '%v' is not recognized (valid values: %v)", return fmt.Errorf("Extensions API group/version '%v' is not recognized (valid values: %v)",
config.GroupVersion, g.GroupVersions) config.GroupVersion, latest.GroupOrDie(extensions.GroupName).GroupVersions)
} }
config.Codec = versionInterfaces.Codec config.Codec = versionInterfaces.Codec
if config.QPS == 0 { if config.QPS == 0 {

9
pkg/client/unversioned/helper.go
View File

@ -33,6 +33,7 @@ import (
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/latest" "k8s.io/kubernetes/pkg/api/latest"
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/runtime" "k8s.io/kubernetes/pkg/runtime"
"k8s.io/kubernetes/pkg/util" "k8s.io/kubernetes/pkg/util"
"k8s.io/kubernetes/pkg/util/sets" "k8s.io/kubernetes/pkg/util/sets"
@ -132,7 +133,7 @@ func New(c *Config) (*Client, error) {
return nil, err return nil, err
} }
if _, err := latest.Group("extensions"); err != nil { if _, err := latest.Group(extensions.GroupName); err != nil {
return &Client{RESTClient: client, ExtensionsClient: nil, DiscoveryClient: discoveryClient}, nil return &Client{RESTClient: client, ExtensionsClient: nil, DiscoveryClient: discoveryClient}, nil
} }
experimentalConfig := *c experimentalConfig := *c
@ -364,9 +365,9 @@ func SetKubernetesDefaults(config *Config) error {
if config.GroupVersion == nil { if config.GroupVersion == nil {
config.GroupVersion = defaultVersionFor(config) config.GroupVersion = defaultVersionFor(config)
} }
versionInterfaces, err := latest.GroupOrDie("").InterfacesFor(*config.GroupVersion) versionInterfaces, err := latest.GroupOrDie(api.GroupName).InterfacesFor(*config.GroupVersion)
if err != nil { if err != nil {
return fmt.Errorf("API version '%v' is not recognized (valid values: %v)", *config.GroupVersion, latest.GroupOrDie("").GroupVersions) return fmt.Errorf("API version '%v' is not recognized (valid values: %v)", *config.GroupVersion, latest.GroupOrDie(api.GroupName).GroupVersions)
} }
if config.Codec == nil { if config.Codec == nil {
config.Codec = versionInterfaces.Codec config.Codec = versionInterfaces.Codec
@ -525,7 +526,7 @@ func defaultVersionFor(config *Config) *unversioned.GroupVersion {
// Clients default to the preferred code API version // Clients default to the preferred code API version
// TODO: implement version negotiation (highest version supported by server) // TODO: implement version negotiation (highest version supported by server)
// TODO this drops out when groupmeta is refactored // TODO this drops out when groupmeta is refactored
copyGroupVersion := latest.GroupOrDie("").GroupVersion copyGroupVersion := latest.GroupOrDie(api.GroupName).GroupVersion
return &copyGroupVersion return &copyGroupVersion
} }

2
pkg/client/unversioned/jobs.go
View File

@ -87,7 +87,7 @@ func (c *jobs) Delete(name string, options *api.DeleteOptions) (err error) {
return c.r.Delete().Namespace(c.ns).Resource("jobs").Name(name).Do().Error() return c.r.Delete().Namespace(c.ns).Resource("jobs").Name(name).Do().Error()
} }
body, err := api.Scheme.EncodeToVersion(options, latest.GroupOrDie("").GroupVersion.String()) body, err := api.Scheme.EncodeToVersion(options, latest.GroupOrDie(api.GroupName).GroupVersion.String())
if err != nil { if err != nil {
return err return err
} }

2
pkg/controller/controller_utils.go
View File

@ -259,7 +259,7 @@ func getPodsAnnotationSet(template *api.PodTemplateSpec, object runtime.Object)
if err != nil { if err != nil {
return desiredAnnotations, fmt.Errorf("unable to get controller reference: %v", err) return desiredAnnotations, fmt.Errorf("unable to get controller reference: %v", err)
} }
createdByRefJson, err := latest.GroupOrDie("").Codec.Encode(&api.SerializedReference{ createdByRefJson, err := latest.GroupOrDie(api.GroupName).Codec.Encode(&api.SerializedReference{
Reference: *createdByRef, Reference: *createdByRef,
}) })
if err != nil { if err != nil {

6
pkg/kubectl/cmd/util/factory.go
View File

@ -164,9 +164,9 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory {
return nil, err return nil, err
} }
switch gvk.Group { switch gvk.Group {
case api.SchemeGroupVersion.Group: case api.GroupName:
return client.RESTClient, nil return client.RESTClient, nil
case extensions.SchemeGroupVersion.Group: case extensions.GroupName:
return client.ExtensionsClient.RESTClient, nil return client.ExtensionsClient.RESTClient, nil
} }
return nil, fmt.Errorf("unable to get RESTClient for resource '%s'", mapping.Resource) return nil, fmt.Errorf("unable to get RESTClient for resource '%s'", mapping.Resource)
@ -500,7 +500,7 @@ func (c *clientSwaggerSchema) ValidateBytes(data []byte) error {
if ok := registered.IsRegisteredAPIGroupVersion(gvk.GroupVersion()); !ok { if ok := registered.IsRegisteredAPIGroupVersion(gvk.GroupVersion()); !ok {
return fmt.Errorf("API version %q isn't supported, only supports API versions %q", gvk.GroupVersion().String(), registered.RegisteredGroupVersions) return fmt.Errorf("API version %q isn't supported, only supports API versions %q", gvk.GroupVersion().String(), registered.RegisteredGroupVersions)
} }
if gvk.Group == "extensions" { if gvk.Group == extensions.GroupName {
if c.c.ExtensionsClient == nil { if c.c.ExtensionsClient == nil {
return errors.New("unable to validate: no experimental client") return errors.New("unable to validate: no experimental client")
} }

3
pkg/kubectl/cmd/util/helpers.go
View File

@ -28,6 +28,7 @@ import (
"strings" "strings"
"time" "time"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/errors" "k8s.io/kubernetes/pkg/api/errors"
"k8s.io/kubernetes/pkg/api/latest" "k8s.io/kubernetes/pkg/api/latest"
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
@ -380,7 +381,7 @@ func Merge(dst runtime.Object, fragment, kind string) (runtime.Object, error) {
return nil, err return nil, err
} }
i, err := latest.GroupOrDie("").InterfacesFor(groupVersion) i, err := latest.GroupOrDie(api.GroupName).InterfacesFor(groupVersion)
if err != nil { if err != nil {
return nil, err return nil, err
} }

2
pkg/kubectl/resource/result.go
View File

@ -221,7 +221,7 @@ func AsVersionedObject(infos []*Info, forceList bool, version string) (runtime.O
object = objects[0] object = objects[0]
} else { } else {
object = &api.List{Items: objects} object = &api.List{Items: objects}
converted, err := tryConvert(api.Scheme, object, version, latest.GroupOrDie("").GroupVersion.Version) converted, err := tryConvert(api.Scheme, object, version, latest.GroupOrDie(api.GroupName).GroupVersion.Version)
if err != nil { if err != nil {
return nil, err return nil, err
} }

2
pkg/kubelet/config/common.go
View File

@ -78,7 +78,7 @@ func getSelfLink(name, namespace string) string {
if len(namespace) == 0 { if len(namespace) == 0 {
namespace = api.NamespaceDefault namespace = api.NamespaceDefault
} }
selfLink = fmt.Sprintf("/api/"+latest.GroupOrDie("").GroupVersion.Version+"/pods/namespaces/%s/%s", name, namespace) selfLink = fmt.Sprintf("/api/"+latest.GroupOrDie(api.GroupName).GroupVersion.Version+"/pods/namespaces/%s/%s", name, namespace)
return selfLink return selfLink
} }

4
pkg/kubelet/dockertools/manager.go
View File

@ -659,7 +659,7 @@ func (dm *DockerManager) runContainer(
} }
if container.Lifecycle != nil && container.Lifecycle.PreStop != nil { if container.Lifecycle != nil && container.Lifecycle.PreStop != nil {
// TODO: This is kind of hacky, we should really just encode the bits we need. // TODO: This is kind of hacky, we should really just encode the bits we need.
data, err := latest.GroupOrDie("").Codec.Encode(pod) data, err := latest.GroupOrDie(api.GroupName).Codec.Encode(pod)
if err != nil { if err != nil {
glog.Errorf("Failed to encode pod: %s for prestop hook", pod.Name) glog.Errorf("Failed to encode pod: %s for prestop hook", pod.Name)
} else { } else {
@ -1410,7 +1410,7 @@ func containerAndPodFromLabels(inspect *docker.Container) (pod *api.Pod, contain
// the pod data may not be set // the pod data may not be set
if body, found := labels[kubernetesPodLabel]; found { if body, found := labels[kubernetesPodLabel]; found {
pod = &api.Pod{} pod = &api.Pod{}
if err = latest.GroupOrDie("").Codec.DecodeInto([]byte(body), pod); err == nil { if err = latest.GroupOrDie(api.GroupName).Codec.DecodeInto([]byte(body), pod); err == nil {
name := labels[kubernetesContainerLabel] name := labels[kubernetesContainerLabel]
for ix := range pod.Spec.Containers { for ix := range pod.Spec.Containers {
if pod.Spec.Containers[ix].Name == name { if pod.Spec.Containers[ix].Name == name {

2
pkg/kubelet/server.go
View File

@ -470,7 +470,7 @@ func encodePods(pods []*api.Pod) (data []byte, err error) {
for _, pod := range pods { for _, pod := range pods {
podList.Items = append(podList.Items, *pod) podList.Items = append(podList.Items, *pod)
} }
return latest.GroupOrDie("").Codec.Encode(podList) return latest.GroupOrDie(api.GroupName).Codec.Encode(podList)
} }
// getPods returns a list of pods bound to the Kubelet and their spec. // getPods returns a list of pods bound to the Kubelet and their spec.

32
pkg/master/master.go
View File

@ -35,7 +35,7 @@ import (
"k8s.io/kubernetes/pkg/api/unversioned" "k8s.io/kubernetes/pkg/api/unversioned"
apiutil "k8s.io/kubernetes/pkg/api/util" apiutil "k8s.io/kubernetes/pkg/api/util"
"k8s.io/kubernetes/pkg/api/v1" "k8s.io/kubernetes/pkg/api/v1"
expapi "k8s.io/kubernetes/pkg/apis/extensions" "k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/apiserver" "k8s.io/kubernetes/pkg/apiserver"
"k8s.io/kubernetes/pkg/auth/authenticator" "k8s.io/kubernetes/pkg/auth/authenticator"
"k8s.io/kubernetes/pkg/auth/authorizer" "k8s.io/kubernetes/pkg/auth/authorizer"
@ -635,7 +635,7 @@ func (m *Master) init(c *Config) {
allGroups := []unversioned.APIGroup{} allGroups := []unversioned.APIGroup{}
// Install extensions unless disabled. // Install extensions unless disabled.
if !m.apiGroupVersionOverrides["extensions/v1beta1"].Disable { if !m.apiGroupVersionOverrides["extensions/v1beta1"].Disable {
m.thirdPartyStorage = c.StorageDestinations.APIGroups["extensions"].Default m.thirdPartyStorage = c.StorageDestinations.APIGroups[extensions.GroupName].Default
m.thirdPartyResources = map[string]*thirdpartyresourcedataetcd.REST{} m.thirdPartyResources = map[string]*thirdpartyresourcedataetcd.REST{}
expVersion := m.experimental(c) expVersion := m.experimental(c)
@ -643,7 +643,7 @@ func (m *Master) init(c *Config) {
if err := expVersion.InstallREST(m.handlerContainer); err != nil { if err := expVersion.InstallREST(m.handlerContainer); err != nil {
glog.Fatalf("Unable to setup experimental api: %v", err) glog.Fatalf("Unable to setup experimental api: %v", err)
} }
g, err := latest.Group("extensions") g, err := latest.Group(extensions.GroupName)
if err != nil { if err != nil {
glog.Fatalf("Unable to setup experimental api: %v", err) glog.Fatalf("Unable to setup experimental api: %v", err)
} }
@ -662,7 +662,7 @@ func (m *Master) init(c *Config) {
Versions: expAPIVersions, Versions: expAPIVersions,
PreferredVersion: unversioned.GroupVersionForDiscovery{GroupVersion: storageVersion, Version: apiutil.GetVersion(storageVersion)}, PreferredVersion: unversioned.GroupVersionForDiscovery{GroupVersion: storageVersion, Version: apiutil.GetVersion(storageVersion)},
} }
apiserver.AddGroupWebService(m.handlerContainer, c.APIGroupPrefix+"/"+latest.GroupOrDie("extensions").GroupVersion.Group, group) apiserver.AddGroupWebService(m.handlerContainer, c.APIGroupPrefix+"/"+latest.GroupOrDie(extensions.GroupName).GroupVersion.Group, group)
allGroups = append(allGroups, group) allGroups = append(allGroups, group)
apiserver.InstallServiceErrorHandler(m.handlerContainer, m.newRequestInfoResolver(), []string{expVersion.GroupVersion.String()}) apiserver.InstallServiceErrorHandler(m.handlerContainer, m.newRequestInfoResolver(), []string{expVersion.GroupVersion.String()})
} }
@ -854,12 +854,12 @@ func (m *Master) defaultAPIGroupVersion() *apiserver.APIGroupVersion {
Root: m.apiPrefix, Root: m.apiPrefix,
RequestInfoResolver: m.newRequestInfoResolver(), RequestInfoResolver: m.newRequestInfoResolver(),
Mapper: latest.GroupOrDie("").RESTMapper, Mapper: latest.GroupOrDie(api.GroupName).RESTMapper,
Creater: api.Scheme, Creater: api.Scheme,
Convertor: api.Scheme, Convertor: api.Scheme,
Typer: api.Scheme, Typer: api.Scheme,
Linker: latest.GroupOrDie("").SelfLinker, Linker: latest.GroupOrDie(api.GroupName).SelfLinker,
Admit: m.admissionControl, Admit: m.admissionControl,
Context: m.requestContextMapper, Context: m.requestContextMapper,
@ -882,7 +882,7 @@ func (m *Master) api_v1() *apiserver.APIGroupVersion {
} }
// HasThirdPartyResource returns true if a particular third party resource currently installed. // HasThirdPartyResource returns true if a particular third party resource currently installed.
func (m *Master) HasThirdPartyResource(rsrc *expapi.ThirdPartyResource) (bool, error) { func (m *Master) HasThirdPartyResource(rsrc *extensions.ThirdPartyResource) (bool, error) {
_, group, err := thirdpartyresourcedata.ExtractApiGroupAndKind(rsrc) _, group, err := thirdpartyresourcedata.ExtractApiGroupAndKind(rsrc)
if err != nil { if err != nil {
return false, err return false, err
@ -932,7 +932,7 @@ func (m *Master) removeAllThirdPartyResources(registry *thirdpartyresourcedataet
if err != nil { if err != nil {
return err return err
} }
list, ok := existingData.(*expapi.ThirdPartyResourceDataList) list, ok := existingData.(*extensions.ThirdPartyResourceDataList)
if !ok { if !ok {
return fmt.Errorf("expected a *ThirdPartyResourceDataList, got %#v", list) return fmt.Errorf("expected a *ThirdPartyResourceDataList, got %#v", list)
} }
@ -969,7 +969,7 @@ func (m *Master) addThirdPartyResourceStorage(path string, storage *thirdpartyre
// For example, if you install a resource ThirdPartyResource{ Name: "foo.company.com", Versions: {"v1"} } // For example, if you install a resource ThirdPartyResource{ Name: "foo.company.com", Versions: {"v1"} }
// then the following RESTful resource is created on the server: // then the following RESTful resource is created on the server:
// http://<host>/apis/company.com/v1/foos/... // http://<host>/apis/company.com/v1/foos/...
func (m *Master) InstallThirdPartyResource(rsrc *expapi.ThirdPartyResource) error { func (m *Master) InstallThirdPartyResource(rsrc *extensions.ThirdPartyResource) error {
kind, group, err := thirdpartyresourcedata.ExtractApiGroupAndKind(rsrc) kind, group, err := thirdpartyresourcedata.ExtractApiGroupAndKind(rsrc)
if err != nil { if err != nil {
return err return err
@ -1002,7 +1002,7 @@ func (m *Master) thirdpartyapi(group, kind, version string) *apiserver.APIGroupV
strings.ToLower(kind) + "s": resourceStorage, strings.ToLower(kind) + "s": resourceStorage,
} }
optionsExternalVersion := latest.GroupOrDie("").GroupVersion optionsExternalVersion := latest.GroupOrDie(api.GroupName).GroupVersion
return &apiserver.APIGroupVersion{ return &apiserver.APIGroupVersion{
Root: apiRoot, Root: apiRoot,
@ -1013,9 +1013,9 @@ func (m *Master) thirdpartyapi(group, kind, version string) *apiserver.APIGroupV
Convertor: api.Scheme, Convertor: api.Scheme,
Typer: api.Scheme, Typer: api.Scheme,
Mapper: thirdpartyresourcedata.NewMapper(latest.GroupOrDie("extensions").RESTMapper, kind, version, group), Mapper: thirdpartyresourcedata.NewMapper(latest.GroupOrDie(extensions.GroupName).RESTMapper, kind, version, group),
Codec: thirdpartyresourcedata.NewCodec(latest.GroupOrDie("extensions").Codec, kind), Codec: thirdpartyresourcedata.NewCodec(latest.GroupOrDie(extensions.GroupName).Codec, kind),
Linker: latest.GroupOrDie("extensions").SelfLinker, Linker: latest.GroupOrDie(extensions.GroupName).SelfLinker,
Storage: storage, Storage: storage,
OptionsExternalVersion: &optionsExternalVersion, OptionsExternalVersion: &optionsExternalVersion,
@ -1040,7 +1040,7 @@ func (m *Master) experimental(c *Config) *apiserver.APIGroupVersion {
} }
storageDecorator := c.storageDecorator() storageDecorator := c.storageDecorator()
dbClient := func(resource string) storage.Interface { dbClient := func(resource string) storage.Interface {
return c.StorageDestinations.get("extensions", resource) return c.StorageDestinations.get(extensions.GroupName, resource)
} }
storage := map[string]rest.Storage{} storage := map[string]rest.Storage{}
@ -1091,8 +1091,8 @@ func (m *Master) experimental(c *Config) *apiserver.APIGroupVersion {
storage["ingresses/status"] = ingressStatusStorage storage["ingresses/status"] = ingressStatusStorage
} }
extensionsGroup := latest.GroupOrDie("extensions") extensionsGroup := latest.GroupOrDie(extensions.GroupName)
optionsExternalVersion := latest.GroupOrDie("").GroupVersion optionsExternalVersion := latest.GroupOrDie(api.GroupName).GroupVersion
return &apiserver.APIGroupVersion{ return &apiserver.APIGroupVersion{
Root: m.apiGroupPrefix, Root: m.apiGroupPrefix,

16
pkg/master/master_test.go
View File

@ -64,12 +64,12 @@ func setUp(t *testing.T) (Master, *etcdtesting.EtcdTestServer, Config, *assert.A
storageVersions := make(map[string]string) storageVersions := make(map[string]string)
storageDestinations := NewStorageDestinations() storageDestinations := NewStorageDestinations()
storageDestinations.AddAPIGroup( storageDestinations.AddAPIGroup(
"", etcdstorage.NewEtcdStorage(server.Client, testapi.Default.Codec(), etcdtest.PathPrefix())) api.GroupName, etcdstorage.NewEtcdStorage(server.Client, testapi.Default.Codec(), etcdtest.PathPrefix()))
storageDestinations.AddAPIGroup( storageDestinations.AddAPIGroup(
"extensions", etcdstorage.NewEtcdStorage(server.Client, testapi.Extensions.Codec(), etcdtest.PathPrefix())) extensions.GroupName, etcdstorage.NewEtcdStorage(server.Client, testapi.Extensions.Codec(), etcdtest.PathPrefix()))
config.StorageDestinations = storageDestinations config.StorageDestinations = storageDestinations
storageVersions[""] = testapi.Default.GroupVersion().String() storageVersions[api.GroupName] = testapi.Default.GroupVersion().String()
storageVersions["extensions"] = testapi.Extensions.GroupVersion().String() storageVersions[extensions.GroupName] = testapi.Extensions.GroupVersion().String()
config.StorageVersions = storageVersions config.StorageVersions = storageVersions
config.PublicAddress = net.ParseIP("192.168.10.4") config.PublicAddress = net.ParseIP("192.168.10.4")
master.nodeRegistry = registrytest.NewNodeRegistry([]string{"node1", "node2"}, api.NodeResources{}) master.nodeRegistry = registrytest.NewNodeRegistry([]string{"node1", "node2"}, api.NodeResources{})
@ -328,7 +328,7 @@ func TestExpapi(t *testing.T) {
master, etcdserver, config, assert := setUp(t) master, etcdserver, config, assert := setUp(t)
defer etcdserver.Terminate(t) defer etcdserver.Terminate(t)
extensionsGroupMeta := latest.GroupOrDie("extensions") extensionsGroupMeta := latest.GroupOrDie(extensions.GroupName)
expAPIGroup := master.experimental(&config) expAPIGroup := master.experimental(&config)
assert.Equal(expAPIGroup.Root, master.apiGroupPrefix) assert.Equal(expAPIGroup.Root, master.apiGroupPrefix)
@ -409,7 +409,7 @@ func TestDiscoveryAtAPIS(t *testing.T) {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
expectGroupName := "extensions" expectGroupName := extensions.GroupName
expectVersions := []unversioned.GroupVersionForDiscovery{ expectVersions := []unversioned.GroupVersionForDiscovery{
{ {
GroupVersion: testapi.Extensions.GroupVersion().String(), GroupVersion: testapi.Extensions.GroupVersion().String(),
@ -417,8 +417,8 @@ func TestDiscoveryAtAPIS(t *testing.T) {
}, },
} }
expectPreferredVersion := unversioned.GroupVersionForDiscovery{ expectPreferredVersion := unversioned.GroupVersionForDiscovery{
GroupVersion: config.StorageVersions["extensions"], GroupVersion: config.StorageVersions[extensions.GroupName],
Version: apiutil.GetVersion(config.StorageVersions["extensions"]), Version: apiutil.GetVersion(config.StorageVersions[extensions.GroupName]),
} }
assert.Equal(expectGroupName, groupList.Groups[0].Name) assert.Equal(expectGroupName, groupList.Groups[0].Name)
assert.Equal(expectVersions, groupList.Groups[0].Versions) assert.Equal(expectVersions, groupList.Groups[0].Versions)

2
pkg/registry/daemonset/etcd/etcd_test.go
View File

@ -30,7 +30,7 @@ import (
) )
func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName)
daemonSetStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) daemonSetStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return daemonSetStorage, statusStorage, server return daemonSetStorage, statusStorage, server
} }

2
pkg/registry/deployment/etcd/etcd_test.go
View File

@ -32,7 +32,7 @@ import (
) )
func newStorage(t *testing.T) (*DeploymentStorage, *etcdtesting.EtcdTestServer) { func newStorage(t *testing.T) (*DeploymentStorage, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName)
deploymentStorage := NewStorage(etcdStorage, generic.UndecoratedStorage) deploymentStorage := NewStorage(etcdStorage, generic.UndecoratedStorage)
return &deploymentStorage, server return &deploymentStorage, server
} }

2
pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go
View File

@ -32,7 +32,7 @@ import (
) )
func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName)
horizontalPodAutoscalerStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) horizontalPodAutoscalerStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return horizontalPodAutoscalerStorage, statusStorage, server return horizontalPodAutoscalerStorage, statusStorage, server
} }

2
pkg/registry/ingress/etcd/etcd_test.go
View File

@ -31,7 +31,7 @@ import (
) )
func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName)
ingressStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) ingressStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return ingressStorage, statusStorage, server return ingressStorage, statusStorage, server
} }

2
pkg/registry/job/etcd/etcd_test.go
View File

@ -32,7 +32,7 @@ import (
) )
func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) { func newStorage(t *testing.T) (*REST, *StatusREST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName)
jobStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage) jobStorage, statusStorage := NewREST(etcdStorage, generic.UndecoratedStorage)
return jobStorage, statusStorage, server return jobStorage, statusStorage, server
} }

2
pkg/registry/thirdpartyresource/etcd/etcd_test.go
View File

@ -32,7 +32,7 @@ import (
) )
func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName)
return NewREST(etcdStorage, generic.UndecoratedStorage), server return NewREST(etcdStorage, generic.UndecoratedStorage), server
} }

4
pkg/registry/thirdpartyresourcedata/codec.go
View File

@ -68,9 +68,9 @@ func (t *thirdPartyResourceDataMapper) RESTMapping(gk unversioned.GroupKind, ver
} }
// TODO figure out why we're doing this rewriting // TODO figure out why we're doing this rewriting
extensionGK := unversioned.GroupKind{Group: "extensions", Kind: "ThirdPartyResourceData"} extensionGK := unversioned.GroupKind{Group: extensions.GroupName, Kind: "ThirdPartyResourceData"}
mapping, err := t.mapper.RESTMapping(extensionGK, latest.GroupOrDie("extensions").GroupVersion.Version) mapping, err := t.mapper.RESTMapping(extensionGK, latest.GroupOrDie(extensions.GroupName).GroupVersion.Version)
if err != nil { if err != nil {
return nil, err return nil, err
} }

2
pkg/registry/thirdpartyresourcedata/etcd/etcd_test.go
View File

@ -32,7 +32,7 @@ import (
) )
func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) { func newStorage(t *testing.T) (*REST, *etcdtesting.EtcdTestServer) {
etcdStorage, server := registrytest.NewEtcdStorage(t, "extensions") etcdStorage, server := registrytest.NewEtcdStorage(t, extensions.GroupName)
return NewREST(etcdStorage, generic.UndecoratedStorage, "foo", "bar"), server return NewREST(etcdStorage, generic.UndecoratedStorage, "foo", "bar"), server
} }

4
pkg/util/io/io.go
View File

@ -39,7 +39,7 @@ func LoadPodFromFile(filePath string) (*api.Pod, error) {
} }
pod := &api.Pod{} pod := &api.Pod{}
if err := latest.GroupOrDie("").Codec.DecodeInto(podDef, pod); err != nil { if err := latest.GroupOrDie(api.GroupName).Codec.DecodeInto(podDef, pod); err != nil {
return nil, fmt.Errorf("failed decoding file: %v", err) return nil, fmt.Errorf("failed decoding file: %v", err)
} }
return pod, nil return pod, nil
@ -50,7 +50,7 @@ func SavePodToFile(pod *api.Pod, filePath string, perm os.FileMode) error {
if filePath == "" { if filePath == "" {
return fmt.Errorf("file path not specified") return fmt.Errorf("file path not specified")
} }
data, err := latest.GroupOrDie("").Codec.Encode(pod) data, err := latest.GroupOrDie(api.GroupName).Codec.Encode(pod)
if err != nil { if err != nil {
return fmt.Errorf("failed encoding pod: %v", err) return fmt.Errorf("failed encoding pod: %v", err)
} }

4
pkg/util/io/io_test.go
View File

@ -32,8 +32,8 @@ func TestSavePodToFile(t *testing.T) {
pod := volume.NewPersistentVolumeRecyclerPodTemplate() pod := volume.NewPersistentVolumeRecyclerPodTemplate()
// sets all default values on a pod for equality comparison after decoding from file // sets all default values on a pod for equality comparison after decoding from file
encoded, err := latest.GroupOrDie("").Codec.Encode(pod) encoded, err := latest.GroupOrDie(api.GroupName).Codec.Encode(pod)
latest.GroupOrDie("").Codec.DecodeInto(encoded, pod) latest.GroupOrDie(api.GroupName).Codec.DecodeInto(encoded, pod)
path := fmt.Sprintf("/tmp/kube-io-test-%s", uuid.New()) path := fmt.Sprintf("/tmp/kube-io-test-%s", uuid.New())
defer os.Remove(path) defer os.Remove(path)

2
test/e2e/dns.go
View File

@ -42,7 +42,7 @@ func createDNSPod(namespace, wheezyProbeCmd, jessieProbeCmd string) *api.Pod {
pod := &api.Pod{ pod := &api.Pod{
TypeMeta: unversioned.TypeMeta{ TypeMeta: unversioned.TypeMeta{
Kind: "Pod", Kind: "Pod",
APIVersion: latest.GroupOrDie("").GroupVersion.Version, APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.Version,
}, },
ObjectMeta: api.ObjectMeta{ ObjectMeta: api.ObjectMeta{
Name: "dns-test-" + string(util.NewUUID()), Name: "dns-test-" + string(util.NewUUID()),

2
test/e2e/empty_dir.go
View File

@ -313,7 +313,7 @@ func testPodWithVolume(image, path string, source *api.EmptyDirVolumeSource) *ap
return &api.Pod{ return &api.Pod{
TypeMeta: unversioned.TypeMeta{ TypeMeta: unversioned.TypeMeta{
Kind: "Pod", Kind: "Pod",
APIVersion: latest.GroupOrDie("").GroupVersion.Version, APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.Version,
}, },
ObjectMeta: api.ObjectMeta{ ObjectMeta: api.ObjectMeta{
Name: podName, Name: podName,

2
test/e2e/host_path.go
View File

@ -111,7 +111,7 @@ func testPodWithHostVol(path string, source *api.HostPathVolumeSource) *api.Pod
return &api.Pod{ return &api.Pod{
TypeMeta: unversioned.TypeMeta{ TypeMeta: unversioned.TypeMeta{
Kind: "Pod", Kind: "Pod",
APIVersion: latest.GroupOrDie("").GroupVersion.Version, APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.Version,
}, },
ObjectMeta: api.ObjectMeta{ ObjectMeta: api.ObjectMeta{
Name: podName, Name: podName,

4
test/e2e/kubelet_etc_hosts.go
View File

@ -143,7 +143,7 @@ func (config *KubeletManagedHostConfig) createPodSpec(podName string) *api.Pod {
pod := &api.Pod{ pod := &api.Pod{
TypeMeta: unversioned.TypeMeta{ TypeMeta: unversioned.TypeMeta{
Kind: "Pod", Kind: "Pod",
APIVersion: latest.GroupOrDie("").GroupVersion.Version, APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.Version,
}, },
ObjectMeta: api.ObjectMeta{ ObjectMeta: api.ObjectMeta{
Name: podName, Name: podName,
@ -204,7 +204,7 @@ func (config *KubeletManagedHostConfig) createPodSpecWithHostNetwork(podName str
pod := &api.Pod{ pod := &api.Pod{
TypeMeta: unversioned.TypeMeta{ TypeMeta: unversioned.TypeMeta{
Kind: "Pod", Kind: "Pod",
APIVersion: latest.GroupOrDie("").GroupVersion.Version, APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.Version,
}, },
ObjectMeta: api.ObjectMeta{ ObjectMeta: api.ObjectMeta{
Name: podName, Name: podName,

4
test/e2e/kubeproxy.go
View File

@ -255,7 +255,7 @@ func (config *KubeProxyTestConfig) createNetShellPodSpec(podName string, node st
pod := &api.Pod{ pod := &api.Pod{
TypeMeta: unversioned.TypeMeta{ TypeMeta: unversioned.TypeMeta{
Kind: "Pod", Kind: "Pod",
APIVersion: latest.GroupOrDie("").GroupVersion.Version, APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.Version,
}, },
ObjectMeta: api.ObjectMeta{ ObjectMeta: api.ObjectMeta{
Name: podName, Name: podName,
@ -295,7 +295,7 @@ func (config *KubeProxyTestConfig) createTestPodSpec() *api.Pod {
pod := &api.Pod{ pod := &api.Pod{
TypeMeta: unversioned.TypeMeta{ TypeMeta: unversioned.TypeMeta{
Kind: "Pod", Kind: "Pod",
APIVersion: latest.GroupOrDie("").GroupVersion.Version, APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.Version,
}, },
ObjectMeta: api.ObjectMeta{ ObjectMeta: api.ObjectMeta{
Name: testPodName, Name: testPodName,

2
test/e2e/pd.go
View File

@ -414,7 +414,7 @@ func testPDPod(diskNames []string, targetHost string, readOnly bool, numContaine
pod := &api.Pod{ pod := &api.Pod{
TypeMeta: unversioned.TypeMeta{ TypeMeta: unversioned.TypeMeta{
Kind: "Pod", Kind: "Pod",
APIVersion: latest.GroupOrDie("").GroupVersion.Version, APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.Version,
}, },
ObjectMeta: api.ObjectMeta{ ObjectMeta: api.ObjectMeta{
Name: "pd-test-" + string(util.NewUUID()), Name: "pd-test-" + string(util.NewUUID()),

2
test/e2e/privileged.go
View File

@ -102,7 +102,7 @@ func (config *PrivilegedPodTestConfig) createPrivilegedPodSpec() *api.Pod {
pod := &api.Pod{ pod := &api.Pod{
TypeMeta: unversioned.TypeMeta{ TypeMeta: unversioned.TypeMeta{
Kind: "Pod", Kind: "Pod",
APIVersion: latest.GroupOrDie("").GroupVersion.Version, APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.Version,
}, },
ObjectMeta: api.ObjectMeta{ ObjectMeta: api.ObjectMeta{
Name: privilegedPodName, Name: privilegedPodName,

2
test/e2e/resize_nodes.go
View File

@ -188,7 +188,7 @@ func rcByNameContainer(name string, replicas int, image string, labels map[strin
return &api.ReplicationController{ return &api.ReplicationController{
TypeMeta: unversioned.TypeMeta{ TypeMeta: unversioned.TypeMeta{
Kind: "ReplicationController", Kind: "ReplicationController",
APIVersion: latest.GroupOrDie("").GroupVersion.Version, APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.Version,
}, },
ObjectMeta: api.ObjectMeta{ ObjectMeta: api.ObjectMeta{
Name: name, Name: name,

2
test/e2e/util.go
View File

@ -2099,7 +2099,7 @@ func NewHostExecPodSpec(ns, name string) *api.Pod {
pod := &api.Pod{ pod := &api.Pod{
TypeMeta: unversioned.TypeMeta{ TypeMeta: unversioned.TypeMeta{
Kind: "Pod", Kind: "Pod",
APIVersion: latest.GroupOrDie("").GroupVersion.Version, APIVersion: latest.GroupOrDie(api.GroupName).GroupVersion.Version,
}, },
ObjectMeta: api.ObjectMeta{ ObjectMeta: api.ObjectMeta{
Name: name, Name: name,

5
test/integration/auth_test.go
View File

@ -38,6 +38,7 @@ import (
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/testapi" "k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/apiserver" "k8s.io/kubernetes/pkg/apiserver"
"k8s.io/kubernetes/pkg/auth/authenticator" "k8s.io/kubernetes/pkg/auth/authenticator"
"k8s.io/kubernetes/pkg/auth/authenticator/bearertoken" "k8s.io/kubernetes/pkg/auth/authenticator/bearertoken"
@ -755,8 +756,8 @@ func TestAuthorizationAttributeDetermination(t *testing.T) {
URL string URL string
expectedAttributes authorizer.Attributes expectedAttributes authorizer.Attributes
}{ }{
"prefix/version/resource": {"GET", "/api/v1/pods", authorizer.AttributesRecord{APIGroup: "", Resource: "pods"}}, "prefix/version/resource": {"GET", "/api/v1/pods", authorizer.AttributesRecord{APIGroup: api.GroupName, Resource: "pods"}},
"prefix/group/version/resource": {"GET", "/apis/extensions/v1/pods", authorizer.AttributesRecord{APIGroup: "extensions", Resource: "pods"}}, "prefix/group/version/resource": {"GET", "/apis/extensions/v1/pods", authorizer.AttributesRecord{APIGroup: extensions.GroupName, Resource: "pods"}},
} }
currentAuthorizationAttributesIndex := 0 currentAuthorizationAttributesIndex := 0

9
test/integration/framework/master_utils.go
View File

@ -29,6 +29,7 @@ import (
"github.com/golang/glog" "github.com/golang/glog"
"k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/api/testapi" "k8s.io/kubernetes/pkg/api/testapi"
"k8s.io/kubernetes/pkg/apis/extensions"
"k8s.io/kubernetes/pkg/apiserver" "k8s.io/kubernetes/pkg/apiserver"
"k8s.io/kubernetes/pkg/client/record" "k8s.io/kubernetes/pkg/client/record"
client "k8s.io/kubernetes/pkg/client/unversioned" client "k8s.io/kubernetes/pkg/client/unversioned"
@ -138,12 +139,12 @@ func NewMasterConfig() *master.Config {
etcdClient := NewEtcdClient() etcdClient := NewEtcdClient()
storageVersions := make(map[string]string) storageVersions := make(map[string]string)
etcdStorage := etcdstorage.NewEtcdStorage(etcdClient, testapi.Default.Codec(), etcdtest.PathPrefix()) etcdStorage := etcdstorage.NewEtcdStorage(etcdClient, testapi.Default.Codec(), etcdtest.PathPrefix())
storageVersions[""] = testapi.Default.GroupVersion().String() storageVersions[api.GroupName] = testapi.Default.GroupVersion().String()
expEtcdStorage := NewExtensionsEtcdStorage(etcdClient) expEtcdStorage := NewExtensionsEtcdStorage(etcdClient)
storageVersions["extensions"] = testapi.Extensions.GroupVersion().String() storageVersions[extensions.GroupName] = testapi.Extensions.GroupVersion().String()
storageDestinations := master.NewStorageDestinations() storageDestinations := master.NewStorageDestinations()
storageDestinations.AddAPIGroup("", etcdStorage) storageDestinations.AddAPIGroup(api.GroupName, etcdStorage)
storageDestinations.AddAPIGroup("extensions", expEtcdStorage) storageDestinations.AddAPIGroup(extensions.GroupName, expEtcdStorage)
return &master.Config{ return &master.Config{
StorageDestinations: storageDestinations, StorageDestinations: storageDestinations,