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

"experimental" -> "extensions"

pull/6/head
Chao Xu 2015-10-09 15:14:03 -07:00
parent 138eeaef8c
commit 80f213c376
27 changed files with 75 additions and 75 deletions
Show Stats 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": {
"values": [
{
"status": "experimental",
"status": "extensions",
"id": "v3.0",
"links": [
{ "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 {
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://"))

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

@ -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)

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

@ -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"},
},

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 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

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

@ -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)
}

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

@ -51,7 +51,7 @@ func TestGetGroup(t *testing.T) {
},
{
"extensions/v1beta1",
"experimental",
"extensions",
},
}
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()
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, ", "))
}
}

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

@ -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)
}

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

@ -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) {

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"}},
// 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()

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

@ -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 {

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

@ -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

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

@ -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")
}

2
pkg/kubectl/describe.go
View File

@ -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]
}

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 := []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,

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)
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)

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

@ -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
}

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

@ -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
}

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

@ -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
}

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

@ -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
}

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

@ -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
}

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

@ -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
}

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

@ -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
}

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

@ -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
}

2
test/integration/auth_test.go
View File

@ -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

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 {
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,