"experimental" -> "extensions"

Godeps/_workspace/src/github.com/rackspace/gophercloud/openstack/client_test.go

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

cmd/integration/integration.go

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

cmd/kube-apiserver/app/server.go

@@ -432,7 +432,7 @@ func (s *APIServer) Run(_ []string) error {
 	storageDestinations.AddAPIGroup("", etcdStorage)
 
 	if enableExp {
-		expGroup, err := latest.Group("experimental")
+		expGroup, err := latest.Group("extensions")
 		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)
 		}
@@ -443,7 +443,7 @@ func (s *APIServer) Run(_ []string) error {
 		if err != nil {
 			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)

cmd/kube-apiserver/app/server_test.go

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

pkg/api/mapper.go

@@ -42,7 +42,7 @@ func NewDefaultRESTMapper(group string, versions []string, interfacesFunc meta.V
 	for _, version := range versions {
 		for kind, oType := range Scheme.KnownTypes(version) {
 			// 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.
 			if !strings.HasPrefix(oType.PkgPath(), importPathPrefix) || ignoredKinds.Has(kind) {
 				continue

pkg/api/testapi/testapi.go

@@ -66,12 +66,12 @@ func init() {
 		// have multiple group support
 		Groups[""] = TestGroup{"", latest.GroupOrDie("").Version, latest.GroupOrDie("").GroupVersion}
 	}
-	if _, ok := Groups["experimental"]; !ok {
-		Groups["experimental"] = TestGroup{"experimental", latest.GroupOrDie("experimental").Version, latest.GroupOrDie("experimental").GroupVersion}
+	if _, ok := Groups["extensions"]; !ok {
+		Groups["extensions"] = TestGroup{"extensions", latest.GroupOrDie("extensions").Version, latest.GroupOrDie("extensions").GroupVersion}
 	}
 
 	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.
@@ -97,8 +97,8 @@ func (g TestGroup) Codec() runtime.Codec {
 		}
 		return interfaces.Codec
 	}
-	if g.Group == "experimental" {
-		interfaces, err := latest.GroupOrDie("experimental").InterfacesFor(g.GroupVersionUnderTest)
+	if g.Group == "extensions" {
+		interfaces, err := latest.GroupOrDie("extensions").InterfacesFor(g.GroupVersionUnderTest)
 		if err != nil {
 			panic(err)
 		}
@@ -118,8 +118,8 @@ func (g TestGroup) Converter() runtime.ObjectConvertor {
 		}
 		return interfaces.ObjectConvertor
 	}
-	if g.Group == "experimental" {
-		interfaces, err := latest.GroupOrDie("experimental").InterfacesFor(g.VersionUnderTest)
+	if g.Group == "extensions" {
+		interfaces, err := latest.GroupOrDie("extensions").InterfacesFor(g.VersionUnderTest)
 		if err != nil {
 			panic(err)
 		}
@@ -140,8 +140,8 @@ func (g TestGroup) MetadataAccessor() meta.MetadataAccessor {
 		}
 		return interfaces.MetadataAccessor
 	}
-	if g.Group == "experimental" {
-		interfaces, err := latest.GroupOrDie("experimental").InterfacesFor(g.VersionUnderTest)
+	if g.Group == "extensions" {
+		interfaces, err := latest.GroupOrDie("extensions").InterfacesFor(g.VersionUnderTest)
 		if err != nil {
 			panic(err)
 		}

pkg/api/util/group_version_test.go

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

pkg/apis/extensions/install/install.go

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

pkg/apis/extensions/install/install_test.go

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

pkg/apis/extensions/v1beta1/defaults.go

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

pkg/apiserver/handlers_test.go

@@ -242,10 +242,10 @@ func TestGetAPIRequestInfo(t *testing.T) {
 		{"POST", "/api/v1/namespaces/other/pods", "create", "api", "", "v1", "other", "pods", "", "", []string{"pods"}},
 
 		// 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
-		{"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()

pkg/client/unversioned/experimental.go

@@ -130,7 +130,7 @@ func NewExperimentalOrDie(c *Config) *ExperimentalClient {
 
 func setExperimentalDefaults(config *Config) error {
 	// if experimental group is not registered, return an error
-	g, err := latest.Group("experimental")
+	g, err := latest.Group("extensions")
 	if err != nil {
 		return err
 	}
@@ -146,7 +146,7 @@ func setExperimentalDefaults(config *Config) error {
 	versionInterfaces, err := g.InterfacesFor(config.Version)
 	if err != nil {
 		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
 	if config.QPS == 0 {

pkg/client/unversioned/helper.go

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

pkg/kubectl/cmd/util/factory.go

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

pkg/kubectl/describe.go

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

pkg/master/master.go

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

pkg/master/master_test.go

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

pkg/registry/daemonset/etcd/etcd_test.go

@@ -29,7 +29,7 @@ import (
 )
 
 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)
 	return storage, statusStorage, fakeClient
 }

pkg/registry/deployment/etcd/etcd_test.go

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

pkg/registry/horizontalpodautoscaler/etcd/etcd_test.go

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

pkg/registry/ingress/etcd/etcd_test.go

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

pkg/registry/job/etcd/etcd_test.go

@@ -31,7 +31,7 @@ import (
 )
 
 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)
 	return storage, statusStorage, fakeClient
 }

pkg/registry/thirdpartyresource/etcd/etcd_test.go

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

pkg/registry/thirdpartyresourcedata/codec.go

@@ -59,7 +59,7 @@ func (t *thirdPartyResourceDataMapper) RESTMapping(kind string, groupVersions ..
 	if kind != "ThirdPartyResourceData" {
 		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 {
 		return nil, err
 	}

pkg/registry/thirdpartyresourcedata/etcd/etcd_test.go

@@ -31,7 +31,7 @@ import (
 )
 
 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
 }
 

test/integration/auth_test.go

@@ -852,7 +852,7 @@ func TestAuthorizationAttributeDetermination(t *testing.T) {
 		expectedAttributes authorizer.Attributes
 	}{
 		"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

test/integration/framework/master_utils.go

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