Remove old etcd client dependency

pkg/cmd/server/etcd/etcd.go

@@ -4,12 +4,9 @@ import (
 	"fmt"
 	"net"
 	"net/http"
-	"net/http/httputil"
 	"time"
 
-	newetcdclient "github.com/coreos/etcd/client"
-	etcdclient "github.com/coreos/go-etcd/etcd"
-	"github.com/golang/glog"
+	etcdclient "github.com/coreos/etcd/client"
 	"golang.org/x/net/context"
 
 	"k8s.io/kubernetes/pkg/client/restclient"
@@ -22,9 +19,8 @@ import (
 // GetAndTestEtcdClient creates an etcd client based on the provided config. It will attempt to
 // connect to the etcd server and block until the server responds at least once, or return an
 // error if the server never responded.
-// TODO: switch this function to use EtcdHelper.
-func GetAndTestEtcdClient(etcdClientInfo configapi.EtcdConnectionInfo) (*etcdclient.Client, error) {
-	etcdClient, err := EtcdClient(etcdClientInfo)
+func GetAndTestEtcdClient(etcdClientInfo configapi.EtcdConnectionInfo) (etcdclient.Client, error) {
+	etcdClient, err := MakeEtcdClient(etcdClientInfo)
 	if err != nil {
 		return nil, err
 	}
@@ -34,8 +30,8 @@ func GetAndTestEtcdClient(etcdClientInfo configapi.EtcdConnectionInfo) (*etcdcli
 	return etcdClient, nil
 }
 
-// EtcdClient creates an etcd client based on the provided config.
-func EtcdClient(etcdClientInfo configapi.EtcdConnectionInfo) (*etcdclient.Client, error) {
+// MakeEtcdClient creates an etcd client based on the provided config.
+func MakeEtcdClient(etcdClientInfo configapi.EtcdConnectionInfo) (etcdclient.Client, error) {
 	tlsConfig, err := restclient.TLSConfigFor(&restclient.Config{
 		TLSClientConfig: restclient.TLSClientConfig{
 			CertFile: etcdClientInfo.ClientCert.CertFile,
@@ -59,51 +55,20 @@ func EtcdClient(etcdClientInfo configapi.EtcdConnectionInfo) (*etcdclient.Client
 		MaxIdleConnsPerHost: 500,
 	})
 
-	etcdClient := etcdclient.NewClient(etcdClientInfo.URLs)
-	etcdClient.SetTransport(transport)
-	etcdClient.CheckRetry = NeverRetryOnFailure
-	return etcdClient, nil
-}
-
-// MakeNewEtcdClient creates an etcd client based on the provided config.
-func MakeNewEtcdClient(etcdClientInfo configapi.EtcdConnectionInfo) (newetcdclient.Client, error) {
-	tlsConfig, err := restclient.TLSConfigFor(&restclient.Config{
-		TLSClientConfig: restclient.TLSClientConfig{
-			CertFile: etcdClientInfo.ClientCert.CertFile,
-			KeyFile:  etcdClientInfo.ClientCert.KeyFile,
-			CAFile:   etcdClientInfo.CA,
-		},
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	transport := knet.SetTransportDefaults(&http.Transport{
-		TLSClientConfig: tlsConfig,
-		Dial: (&net.Dialer{
-			// default from http.DefaultTransport
-			Timeout: 30 * time.Second,
-			// Lower the keep alive for connections.
-			KeepAlive: 1 * time.Second,
-		}).Dial,
-		// Because watches are very bursty, defends against long delays in watch reconnections.
-		MaxIdleConnsPerHost: 500,
-	})
-
-	cfg := newetcdclient.Config{
+	cfg := etcdclient.Config{
 		Endpoints: etcdClientInfo.URLs,
 		// TODO: Determine if transport needs optimization
 		Transport: transport,
 	}
-	return newetcdclient.New(cfg)
+	return etcdclient.New(cfg)
 }
 
 // TestEtcdClient verifies a client is functional.  It will attempt to
 // connect to the etcd server and block until the server responds at least once, or return an
 // error if the server never responded.
-func TestEtcdClient(etcdClient *etcdclient.Client) error {
+func TestEtcdClient(etcdClient etcdclient.Client) error {
 	for i := 0; ; i++ {
-		_, err := etcdClient.Get("/", false, false)
+		_, err := etcdclient.NewKeysAPI(etcdClient).Get(context.Background(), "/", nil)
 		if err == nil || etcdutil.IsEtcdNotFound(err) {
 			break
 		}
@@ -114,36 +79,3 @@ func TestEtcdClient(etcdClient *etcdclient.Client) error {
 	}
 	return nil
 }
-
-// TestEtcdClient verifies a client is functional.  It will attempt to
-// connect to the etcd server and block until the server responds at least once, or return an
-// error if the server never responded.
-func TestNewEtcdClient(etcdClient newetcdclient.Client) error {
-	for i := 0; ; i++ {
-		_, err := newetcdclient.NewKeysAPI(etcdClient).Get(context.Background(), "/", nil)
-		if err == nil || etcdutil.IsEtcdNotFound(err) {
-			break
-		}
-		if i > 100 {
-			return fmt.Errorf("could not reach etcd: %v", err)
-		}
-		time.Sleep(50 * time.Millisecond)
-	}
-	return nil
-}
-
-// NeverRetryOnFailure is a retry function for the etcdClient.  If there's only one machine, master election doesn't make much sense,
-// so we don't bother to retry, we simply dump the failure and return the error directly.
-func NeverRetryOnFailure(cluster *etcdclient.Cluster, numReqs int, lastResp http.Response, err error) error {
-	if len(cluster.Machines) > 1 {
-		return etcdclient.DefaultCheckRetry(cluster, numReqs, lastResp, err)
-	}
-
-	content, err := httputil.DumpResponse(&lastResp, true)
-	if err != nil {
-		glog.Errorf("failure dumping response: %v", err)
-	} else {
-		glog.Errorf("etcd failure response: %s", string(content))
-	}
-	return err
-}

pkg/cmd/server/origin/master_config.go

@@ -167,7 +167,7 @@ type MasterConfig struct {
 // BuildMasterConfig builds and returns the OpenShift master configuration based on the
 // provided options
 func BuildMasterConfig(options configapi.MasterConfig) (*MasterConfig, error) {
-	client, err := etcd.MakeNewEtcdClient(options.EtcdClientInfo)
+	client, err := etcd.MakeEtcdClient(options.EtcdClientInfo)
 	if err != nil {
 		return nil, err
 	}

pkg/cmd/server/start/start_master.go

@@ -449,10 +449,8 @@ func StartAPI(oc *origin.MasterConfig, kc *kubernetes.MasterConfig) error {
 	}
 
 	// verify we can connect to etcd with the provided config
-	if etcdClient, err := etcd.GetAndTestEtcdClient(oc.Options.EtcdClientInfo); err != nil {
+	if _, err := etcd.GetAndTestEtcdClient(oc.Options.EtcdClientInfo); err != nil {
 		return err
-	} else {
-		etcdClient.Close()
 	}
 
 	// Must start policy caching immediately

test/integration/userclient_test.go

@@ -399,7 +399,7 @@ func TestUserInitialization(t *testing.T) {
 		},
 	}
 
-	oldEtcdClient, err := etcd.MakeNewEtcdClient(masterConfig.EtcdClientInfo)
+	oldEtcdClient, err := etcd.MakeEtcdClient(masterConfig.EtcdClientInfo)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}

test/util/etcd.go

@@ -1,20 +1,18 @@
 package util
 
 import (
+	"encoding/json"
 	"flag"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"math/rand"
 	"os"
 	goruntime "runtime"
 	"strings"
 	"testing"
 
+	"golang.org/x/net/context"
+
 	"github.com/coreos/pkg/capnslog"
 
-	newetcdclient "github.com/coreos/etcd/client"
-	"github.com/coreos/go-etcd/etcd"
+	etcdclient "github.com/coreos/etcd/client"
 
 	"k8s.io/kubernetes/pkg/capabilities"
 	etcdtest "k8s.io/kubernetes/pkg/storage/etcd/testing"
@@ -46,27 +44,22 @@ func RequireEtcd(t *testing.T) *etcdtest.EtcdTestServer {
 	return s
 }
 
-func NewEtcdClient() *etcd.Client {
-	etcdServers := []string{GetEtcdURL()}
-
-	client := etcd.NewClient(etcdServers)
-	if err := serveretcd.TestEtcdClient(client); err != nil {
-		panic(err)
-	}
+func NewEtcdClient() etcdclient.Client {
+	client, _ := MakeNewEtcdClient()
 	return client
 }
 
-func MakeNewEtcdClient() (newetcdclient.Client, error) {
+func MakeNewEtcdClient() (etcdclient.Client, error) {
 	etcdServers := []string{GetEtcdURL()}
 
-	cfg := newetcdclient.Config{
+	cfg := etcdclient.Config{
 		Endpoints: etcdServers,
 	}
-	client, err := newetcdclient.New(cfg)
+	client, err := etcdclient.New(cfg)
 	if err != nil {
 		return nil, err
 	}
-	return client, serveretcd.TestNewEtcdClient(client)
+	return client, serveretcd.TestEtcdClient(client)
 }
 
 func GetEtcdURL() string {
@@ -76,16 +69,6 @@ func GetEtcdURL() string {
 	return url
 }
 
-func logEtcd() {
-	etcd.SetLogger(log.New(os.Stderr, "go-etcd", log.LstdFlags))
-}
-
-func withEtcdKey(f func(string)) {
-	prefix := fmt.Sprintf("/test-%d", rand.Int63())
-	defer NewEtcdClient().Delete(prefix, true)
-	f(prefix)
-}
-
 func DumpEtcdOnFailure(t *testing.T) {
 	if !t.Failed() {
 		return
@@ -99,16 +82,31 @@ func DumpEtcdOnFailure(t *testing.T) {
 		last = 0
 	}
 	name := f.Name()[last:]
-
 	client := NewEtcdClient()
-	etcdResponse, err := client.RawGet("/", false, true)
+	keyClient := etcdclient.NewKeysAPI(client)
+
+	response, err := keyClient.Get(context.Background(), "/", &etcdclient.GetOptions{Recursive: true, Sort: true})
 	if err != nil {
 		t.Logf("error dumping etcd: %v", err)
 		return
 	}
+	jsonResponse, err := json.Marshal(response.Node)
+	if err != nil {
+		t.Logf("error encoding etcd dump: %v", err)
+		return
+	}
 
-	if err := ioutil.WriteFile(GetBaseDir()+"/etcd-dump-"+name+".json", etcdResponse.Body, os.FileMode(0444)); err != nil {
-		t.Logf("error dumping etcd: %v", err)
+	t.Logf("dumping etcd to %q", GetBaseDir()+"/etcd-dump-"+name+".json")
+	dumpFile, err := os.OpenFile(GetBaseDir()+"/etcd-dump-"+name+".json", os.O_WRONLY|os.O_CREATE, 0444)
+	if err != nil {
+		t.Logf("error writing etcd dump: %v", err)
 		return
 	}
+	defer dumpFile.Close()
+	_, err = dumpFile.Write(jsonResponse)
+	if err != nil {
+		t.Logf("error writing etcd dump: %v", err)
+		return
+	}
+
 }