github/kubernetes
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

"experimental" -> "extensions"

Browse Source
This commit is contained in:
Chao Xu
2015-10-09 15:14:03 -07:00
parent 138eeaef8c
commit 80f213c376
27 changed files with 75 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Godeps/_workspace/src/github.com/rackspace/gophercloud/openstack/client_test.go generated vendored
View File

@@ -67,7 +67,7 @@ func TestAuthenticatedClientV2(t *testing.T) {
"versions": { "versions": {
"values": [ "values": [
{ {
"status": "experimental", "status": "extensions",
"id": "v3.0", "id": "v3.0",
"links": [ "links": [
{ "href": "%s", "rel": "self" } { "href": "%s", "rel": "self" }

6
cmd/integration/integration.go
View File

@@ -143,14 +143,14 @@ func startComponents(firstManifestURL, secondManifestURL string) (string, string
if err != nil { if err != nil {
glog.Fatalf("Unable to get etcd storage: %v", err) glog.Fatalf("Unable to get etcd storage: %v", err)
} }
expEtcdStorage, err := master.NewEtcdStorage(etcdClient, latest.GroupOrDie("experimental").InterfacesFor, testapi.Experimental.GroupAndVersion(), etcdtest.PathPrefix()) expEtcdStorage, err := master.NewEtcdStorage(etcdClient, latest.GroupOrDie("extensions").InterfacesFor, testapi.Experimental.GroupAndVersion(), etcdtest.PathPrefix())
storageVersions["experimental"] = testapi.Experimental.GroupAndVersion() storageVersions["extensions"] = testapi.Experimental.GroupAndVersion()
if err != nil { if err != nil {
glog.Fatalf("Unable to get etcd storage for experimental: %v", err) glog.Fatalf("Unable to get etcd storage for experimental: %v", err)
} }
storageDestinations := master.NewStorageDestinations() storageDestinations := master.NewStorageDestinations()
storageDestinations.AddAPIGroup("", etcdStorage) storageDestinations.AddAPIGroup("", etcdStorage)
storageDestinations.AddAPIGroup("experimental", expEtcdStorage) storageDestinations.AddAPIGroup("extensions", expEtcdStorage)
// Master // Master
host, port, err := net.SplitHostPort(strings.TrimLeft(apiServer.URL, "http://")) host, port, err := net.SplitHostPort(strings.TrimLeft(apiServer.URL, "http://"))

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

@@ -432,7 +432,7 @@ func (s *APIServer) Run(_ []string) error {
storageDestinations.AddAPIGroup("", etcdStorage) storageDestinations.AddAPIGroup("", etcdStorage)
if enableExp { if enableExp {
expGroup, err := latest.Group("experimental") expGroup, err := latest.Group("extensions")
if err != nil { if err != nil {
glog.Fatalf("experimental API is enabled in runtime config, but not enabled in the environment variable KUBE_API_VERSIONS. Error: %v", err) glog.Fatalf("experimental API is enabled in runtime config, but not enabled in the environment variable KUBE_API_VERSIONS. Error: %v", err)
} }
@@ -443,7 +443,7 @@ func (s *APIServer) Run(_ []string) error {
if err != nil { if err != nil {
glog.Fatalf("Invalid experimental storage version or misconfigured etcd: %v", err) glog.Fatalf("Invalid experimental storage version or misconfigured etcd: %v", err)
} }
storageDestinations.AddAPIGroup("experimental", expEtcdStorage) storageDestinations.AddAPIGroup("extensions", expEtcdStorage)
} }
updateEtcdOverrides(s.EtcdServersOverrides, storageVersions, s.EtcdPathPrefix, &storageDestinations, newEtcd) updateEtcdOverrides(s.EtcdServersOverrides, storageVersions, s.EtcdPathPrefix, &storageDestinations, newEtcd)

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

@@ -79,7 +79,7 @@ func TestGenerateStorageVersionMap(t *testing.T) {
storageVersions: "v1,extensions/v1beta1", storageVersions: "v1,extensions/v1beta1",
expectedMap: map[string]string{ expectedMap: map[string]string{
"": "v1", "": "v1",
"experimental": "extensions/v1beta1", "extensions": "extensions/v1beta1",
}, },
}, },
{ {
@@ -87,7 +87,7 @@ func TestGenerateStorageVersionMap(t *testing.T) {
storageVersions: "extensions/v1beta1,v1", storageVersions: "extensions/v1beta1,v1",
expectedMap: map[string]string{ expectedMap: map[string]string{
"": "v1", "": "v1",
"experimental": "extensions/v1beta1", "extensions": "extensions/v1beta1",
}, },
}, },
{ {
@@ -123,7 +123,7 @@ func TestUpdateEtcdOverrides(t *testing.T) {
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: "experimental", apigroup: "extensions",
resource: "resource", resource: "resource",
servers: []string{"http://127.0.0.1:10000"}, servers: []string{"http://127.0.0.1:10000"},
}, },

2
pkg/api/mapper.go
View File

@@ -42,7 +42,7 @@ func NewDefaultRESTMapper(group string, versions []string, interfacesFunc meta.V
for _, version := range versions { for _, version := range versions {
for kind, oType := range Scheme.KnownTypes(version) { for kind, oType := range Scheme.KnownTypes(version) {
// TODO: Remove import path prefix check. // TODO: Remove import path prefix check.
// We check the import path prefix because we currently stuff both "api" and "experimental" objects // We check the import path prefix because we currently stuff both "api" and "extensions" objects
// into the same group within Scheme since Scheme has no notion of groups yet. // into the same group within Scheme since Scheme has no notion of groups yet.
if !strings.HasPrefix(oType.PkgPath(), importPathPrefix) || ignoredKinds.Has(kind) { if !strings.HasPrefix(oType.PkgPath(), importPathPrefix) || ignoredKinds.Has(kind) {
continue continue

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

@@ -66,12 +66,12 @@ func init() {
// have multiple group support // have multiple group support
Groups[""] = TestGroup{"", latest.GroupOrDie("").Version, latest.GroupOrDie("").GroupVersion} Groups[""] = TestGroup{"", latest.GroupOrDie("").Version, latest.GroupOrDie("").GroupVersion}
} }
if _, ok := Groups["experimental"]; !ok { if _, ok := Groups["extensions"]; !ok {
Groups["experimental"] = TestGroup{"experimental", latest.GroupOrDie("experimental").Version, latest.GroupOrDie("experimental").GroupVersion} Groups["extensions"] = TestGroup{"extensions", latest.GroupOrDie("extensions").Version, latest.GroupOrDie("extensions").GroupVersion}
} }
Default = Groups[""] Default = Groups[""]
Experimental = Groups["experimental"] Experimental = Groups["extensions"]
} }
// Version returns the API version to test against, as set by the KUBE_TEST_API env var. // Version returns the API version to test against, as set by the KUBE_TEST_API env var.
@@ -97,8 +97,8 @@ func (g TestGroup) Codec() runtime.Codec {
} }
return interfaces.Codec return interfaces.Codec
} }
if g.Group == "experimental" { if g.Group == "extensions" {
interfaces, err := latest.GroupOrDie("experimental").InterfacesFor(g.GroupVersionUnderTest) interfaces, err := latest.GroupOrDie("extensions").InterfacesFor(g.GroupVersionUnderTest)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@@ -118,8 +118,8 @@ func (g TestGroup) Converter() runtime.ObjectConvertor {
} }
return interfaces.ObjectConvertor return interfaces.ObjectConvertor
} }
if g.Group == "experimental" { if g.Group == "extensions" {
interfaces, err := latest.GroupOrDie("experimental").InterfacesFor(g.VersionUnderTest) interfaces, err := latest.GroupOrDie("extensions").InterfacesFor(g.VersionUnderTest)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@@ -140,8 +140,8 @@ func (g TestGroup) MetadataAccessor() meta.MetadataAccessor {
} }
return interfaces.MetadataAccessor return interfaces.MetadataAccessor
} }
if g.Group == "experimental" { if g.Group == "extensions" {
interfaces, err := latest.GroupOrDie("experimental").InterfacesFor(g.VersionUnderTest) interfaces, err := latest.GroupOrDie("extensions").InterfacesFor(g.VersionUnderTest)
if err != nil { if err != nil {
panic(err) panic(err)
} }

2
pkg/api/util/group_version_test.go
View File

@@ -51,7 +51,7 @@ func TestGetGroup(t *testing.T) {
}, },
{ {
"extensions/v1beta1", "extensions/v1beta1",
"experimental", "extensions",
}, },
} }
for _, test := range testCases { for _, test := range testCases {

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

@@ -40,12 +40,12 @@ const importPrefix = "k8s.io/kubernetes/pkg/apis/extensions"
var accessor = meta.NewAccessor() var accessor = meta.NewAccessor()
func init() { func init() {
groupMeta, err := latest.RegisterGroup("experimental") groupMeta, err := latest.RegisterGroup("extensions")
if err != nil { if err != nil {
glog.V(4).Infof("%v", err) glog.V(4).Infof("%v", err)
return return
} }
registeredGroupVersions := registered.GroupVersionsForGroup("experimental") registeredGroupVersions := registered.GroupVersionsForGroup("extensions")
groupVersion := registeredGroupVersions[0] groupVersion := registeredGroupVersions[0]
*groupMeta = latest.GroupMeta{ *groupMeta = latest.GroupMeta{
GroupVersion: groupVersion, GroupVersion: groupVersion,
@@ -70,7 +70,7 @@ func init() {
ignoredKinds := sets.NewString() ignoredKinds := sets.NewString()
groupMeta.RESTMapper = api.NewDefaultRESTMapper("experimental", groupVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped) groupMeta.RESTMapper = api.NewDefaultRESTMapper("extensions", groupVersions, interfacesFor, importPrefix, ignoredKinds, rootScoped)
api.RegisterRESTMapper(groupMeta.RESTMapper) api.RegisterRESTMapper(groupMeta.RESTMapper)
groupMeta.InterfacesFor = interfacesFor groupMeta.InterfacesFor = interfacesFor
} }
@@ -86,7 +86,7 @@ func interfacesFor(version string) (*meta.VersionInterfaces, error) {
MetadataAccessor: accessor, MetadataAccessor: accessor,
}, nil }, nil
default: default:
g, _ := latest.Group("experimental") g, _ := latest.Group("extensions")
return nil, fmt.Errorf("unsupported storage version: %s (valid: %s)", version, strings.Join(g.Versions, ", ")) return nil, fmt.Errorf("unsupported storage version: %s (valid: %s)", version, strings.Join(g.Versions, ", "))
} }
} }

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

@@ -50,7 +50,7 @@ func TestCodec(t *testing.T) {
daemonSet := experimental.DaemonSet{} daemonSet := experimental.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("experimental").Codec.Encode(&daemonSet) data, err := latest.GroupOrDie("extensions").Codec.Encode(&daemonSet)
if err != nil { if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
@@ -58,33 +58,33 @@ 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("experimental").GroupVersion || other.Kind != "DaemonSet" { if other.APIVersion != latest.GroupOrDie("extensions").GroupVersion || 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("experimental").InterfacesFor(""); err == nil { if _, err := latest.GroupOrDie("extensions").InterfacesFor(""); err == nil {
t.Fatalf("unexpected non-error: %v", err) t.Fatalf("unexpected non-error: %v", err)
} }
for i, groupVersion := range append([]string{latest.GroupOrDie("experimental").GroupVersion}, latest.GroupOrDie("experimental").GroupVersions...) { for i, groupVersion := range append([]string{latest.GroupOrDie("extensions").GroupVersion}, latest.GroupOrDie("extensions").GroupVersions...) {
if vi, err := latest.GroupOrDie("experimental").InterfacesFor(groupVersion); err != nil || vi == nil { if vi, err := latest.GroupOrDie("extensions").InterfacesFor(groupVersion); 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) {
if v, k, err := latest.GroupOrDie("experimental").RESTMapper.VersionAndKindForResource("horizontalpodautoscalers"); err != nil || v != "extensions/v1beta1" || k != "HorizontalPodAutoscaler" { if v, k, err := latest.GroupOrDie("extensions").RESTMapper.VersionAndKindForResource("horizontalpodautoscalers"); err != nil || v != "extensions/v1beta1" || k != "HorizontalPodAutoscaler" {
t.Errorf("unexpected version mapping: %s %s %v", v, k, err) t.Errorf("unexpected version mapping: %s %s %v", v, k, err)
} }
if m, err := latest.GroupOrDie("experimental").RESTMapper.RESTMapping("DaemonSet", ""); err != nil || m.APIVersion != "extensions/v1beta1" || m.Resource != "daemonsets" { if m, err := latest.GroupOrDie("extensions").RESTMapper.RESTMapping("DaemonSet", ""); err != nil || m.APIVersion != "extensions/v1beta1" || m.Resource != "daemonsets" {
t.Errorf("unexpected version mapping: %#v %v", m, err) t.Errorf("unexpected version mapping: %#v %v", m, err)
} }
for _, groupVersion := range latest.GroupOrDie("experimental").GroupVersions { for _, groupVersion := range latest.GroupOrDie("extensions").GroupVersions {
mapping, err := latest.GroupOrDie("experimental").RESTMapper.RESTMapping("HorizontalPodAutoscaler", groupVersion) mapping, err := latest.GroupOrDie("extensions").RESTMapper.RESTMapping("HorizontalPodAutoscaler", groupVersion)
if err != nil { if err != nil {
t.Errorf("unexpected error: %v", err) t.Errorf("unexpected error: %v", err)
} }
@@ -96,7 +96,7 @@ func TestRESTMapper(t *testing.T) {
t.Errorf("incorrect groupVersion: %v", mapping) t.Errorf("incorrect groupVersion: %v", mapping)
} }
interfaces, _ := latest.GroupOrDie("experimental").InterfacesFor(groupVersion) interfaces, _ := latest.GroupOrDie("extensions").InterfacesFor(groupVersion)
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)
} }

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 = "experimental" obj.APIGroup = "extensions"
} }
}, },
func(obj *DaemonSet) { func(obj *DaemonSet) {

4
pkg/apiserver/handlers_test.go
View File

@@ -242,10 +242,10 @@ func TestGetAPIRequestInfo(t *testing.T) {
{"POST", "/api/v1/namespaces/other/pods", "create", "api", "", "v1", "other", "pods", "", "", []string{"pods"}}, {"POST", "/api/v1/namespaces/other/pods", "create", "api", "", "v1", "other", "pods", "", "", []string{"pods"}},
// api group identification // api group identification
{"POST", "/apis/extensions/v1/namespaces/other/pods", "create", "api", "experimental", "v1", "other", "pods", "", "", []string{"pods"}}, {"POST", "/apis/extensions/v1/namespaces/other/pods", "create", "api", "extensions", "v1", "other", "pods", "", "", []string{"pods"}},
// api version identification // api version identification
{"POST", "/apis/extensions/v1beta3/namespaces/other/pods", "create", "api", "experimental", "v1beta3", "other", "pods", "", "", []string{"pods"}}, {"POST", "/apis/extensions/v1beta3/namespaces/other/pods", "create", "api", "extensions", "v1beta3", "other", "pods", "", "", []string{"pods"}},
} }
apiRequestInfoResolver := newTestAPIRequestInfoResolver() apiRequestInfoResolver := newTestAPIRequestInfoResolver()

4
pkg/client/unversioned/experimental.go
View File

@@ -130,7 +130,7 @@ func NewExperimentalOrDie(c *Config) *ExperimentalClient {
func setExperimentalDefaults(config *Config) error { func setExperimentalDefaults(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("experimental") g, err := latest.Group("extensions")
if err != nil { if err != nil {
return err return err
} }
@@ -146,7 +146,7 @@ func setExperimentalDefaults(config *Config) error {
versionInterfaces, err := g.InterfacesFor(config.Version) versionInterfaces, err := g.InterfacesFor(config.Version)
if err != nil { if err != nil {
return fmt.Errorf("Experimental API version '%s' is not recognized (valid values: %s)", return fmt.Errorf("Experimental API version '%s' is not recognized (valid values: %s)",
config.Version, strings.Join(latest.GroupOrDie("experimental").Versions, ", ")) config.Version, strings.Join(latest.GroupOrDie("extensions").Versions, ", "))
} }
config.Codec = versionInterfaces.Codec config.Codec = versionInterfaces.Codec
if config.QPS == 0 { if config.QPS == 0 {

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

@@ -144,7 +144,7 @@ func New(c *Config) (*Client, error) {
return nil, err return nil, err
} }
if _, err := latest.Group("experimental"); err != nil { if _, err := latest.Group("extensions"); err != nil {
return &Client{RESTClient: client, ExperimentalClient: nil}, nil return &Client{RESTClient: client, ExperimentalClient: nil}, nil
} }
experimentalConfig := *c experimentalConfig := *c

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

@@ -142,7 +142,7 @@ func NewFactory(optionalClientConfig clientcmd.ClientConfig) *Factory {
switch group { switch group {
case "": case "":
return client.RESTClient, nil return client.RESTClient, nil
case "experimental": case "extensions":
return client.ExperimentalClient.RESTClient, nil return client.ExperimentalClient.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)
@@ -406,7 +406,7 @@ func (c *clientSwaggerSchema) ValidateBytes(data []byte) error {
if err != nil { if err != nil {
return fmt.Errorf("could not find api group for %s: %v", kind, err) return fmt.Errorf("could not find api group for %s: %v", kind, err)
} }
if group == "experimental" { if group == "extensions" {
if c.c.ExperimentalClient == nil { if c.c.ExperimentalClient == nil {
return errors.New("unable to validate: no experimental client") return errors.New("unable to validate: no experimental client")
} }

2
pkg/kubectl/describe.go
View File

@@ -113,7 +113,7 @@ func DescriberFor(group string, kind string, c *client.Client) (Describer, bool)
switch group { switch group {
case "": case "":
f, ok = describerMap(c)[kind] f, ok = describerMap(c)[kind]
case "experimental": case "extensions":
f, ok = expDescriberMap(c)[kind] f, ok = expDescriberMap(c)[kind]
} }

16
pkg/master/master.go
View File

@@ -653,7 +653,7 @@ func (m *Master) init(c *Config) {
// allGroups records all supported groups at /apis // allGroups records all supported groups at /apis
allGroups := []api.APIGroup{} allGroups := []api.APIGroup{}
if m.exp { if m.exp {
m.thirdPartyStorage = c.StorageDestinations.APIGroups["experimental"].Default m.thirdPartyStorage = c.StorageDestinations.APIGroups["extensions"].Default
m.thirdPartyResources = map[string]*thirdpartyresourcedataetcd.REST{} m.thirdPartyResources = map[string]*thirdpartyresourcedataetcd.REST{}
expVersion := m.experimental(c) expVersion := m.experimental(c)
@@ -661,7 +661,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("experimental") g, err := latest.Group("extensions")
if err != nil { if err != nil {
glog.Fatalf("Unable to setup experimental api: %v", err) glog.Fatalf("Unable to setup experimental api: %v", err)
} }
@@ -680,7 +680,7 @@ func (m *Master) init(c *Config) {
Versions: expAPIVersions, Versions: expAPIVersions,
PreferredVersion: api.GroupVersion{GroupVersion: storageVersion, Version: apiutil.GetVersion(storageVersion)}, PreferredVersion: api.GroupVersion{GroupVersion: storageVersion, Version: apiutil.GetVersion(storageVersion)},
} }
apiserver.AddGroupWebService(m.handlerContainer, c.APIGroupPrefix+"/"+latest.GroupOrDie("experimental").Group+"/", group) apiserver.AddGroupWebService(m.handlerContainer, c.APIGroupPrefix+"/"+latest.GroupOrDie("extensions").Group+"/", group)
allGroups = append(allGroups, group) allGroups = append(allGroups, group)
apiserver.InstallServiceErrorHandler(m.handlerContainer, m.newAPIRequestInfoResolver(), []string{expVersion.Version}) apiserver.InstallServiceErrorHandler(m.handlerContainer, m.newAPIRequestInfoResolver(), []string{expVersion.Version})
} }
@@ -1023,9 +1023,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("experimental").RESTMapper, kind, version, group), Mapper: thirdpartyresourcedata.NewMapper(latest.GroupOrDie("extensions").RESTMapper, kind, version, group),
Codec: thirdpartyresourcedata.NewCodec(latest.GroupOrDie("experimental").Codec, kind), Codec: thirdpartyresourcedata.NewCodec(latest.GroupOrDie("extensions").Codec, kind),
Linker: latest.GroupOrDie("experimental").SelfLinker, Linker: latest.GroupOrDie("extensions").SelfLinker,
Storage: storage, Storage: storage,
ServerVersion: latest.GroupOrDie("").GroupVersion, ServerVersion: latest.GroupOrDie("").GroupVersion,
@@ -1040,7 +1040,7 @@ func (m *Master) thirdpartyapi(group, kind, version string) *apiserver.APIGroupV
func (m *Master) experimental(c *Config) *apiserver.APIGroupVersion { func (m *Master) experimental(c *Config) *apiserver.APIGroupVersion {
controllerStorage := expcontrolleretcd.NewStorage(c.StorageDestinations.get("", "replicationControllers")) controllerStorage := expcontrolleretcd.NewStorage(c.StorageDestinations.get("", "replicationControllers"))
dbClient := func(resource string) storage.Interface { dbClient := func(resource string) storage.Interface {
return c.StorageDestinations.get("experimental", resource) return c.StorageDestinations.get("extensions", resource)
} }
autoscalerStorage := horizontalpodautoscaleretcd.NewREST(dbClient("horizonalpodautoscalers")) autoscalerStorage := horizontalpodautoscaleretcd.NewREST(dbClient("horizonalpodautoscalers"))
thirdPartyResourceStorage := thirdpartyresourceetcd.NewREST(dbClient("thirdpartyresources")) thirdPartyResourceStorage := thirdpartyresourceetcd.NewREST(dbClient("thirdpartyresources"))
@@ -1074,7 +1074,7 @@ func (m *Master) experimental(c *Config) *apiserver.APIGroupVersion {
strings.ToLower("ingress"): ingressStorage, strings.ToLower("ingress"): ingressStorage,
} }
expMeta := latest.GroupOrDie("experimental") expMeta := latest.GroupOrDie("extensions")
return &apiserver.APIGroupVersion{ return &apiserver.APIGroupVersion{
Root: m.apiGroupPrefix, Root: m.apiGroupPrefix,

18
pkg/master/master_test.go
View File

@@ -67,10 +67,10 @@ func setUp(t *testing.T) (Master, Config, *assert.Assertions) {
storageVersions := make(map[string]string) storageVersions := make(map[string]string)
storageDestinations := NewStorageDestinations() storageDestinations := NewStorageDestinations()
storageDestinations.AddAPIGroup("", etcdstorage.NewEtcdStorage(fakeClient, testapi.Default.Codec(), etcdtest.PathPrefix())) storageDestinations.AddAPIGroup("", etcdstorage.NewEtcdStorage(fakeClient, testapi.Default.Codec(), etcdtest.PathPrefix()))
storageDestinations.AddAPIGroup("experimental", etcdstorage.NewEtcdStorage(fakeClient, testapi.Experimental.Codec(), etcdtest.PathPrefix())) storageDestinations.AddAPIGroup("extensions", etcdstorage.NewEtcdStorage(fakeClient, testapi.Experimental.Codec(), etcdtest.PathPrefix()))
config.StorageDestinations = storageDestinations config.StorageDestinations = storageDestinations
storageVersions[""] = testapi.Default.Version() storageVersions[""] = testapi.Default.Version()
storageVersions["experimental"] = testapi.Experimental.GroupAndVersion() storageVersions["extensions"] = testapi.Experimental.GroupAndVersion()
config.StorageVersions = storageVersions config.StorageVersions = storageVersions
master.nodeRegistry = registrytest.NewNodeRegistry([]string{"node1", "node2"}, api.NodeResources{}) master.nodeRegistry = registrytest.NewNodeRegistry([]string{"node1", "node2"}, api.NodeResources{})
@@ -293,10 +293,10 @@ func TestExpapi(t *testing.T) {
expAPIGroup := master.experimental(&config) expAPIGroup := master.experimental(&config)
assert.Equal(expAPIGroup.Root, master.apiGroupPrefix) assert.Equal(expAPIGroup.Root, master.apiGroupPrefix)
assert.Equal(expAPIGroup.Mapper, latest.GroupOrDie("experimental").RESTMapper) assert.Equal(expAPIGroup.Mapper, latest.GroupOrDie("extensions").RESTMapper)
assert.Equal(expAPIGroup.Codec, latest.GroupOrDie("experimental").Codec) assert.Equal(expAPIGroup.Codec, latest.GroupOrDie("extensions").Codec)
assert.Equal(expAPIGroup.Linker, latest.GroupOrDie("experimental").SelfLinker) assert.Equal(expAPIGroup.Linker, latest.GroupOrDie("extensions").SelfLinker)
assert.Equal(expAPIGroup.Version, latest.GroupOrDie("experimental").GroupVersion) assert.Equal(expAPIGroup.Version, latest.GroupOrDie("extensions").GroupVersion)
} }
// TestSecondsSinceSync verifies that proper results are returned // TestSecondsSinceSync verifies that proper results are returned
@@ -471,7 +471,7 @@ func TestDiscoveryAtAPIS(t *testing.T) {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
expectGroupName := "experimental" expectGroupName := "extensions"
expectVersions := []api.GroupVersion{ expectVersions := []api.GroupVersion{
{ {
GroupVersion: testapi.Experimental.GroupAndVersion(), GroupVersion: testapi.Experimental.GroupAndVersion(),
@@ -479,8 +479,8 @@ func TestDiscoveryAtAPIS(t *testing.T) {
}, },
} }
expectPreferredVersion := api.GroupVersion{ expectPreferredVersion := api.GroupVersion{
GroupVersion: config.StorageVersions["experimental"], GroupVersion: config.StorageVersions["extensions"],
Version: apiutil.GetVersion(config.StorageVersions["experimental"]), Version: apiutil.GetVersion(config.StorageVersions["extensions"]),
} }
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

@@ -29,7 +29,7 @@ import (
) )
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) { func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "experimental") etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
storage, statusStorage := NewREST(etcdStorage) storage, statusStorage := NewREST(etcdStorage)
return storage, statusStorage, fakeClient return storage, statusStorage, fakeClient
} }

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

@@ -32,7 +32,7 @@ import (
) )
func newStorage(t *testing.T) (*DeploymentStorage, *tools.FakeEtcdClient) { func newStorage(t *testing.T) (*DeploymentStorage, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "experimental") etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
deploymentStorage := NewStorage(etcdStorage) deploymentStorage := NewStorage(etcdStorage)
return &deploymentStorage, fakeClient return &deploymentStorage, fakeClient
} }

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

@@ -32,7 +32,7 @@ import (
) )
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "experimental") etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
return NewREST(etcdStorage), fakeClient return NewREST(etcdStorage), fakeClient
} }

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

@@ -30,7 +30,7 @@ import (
) )
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "experimental") etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
ingressStorage := NewREST(etcdStorage) ingressStorage := NewREST(etcdStorage)
return ingressStorage, fakeClient return ingressStorage, fakeClient
} }

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

@@ -31,7 +31,7 @@ import (
) )
func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) { func newStorage(t *testing.T) (*REST, *StatusREST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "experimental") etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
storage, statusStorage := NewREST(etcdStorage) storage, statusStorage := NewREST(etcdStorage)
return storage, statusStorage, fakeClient return storage, statusStorage, fakeClient
} }

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

@@ -31,7 +31,7 @@ import (
) )
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "experimental") etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
return NewREST(etcdStorage), fakeClient return NewREST(etcdStorage), fakeClient
} }

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

@@ -59,7 +59,7 @@ func (t *thirdPartyResourceDataMapper) RESTMapping(kind string, groupVersions ..
if kind != "ThirdPartyResourceData" { if kind != "ThirdPartyResourceData" {
return nil, fmt.Errorf("unknown kind %s expected %s", kind, t.kind) return nil, fmt.Errorf("unknown kind %s expected %s", kind, t.kind)
} }
mapping, err := t.mapper.RESTMapping("ThirdPartyResourceData", latest.GroupOrDie("experimental").GroupVersion) mapping, err := t.mapper.RESTMapping("ThirdPartyResourceData", latest.GroupOrDie("extensions").GroupVersion)
if err != nil { if err != nil {
return nil, err return nil, err
} }

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

@@ -31,7 +31,7 @@ import (
) )
func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) { func newStorage(t *testing.T) (*REST, *tools.FakeEtcdClient) {
etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "experimental") etcdStorage, fakeClient := registrytest.NewEtcdStorage(t, "extensions")
return NewREST(etcdStorage, "foo", "bar"), fakeClient return NewREST(etcdStorage, "foo", "bar"), fakeClient
} }

2
test/integration/auth_test.go
View File

@@ -852,7 +852,7 @@ func TestAuthorizationAttributeDetermination(t *testing.T) {
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: "", Resource: "pods"}},
"prefix/group/version/resource": {"GET", "/apis/extensions/v1/pods", authorizer.AttributesRecord{APIGroup: "experimental", Resource: "pods"}}, "prefix/group/version/resource": {"GET", "/apis/extensions/v1/pods", authorizer.AttributesRecord{APIGroup: "extensions", Resource: "pods"}},
} }
currentAuthorizationAttributesIndex := 0 currentAuthorizationAttributesIndex := 0

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

@@ -131,14 +131,14 @@ func startMasterOrDie(masterConfig *master.Config) (*master.Master, *httptest.Se
if err != nil { if err != nil {
glog.Fatalf("Failed to create etcd storage for master %v", err) glog.Fatalf("Failed to create etcd storage for master %v", err)
} }
expEtcdStorage, err := master.NewEtcdStorage(etcdClient, latest.GroupOrDie("experimental").InterfacesFor, latest.GroupOrDie("experimental").GroupVersion, etcdtest.PathPrefix()) expEtcdStorage, err := master.NewEtcdStorage(etcdClient, latest.GroupOrDie("extensions").InterfacesFor, latest.GroupOrDie("extensions").GroupVersion, etcdtest.PathPrefix())
storageVersions["experimental"] = latest.GroupOrDie("experimental").GroupVersion storageVersions["extensions"] = latest.GroupOrDie("extensions").GroupVersion
if err != nil { if err != nil {
glog.Fatalf("Failed to create etcd storage for master %v", err) glog.Fatalf("Failed to create etcd storage for master %v", err)
} }
storageDestinations := master.NewStorageDestinations() storageDestinations := master.NewStorageDestinations()
storageDestinations.AddAPIGroup("", etcdStorage) storageDestinations.AddAPIGroup("", etcdStorage)
storageDestinations.AddAPIGroup("experimental", expEtcdStorage) storageDestinations.AddAPIGroup("extensions", expEtcdStorage)
masterConfig = &master.Config{ masterConfig = &master.Config{
StorageDestinations: storageDestinations, StorageDestinations: storageDestinations,
@@ -275,14 +275,14 @@ func RunAMaster(t *testing.T) (*master.Master, *httptest.Server) {
if err != nil { if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
expEtcdStorage, err := master.NewEtcdStorage(etcdClient, latest.GroupOrDie("experimental").InterfacesFor, testapi.Experimental.GroupAndVersion(), etcdtest.PathPrefix()) expEtcdStorage, err := master.NewEtcdStorage(etcdClient, latest.GroupOrDie("extensions").InterfacesFor, testapi.Experimental.GroupAndVersion(), etcdtest.PathPrefix())
storageVersions["experimental"] = testapi.Experimental.GroupAndVersion() storageVersions["extensions"] = testapi.Experimental.GroupAndVersion()
if err != nil { if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
storageDestinations := master.NewStorageDestinations() storageDestinations := master.NewStorageDestinations()
storageDestinations.AddAPIGroup("", etcdStorage) storageDestinations.AddAPIGroup("", etcdStorage)
storageDestinations.AddAPIGroup("experimental", expEtcdStorage) storageDestinations.AddAPIGroup("extensions", expEtcdStorage)
m := master.New(&master.Config{ m := master.New(&master.Config{
StorageDestinations: storageDestinations, StorageDestinations: storageDestinations,