Revert "Enable v3 Client as the default on UTs"

pkg/genericapiserver/genericapiserver_test.go

@@ -44,7 +44,7 @@ import (
 
 // setUp is a convience function for setting up for (most) tests.
 func setUp(t *testing.T) (GenericAPIServer, *etcdtesting.EtcdTestServer, Config, *assert.Assertions) {
-	etcdServer, _ := etcdtesting.NewUnsecuredEtcd3TestClientServer(t)
+	etcdServer := etcdtesting.NewEtcdTestClientServer(t)
 
 	genericapiserver := GenericAPIServer{}
 	config := Config{}

pkg/master/master_test.go

@@ -59,6 +59,7 @@ import (
 	"k8s.io/kubernetes/pkg/storage"
 	"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
 	etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
+	"k8s.io/kubernetes/pkg/storage/storagebackend"
 	"k8s.io/kubernetes/pkg/util/intstr"
 	utilnet "k8s.io/kubernetes/pkg/util/net"
 	"k8s.io/kubernetes/pkg/util/sets"
@@ -73,7 +74,7 @@ import (
 
 // setUp is a convience function for setting up for (most) tests.
 func setUp(t *testing.T) (*Master, *etcdtesting.EtcdTestServer, Config, *assert.Assertions) {
-	server, storageConfig := etcdtesting.NewUnsecuredEtcd3TestClientServer(t)
+	server := etcdtesting.NewUnsecuredEtcdTestClientServer(t)
 
 	master := &Master{
 		GenericAPIServer: &genericapiserver.GenericAPIServer{},
@@ -82,6 +83,16 @@ func setUp(t *testing.T) (*Master, *etcdtesting.EtcdTestServer, Config, *assert.
 		Config: &genericapiserver.Config{},
 	}
 
+	storageConfig := storagebackend.Config{
+		Prefix:   etcdtest.PathPrefix(),
+		CAFile:   server.CAFile,
+		KeyFile:  server.KeyFile,
+		CertFile: server.CertFile,
+	}
+	for _, url := range server.ClientURLs {
+		storageConfig.ServerList = append(storageConfig.ServerList, url.String())
+	}
+
 	resourceEncoding := genericapiserver.NewDefaultResourceEncodingConfig()
 	resourceEncoding.SetVersionEncoding(api.GroupName, *testapi.Default.GroupVersion(), unversioned.GroupVersion{Group: api.GroupName, Version: runtime.APIVersionInternal})
 	resourceEncoding.SetVersionEncoding(autoscaling.GroupName, *testapi.Autoscaling.GroupVersion(), unversioned.GroupVersion{Group: autoscaling.GroupName, Version: runtime.APIVersionInternal})
@@ -90,7 +101,7 @@ func setUp(t *testing.T) (*Master, *etcdtesting.EtcdTestServer, Config, *assert.
 	resourceEncoding.SetVersionEncoding(extensions.GroupName, *testapi.Extensions.GroupVersion(), unversioned.GroupVersion{Group: extensions.GroupName, Version: runtime.APIVersionInternal})
 	resourceEncoding.SetVersionEncoding(rbac.GroupName, *testapi.Rbac.GroupVersion(), unversioned.GroupVersion{Group: rbac.GroupName, Version: runtime.APIVersionInternal})
 	resourceEncoding.SetVersionEncoding(certificates.GroupName, *testapi.Certificates.GroupVersion(), unversioned.GroupVersion{Group: certificates.GroupName, Version: runtime.APIVersionInternal})
-	storageFactory := genericapiserver.NewDefaultStorageFactory(*storageConfig, testapi.StorageMediaType(), api.Codecs, resourceEncoding, DefaultAPIResourceConfigSource())
+	storageFactory := genericapiserver.NewDefaultStorageFactory(storageConfig, testapi.StorageMediaType(), api.Codecs, resourceEncoding, DefaultAPIResourceConfigSource())
 
 	config.StorageFactory = storageFactory
 	config.APIResourceConfigSource = DefaultAPIResourceConfigSource()

pkg/registry/generic/registry/store_test.go

@@ -38,8 +38,8 @@ import (
 	"k8s.io/kubernetes/pkg/selection"
 	"k8s.io/kubernetes/pkg/storage"
 	etcdstorage "k8s.io/kubernetes/pkg/storage/etcd"
+	"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
 	etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
-	"k8s.io/kubernetes/pkg/storage/storagebackend/factory"
 	storagetesting "k8s.io/kubernetes/pkg/storage/testing"
 	"k8s.io/kubernetes/pkg/util/sets"
 	"k8s.io/kubernetes/pkg/util/validation/field"
@@ -1098,13 +1098,10 @@ func TestStoreWatch(t *testing.T) {
 
 func newTestGenericStoreRegistry(t *testing.T, hasCacheEnabled bool) (*etcdtesting.EtcdTestServer, *Store) {
 	podPrefix := "/pods"
-	server, sc := etcdtesting.NewUnsecuredEtcd3TestClientServer(t)
+	server := etcdtesting.NewEtcdTestClientServer(t)
 	strategy := &testRESTStrategy{api.Scheme, api.SimpleNameGenerator, true, false, true}
-	sc.Codec = testapi.Default.StorageCodec()
+	codec := testapi.Default.StorageCodec()
-	s, err := factory.Create(*sc)
+	s := etcdstorage.NewEtcdStorage(server.Client, codec, etcdtest.PathPrefix(), false, etcdtest.DeserializationCacheSize)
-	if err != nil {
-		t.Fatalf("Error creating storage: %v", err)
-	}
 	if hasCacheEnabled {
 		config := storage.CacherConfig{
 			CacheCapacity:  10,
@@ -1114,7 +1111,7 @@ func newTestGenericStoreRegistry(t *testing.T, hasCacheEnabled bool) (*etcdtesti
 			ResourcePrefix: podPrefix,
 			KeyFunc:        func(obj runtime.Object) (string, error) { return storage.NoNamespaceKeyFunc(podPrefix, obj) },
 			NewListFunc:    func() runtime.Object { return &api.PodList{} },
-			Codec:          sc.Codec,
+			Codec:          codec,
 		}
 		s = storage.NewCacherFromConfig(config)
 	}

pkg/registry/registrytest/etcd.go

@@ -30,14 +30,21 @@ import (
 	"k8s.io/kubernetes/pkg/registry/generic/registry"
 	"k8s.io/kubernetes/pkg/runtime"
 	etcdstorage "k8s.io/kubernetes/pkg/storage/etcd"
+	"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
 	etcdtesting "k8s.io/kubernetes/pkg/storage/etcd/testing"
 	"k8s.io/kubernetes/pkg/storage/storagebackend"
 	storagetesting "k8s.io/kubernetes/pkg/storage/testing"
 )
 
 func NewEtcdStorage(t *testing.T, group string) (*storagebackend.Config, *etcdtesting.EtcdTestServer) {
-	server, config := etcdtesting.NewUnsecuredEtcd3TestClientServer(t)
+	server := etcdtesting.NewUnsecuredEtcdTestClientServer(t)
-	config.Codec = testapi.Groups[group].StorageCodec()
+	config := &storagebackend.Config{
+		Type:                     "etcd2",
+		Prefix:                   etcdtest.PathPrefix(),
+		ServerList:               server.Client.Endpoints(),
+		DeserializationCacheSize: etcdtest.DeserializationCacheSize,
+		Codec: testapi.Groups[group].StorageCodec(),
+	}
 	return config, server
 }
 

pkg/storage/etcd/testing/utils.go

@@ -27,16 +27,12 @@ import (
 	"testing"
 	"time"
 
-	"k8s.io/kubernetes/pkg/storage/etcd/etcdtest"
 	"k8s.io/kubernetes/pkg/storage/etcd/testing/testingcert"
-	"k8s.io/kubernetes/pkg/storage/storagebackend"
 	"k8s.io/kubernetes/pkg/util/wait"
 
 	etcd "github.com/coreos/etcd/client"
-	"github.com/coreos/etcd/clientv3"
 	"github.com/coreos/etcd/etcdserver"
 	"github.com/coreos/etcd/etcdserver/api/v2http"
-	"github.com/coreos/etcd/integration"
 	"github.com/coreos/etcd/pkg/testutil"
 	"github.com/coreos/etcd/pkg/transport"
 	"github.com/coreos/etcd/pkg/types"
@@ -46,8 +42,6 @@ import (
 
 // EtcdTestServer encapsulates the datastructures needed to start local instance for testing
 type EtcdTestServer struct {
-	// The following are lumped etcd2 test server params
-	// TODO: Deprecate in a post 1.5 release
 	etcdserver.ServerConfig
 	PeerListeners, ClientListeners []net.Listener
 	Client                         etcd.Client
@@ -60,10 +54,6 @@ type EtcdTestServer struct {
 	raftHandler http.Handler
 	s           *etcdserver.EtcdServer
 	hss         []*httptest.Server
-
-	// The following are lumped etcd3 test server params
-	v3Cluster *integration.ClusterV3
-	v3Client  *clientv3.Client
 }
 
 // newLocalListener opens a port localhost using any port
@@ -229,9 +219,6 @@ func (m *EtcdTestServer) waitUntilUp() error {
 
 // Terminate will shutdown the running etcd server
 func (m *EtcdTestServer) Terminate(t *testing.T) {
-	if m.v3Cluster != nil {
-		m.v3Cluster.Terminate(t)
-	} else {
 	m.Client = nil
 	m.s.Stop()
 	// TODO: This is a pretty ugly hack to workaround races during closing
@@ -253,10 +240,9 @@ func (m *EtcdTestServer) Terminate(t *testing.T) {
 			t.Fatal(err)
 		}
 	}
-	}
 }
 
-// NewEtcdTestClientServer DEPRECATED creates a new client and server for testing
+// NewEtcdTestClientServer creates a new client and server for testing
 func NewEtcdTestClientServer(t *testing.T) *EtcdTestServer {
 	server := configureTestCluster(t, "foo", true)
 	err := server.launch(t)
@@ -283,7 +269,7 @@ func NewEtcdTestClientServer(t *testing.T) *EtcdTestServer {
 	return server
 }
 
-// NewUnsecuredEtcdTestClientServer DEPRECATED creates a new client and server for testing
+// NewUnsecuredEtcdTestClientServer creates a new client and server for testing
 func NewUnsecuredEtcdTestClientServer(t *testing.T) *EtcdTestServer {
 	server := configureTestCluster(t, "foo", false)
 	err := server.launch(t)
@@ -308,18 +294,3 @@ func NewUnsecuredEtcdTestClientServer(t *testing.T) *EtcdTestServer {
 	}
 	return server
 }
-
-// NewEtcd3TestClientServer creates a new client and server for testing
-func NewUnsecuredEtcd3TestClientServer(t *testing.T) (*EtcdTestServer, *storagebackend.Config) {
-	server := &EtcdTestServer{
-		v3Cluster: integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1}),
-	}
-	server.v3Client = server.v3Cluster.RandClient()
-	config := &storagebackend.Config{
-		Type:                     "etcd3",
-		Prefix:                   etcdtest.PathPrefix(),
-		ServerList:               server.v3Client.Endpoints(),
-		DeserializationCacheSize: etcdtest.DeserializationCacheSize,
-	}
-	return server, config
-}

pkg/storage/storagebackend/factory/etcd3.go

@@ -36,11 +36,7 @@ func newETCD3Storage(c storagebackend.Config) (storage.Interface, error) {
 	if err != nil {
 		return nil, err
 	}
-	// NOTE: Client relies on nil tlsConfig
+
-	// for non-secure connections, update the implicit variable
-	if len(c.CertFile) == 0 && len(c.KeyFile) == 0 && len(c.CAFile) == 0 {
-		tlsConfig = nil
-	}
 	cfg := clientv3.Config{
 		Endpoints: c.ServerList,
 		TLS:       tlsConfig,