Merge pull request #18274 from deads2k/server-02-kill-etcd2

Automatic merge from submit-queue (batch tested with PRs 17114, 18274).

remove etcd2 client from server

We stopped supporting etcd2 in 3.7.  This remove the related code.

Author: openshift-merge-robot

pkg/cmd/server/etcd/etcd.go

@@ -2,96 +2,17 @@ package etcd
 
 import (
 	"fmt"
-	"net"
-	"net/http"
 	"time"
 
-	etcdclient "github.com/coreos/etcd/client"
 	"github.com/coreos/etcd/clientv3"
 	"golang.org/x/net/context"
 
-	knet "k8s.io/apimachinery/pkg/util/net"
 	etcdutil "k8s.io/apiserver/pkg/storage/etcd/util"
 	restclient "k8s.io/client-go/rest"
 
 	configapi "github.com/openshift/origin/pkg/cmd/server/api"
 )
 
-// TestEtcdConnectionInfo creates an etcd client based on the provided config and attempts 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 TestEtcdConnectionInfo(etcdClientInfo configapi.EtcdConnectionInfo) 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 err
-	}
-	client, err := clientv3.New(clientv3.Config{
-		Endpoints: etcdClientInfo.URLs,
-		TLS:       tlsConfig,
-	})
-	if err != nil {
-		return err
-	}
-	ctx, _ := context.WithDeadline(context.Background(), time.Now().Add(5*time.Second))
-	return client.Sync(ctx)
-}
-
-// 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,
-			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 := etcdclient.Config{
-		Endpoints: etcdClientInfo.URLs,
-		// TODO: Determine if transport needs optimization
-		Transport: transport,
-	}
-	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 {
-	for i := 0; ; i++ {
-		_, err := etcdclient.NewKeysAPI(etcdClient).Get(context.Background(), "/", nil)
-		if err == nil || etcdutil.IsEtcdNotFound(err) {
-			break
-		}
-		if i > 100 {
-			return fmt.Errorf("could not reach etcd(v2): %v", err)
-		}
-		time.Sleep(50 * time.Millisecond)
-	}
-	return nil
-}
-
 // MakeEtcdClientV3Config creates client configuration based on the configapi.
 func MakeEtcdClientV3Config(etcdClientInfo configapi.EtcdConnectionInfo) (*clientv3.Config, error) {
 	tlsConfig, err := restclient.TLSConfigFor(&restclient.Config{

pkg/cmd/server/kubernetes/master/master_config.go

@@ -148,7 +148,7 @@ func BuildKubeAPIserverOptions(masterConfig configapi.MasterConfig) (*kapiserver
 	}
 
 	server.Etcd.EnableGarbageCollection = true
-	server.Etcd.StorageConfig.Type = "etcd2"                 // TODO(post-1.6.1-rebase): enable etcd3 as upstream
+	server.Etcd.StorageConfig.Type = "etcd3"
 	server.Etcd.DefaultStorageMediaType = "application/json" // TODO(post-1.6.1-rebase): enable protobuf with etcd3 as upstream
 	server.Etcd.StorageConfig.Quorum = true
 	server.Etcd.StorageConfig.Prefix = masterConfig.EtcdStorageConfig.KubernetesStoragePrefix

pkg/cmd/server/start/start_master.go

@@ -34,7 +34,6 @@ import (
 	"k8s.io/kubernetes/pkg/kubectl/cmd/templates"
 	kcmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
 	kubelettypes "k8s.io/kubernetes/pkg/kubelet/types"
-	kutilerrors "k8s.io/kubernetes/staging/src/k8s.io/apimachinery/pkg/util/errors"
 
 	"github.com/openshift/origin/pkg/cmd/server/admin"
 	configapi "github.com/openshift/origin/pkg/cmd/server/api"
@@ -583,22 +582,13 @@ func StartAPI(oc *origin.MasterConfig) error {
 }
 
 func testEtcdConnectivity(etcdClientInfo configapi.EtcdConnectionInfo) error {
-	// first try etcd2
-	etcdClient2, etcd2Err := etcd.MakeEtcdClient(etcdClientInfo)
-	if etcd2Err == nil {
-		etcd2Err = etcd.TestEtcdClient(etcdClient2)
-		if etcd2Err == nil {
-			return nil
-		}
-	}
-
 	// try etcd3 otherwise
-	etcdClient3, etcd3Err := etcd.MakeEtcdClientV3(etcdClientInfo)
-	if etcd3Err != nil {
-		return kutilerrors.NewAggregate([]error{etcd2Err, etcd3Err})
+	etcdClient3, err := etcd.MakeEtcdClientV3(etcdClientInfo)
+	if err != nil {
+		return err
 	}
-	if etcd3Err := etcd.TestEtcdClientV3(etcdClient3); etcd3Err != nil {
-		return kutilerrors.NewAggregate([]error{etcd2Err, etcd3Err})
+	if err := etcd.TestEtcdClientV3(etcdClient3); err != nil {
+		return err
 	}
 
 	return nil

pkg/oc/admin/diagnostics/diagnostics/host/etcd.go

@@ -10,7 +10,6 @@ import (
 	"text/tabwriter"
 	"time"
 
-	etcdclient "github.com/coreos/etcd/client"
 	"github.com/coreos/etcd/clientv3"
 
 	"bytes"
@@ -24,7 +23,6 @@ import (
 // and organize them by volume.
 type EtcdWriteVolume struct {
 	MasterConfigLocation string
-	V2Client             etcdclient.Client
 	V3Client             *clientv3.Client
 	durationSpec         string
 	duration             time.Duration
@@ -55,11 +53,11 @@ func (d *EtcdWriteVolume) AvailableParameters() []types.Parameter {
 }
 
 func (d *EtcdWriteVolume) Complete(logger *log.Logger) error {
-	v2Client, v3Client, found, err := findEtcdClients(d.MasterConfigLocation, logger)
+	v3Client, found, err := findEtcdClients(d.MasterConfigLocation, logger)
 	if err != nil || !found {
 		return err
 	}
-	d.V2Client, d.V3Client = v2Client, v3Client
+	d.V3Client = v3Client
 
 	// determine the duration to run the check from either the deprecated env var, the flag, or the default
 	s := os.Getenv("ETCD_WRITE_VOLUME_DURATION") // deprecated way
@@ -78,9 +76,6 @@ func (d *EtcdWriteVolume) Complete(logger *log.Logger) error {
 }
 
 func (d *EtcdWriteVolume) CanRun() (bool, error) {
-	if d.V2Client == nil {
-		return false, fmt.Errorf("must have a V2 etcd client")
-	}
 	if d.V3Client == nil {
 		return false, fmt.Errorf("must have a V3 etcd client")
 	}
@@ -90,53 +85,23 @@ func (d *EtcdWriteVolume) CanRun() (bool, error) {
 func (d *EtcdWriteVolume) Check() types.DiagnosticResult {
 	r := types.NewDiagnosticResult(EtcdWriteName)
 
-	var wg sync.WaitGroup
-
 	ctx := context.Background()
 	ctx, cancel := context.WithDeadline(ctx, time.Now().Add(d.duration))
 	defer cancel()
 
 	keyStats := &keyCounter{}
 	stats := &lockedKeyCounter{KeyCounter: keyStats}
 
-	wg.Add(2)
-	go func() {
-		defer wg.Done()
-		keys := etcdclient.NewKeysAPI(d.V2Client)
-		w := keys.Watcher("/", &etcdclient.WatcherOptions{Recursive: true})
-		for {
-			evt, err := w.Next(ctx)
-			if err != nil {
-				if err != context.DeadlineExceeded {
-					r.Error("DEw2001", err, fmt.Sprintf("Unable to get a v2 watch event, stopping early: %v", err))
-				}
-				return
-			}
-			node := evt.Node
-			if node == nil {
-				node = evt.PrevNode
-			}
-			if node == nil {
+	ch := d.V3Client.Watch(ctx, "/", clientv3.WithKeysOnly(), clientv3.WithPrefix())
+	for resource := range ch {
+		for _, evt := range resource.Events {
+			if evt.Kv == nil {
 				continue
 			}
-			action := fmt.Sprintf("v2:%s", evt.Action)
-			stats.Inc(strings.Split(action+"/"+strings.TrimPrefix(evt.Node.Key, "/"), "/"))
+			action := fmt.Sprintf("v3:%s", evt.Type)
+			stats.Inc(strings.Split(action+"/"+strings.TrimPrefix(string(evt.Kv.Key), "/"), "/"))
 		}
-	}()
-	go func() {
-		defer wg.Done()
-		ch := d.V3Client.Watch(ctx, "/", clientv3.WithKeysOnly(), clientv3.WithPrefix())
-		for resource := range ch {
-			for _, evt := range resource.Events {
-				if evt.Kv == nil {
-					continue
-				}
-				action := fmt.Sprintf("v3:%s", evt.Type)
-				stats.Inc(strings.Split(action+"/"+strings.TrimPrefix(string(evt.Kv.Key), "/"), "/"))
-			}
-		}
-	}()
-	wg.Wait()
+	}
 
 	bins := keyStats.Bins("", "/")
 	sort.Sort(DescendingBins(bins))
@@ -154,38 +119,32 @@ func (d *EtcdWriteVolume) Check() types.DiagnosticResult {
 }
 
 // findEtcdClients finds and loads etcd clients
-func findEtcdClients(configFile string, logger *log.Logger) (etcdclient.Client, *clientv3.Client, bool, error) {
+func findEtcdClients(configFile string, logger *log.Logger) (*clientv3.Client, bool, error) {
 	masterConfig, err := GetMasterConfig(configFile, logger)
 	if err != nil {
 		configErr := fmt.Errorf("Unreadable master config; skipping this diagnostic.")
 		logger.Error("DE2001", configErr.Error())
-		return nil, nil, false, configErr
+		return nil, false, configErr
 	}
 	if len(masterConfig.EtcdClientInfo.URLs) == 0 {
 		configErr := fmt.Errorf("No etcdClientInfo.urls defined; can't contact etcd")
 		logger.Error("DE2002", configErr.Error())
-		return nil, nil, false, configErr
-	}
-	v2Client, err := etcd.MakeEtcdClient(masterConfig.EtcdClientInfo)
-	if err != nil {
-		configErr := fmt.Errorf("Unable to create an etcd v2 client: %v", err)
-		logger.Error("DE2003", configErr.Error())
-		return nil, nil, false, configErr
+		return nil, false, configErr
 	}
 	config, err := etcd.MakeEtcdClientV3Config(masterConfig.EtcdClientInfo)
 	if err != nil {
 		configErr := fmt.Errorf("Unable to create an etcd v3 client config: %v", err)
 		logger.Error("DE2004", configErr.Error())
-		return nil, nil, false, configErr
+		return nil, false, configErr
 	}
 	config.DialTimeout = 5 * time.Second
 	v3Client, err := clientv3.New(*config)
 	if err != nil {
 		configErr := fmt.Errorf("Unable to create an etcd v3 client: %v", err)
 		logger.Error("DE2005", configErr.Error())
-		return nil, nil, false, configErr
+		return nil, false, configErr
 	}
-	return v2Client, v3Client, true, nil
+	return v3Client, true, nil
 }
 
 type KeyCounter interface {