Move the newClientCfg into clientv3 package so as to be reused by both etcdctl and v3discovery

client/v3/config.go

@@ -19,6 +19,7 @@ import (
 	"crypto/tls"
 	"time"
 
+	"go.etcd.io/etcd/client/pkg/v3/transport"
 	"go.uber.org/zap"
 	"google.golang.org/grpc"
 )
@@ -118,3 +119,65 @@ type AuthConfig struct {
 	Username string `json:"username"`
 	Password string `json:"password"`
 }
+
+// NewClientConfig creates a Config based on the provided ConfigSpec.
+func NewClientConfig(confSpec *ConfigSpec, lg *zap.Logger) (*Config, error) {
+	tlsCfg, err := newTLSConfig(confSpec.Secure, lg)
+	if err != nil {
+		return nil, err
+	}
+
+	cfg := &Config{
+		Endpoints:            confSpec.Endpoints,
+		DialTimeout:          confSpec.DialTimeout,
+		DialKeepAliveTime:    confSpec.KeepAliveTime,
+		DialKeepAliveTimeout: confSpec.KeepAliveTimeout,
+		TLS:                  tlsCfg,
+	}
+
+	if confSpec.Auth != nil {
+		cfg.Username = confSpec.Auth.Username
+		cfg.Password = confSpec.Auth.Password
+	}
+
+	return cfg, nil
+}
+
+func newTLSConfig(scfg *SecureConfig, lg *zap.Logger) (*tls.Config, error) {
+	var (
+		tlsCfg *tls.Config
+		err    error
+	)
+
+	if scfg == nil {
+		return nil, nil
+	}
+
+	if scfg.Cert != "" || scfg.Key != "" || scfg.Cacert != "" || scfg.ServerName != "" {
+		cfgtls := &transport.TLSInfo{
+			CertFile:      scfg.Cert,
+			KeyFile:       scfg.Key,
+			TrustedCAFile: scfg.Cacert,
+			ServerName:    scfg.ServerName,
+			Logger:        lg,
+		}
+		if tlsCfg, err = cfgtls.ClientConfig(); err != nil {
+			return nil, err
+		}
+	}
+
+	// If key/cert is not given but user wants secure connection, we
+	// should still setup an empty tls configuration for gRPC to setup
+	// secure connection.
+	if tlsCfg == nil && !scfg.InsecureTransport {
+		tlsCfg = &tls.Config{}
+	}
+
+	// If the user wants to skip TLS verification then we should set
+	// the InsecureSkipVerify flag in tls configuration.
+	if tlsCfg != nil && scfg.InsecureSkipVerify {
+		tlsCfg.InsecureSkipVerify = true
+	}
+
+	return tlsCfg, nil
+}

etcdctl/ctlv3/command/global_test.go → client/v3/config_test.go

@@ -12,83 +12,92 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package command
+package clientv3
 
 import (
 	"crypto/tls"
-
-	"go.uber.org/zap"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/assert"
 	"go.etcd.io/etcd/client/pkg/v3/transport"
-	clientv3 "go.etcd.io/etcd/client/v3"
+	"go.uber.org/zap"
 )
 
 func TestNewClientConfig(t *testing.T) {
 	cases := []struct {
 		name         string
-		spec         clientv3.ConfigSpec
-		expectedConf clientv3.Config
+		spec         ConfigSpec
+		expectedConf Config
 	}{
 		{
-			name: "default secure transport",
-			spec: clientv3.ConfigSpec{
+			name: "only has basic info",
+			spec: ConfigSpec{
 				Endpoints:        []string{"http://192.168.0.10:2379"},
 				DialTimeout:      2 * time.Second,
 				KeepAliveTime:    3 * time.Second,
 				KeepAliveTimeout: 5 * time.Second,
-				Secure: &clientv3.SecureConfig{
-					InsecureTransport: false,
-				},
 			},
-			expectedConf: clientv3.Config{
+			expectedConf: Config{
 				Endpoints:            []string{"http://192.168.0.10:2379"},
 				DialTimeout:          2 * time.Second,
 				DialKeepAliveTime:    3 * time.Second,
 				DialKeepAliveTimeout: 5 * time.Second,
-				TLS:                  &tls.Config{},
 			},
 		},
 		{
-			name: "default secure transport and auth enabled",
-			spec: clientv3.ConfigSpec{
+			name: "auth enabled",
+			spec: ConfigSpec{
 				Endpoints:        []string{"http://192.168.0.12:2379"},
 				DialTimeout:      1 * time.Second,
 				KeepAliveTime:    4 * time.Second,
 				KeepAliveTimeout: 6 * time.Second,
-				Secure: &clientv3.SecureConfig{
-					InsecureTransport: false,
-				},
-				Auth: &clientv3.AuthConfig{
+				Auth: &AuthConfig{
 					Username: "test",
 					Password: "changeme",
 				},
 			},
-			expectedConf: clientv3.Config{
+			expectedConf: Config{
 				Endpoints:            []string{"http://192.168.0.12:2379"},
 				DialTimeout:          1 * time.Second,
 				DialKeepAliveTime:    4 * time.Second,
 				DialKeepAliveTimeout: 6 * time.Second,
-				TLS:                  &tls.Config{},
 				Username:             "test",
 				Password:             "changeme",
 			},
 		},
+		{
+			name: "default secure transport",
+			spec: ConfigSpec{
+				Endpoints:        []string{"http://192.168.0.10:2379"},
+				DialTimeout:      2 * time.Second,
+				KeepAliveTime:    3 * time.Second,
+				KeepAliveTimeout: 5 * time.Second,
+				Secure: &SecureConfig{
+					InsecureTransport: false,
+				},
+			},
+			expectedConf: Config{
+				Endpoints:            []string{"http://192.168.0.10:2379"},
+				DialTimeout:          2 * time.Second,
+				DialKeepAliveTime:    3 * time.Second,
+				DialKeepAliveTimeout: 5 * time.Second,
+				TLS:                  &tls.Config{},
+			},
+		},
 		{
 			name: "default secure transport and skip TLS verification",
-			spec: clientv3.ConfigSpec{
+			spec: ConfigSpec{
 				Endpoints:        []string{"http://192.168.0.13:2379"},
 				DialTimeout:      1 * time.Second,
 				KeepAliveTime:    3 * time.Second,
 				KeepAliveTimeout: 5 * time.Second,
-				Secure: &clientv3.SecureConfig{
+				Secure: &SecureConfig{
 					InsecureTransport:  false,
 					InsecureSkipVerify: true,
 				},
 			},
-			expectedConf: clientv3.Config{
+			expectedConf: Config{
 				Endpoints:            []string{"http://192.168.0.13:2379"},
 				DialTimeout:          1 * time.Second,
 				DialKeepAliveTime:    3 * time.Second,
@@ -102,7 +111,9 @@ func TestNewClientConfig(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			cfg, err := newClientCfg(tc.spec.Endpoints, tc.spec.DialTimeout, tc.spec.KeepAliveTime, tc.spec.KeepAliveTimeout, tc.spec.Secure, tc.spec.Auth)
+			lg, _ := zap.NewProduction()
+
+			cfg, err := NewClientConfig(&tc.spec, lg)
 			if err != nil {
 				t.Fatalf("Unexpected error: %v", err)
 			}
@@ -118,14 +129,20 @@ func TestNewClientConfigWithSecureCfg(t *testing.T) {
 		t.Fatalf("Unexpected error: %v", err)
 	}
 
-	scfg := &clientv3.SecureConfig{
+	scfg := &SecureConfig{
 		Cert:   tls.CertFile,
 		Key:    tls.KeyFile,
 		Cacert: tls.TrustedCAFile,
 	}
 
-	cfg, err := newClientCfg([]string{"http://192.168.0.13:2379"}, 2*time.Second, 3*time.Second, 5*time.Second, scfg, nil)
-	if cfg == nil || err != nil {
+	cfg, err := NewClientConfig(&ConfigSpec{
+		Endpoints:        []string{"http://192.168.0.13:2379"},
+		DialTimeout:      2 * time.Second,
+		KeepAliveTime:    3 * time.Second,
+		KeepAliveTimeout: 5 * time.Second,
+		Secure:           scfg,
+	}, nil)
+	if err != nil || cfg == nil || cfg.TLS == nil {
 		t.Fatalf("Unexpected result client config: %v", err)
 	}
 }

client/v3/go.mod

@@ -6,6 +6,7 @@ require (
 	github.com/dustin/go-humanize v1.0.0
 	github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0
 	github.com/prometheus/client_golang v1.11.0
+	github.com/stretchr/testify v1.7.0
 	go.etcd.io/etcd/api/v3 v3.6.0-alpha.0
 	go.etcd.io/etcd/client/pkg/v3 v3.6.0-alpha.0
 	go.uber.org/zap v1.17.0
@@ -26,7 +27,6 @@ require (
 	github.com/prometheus/client_model v0.2.0 // indirect
 	github.com/prometheus/common v0.26.0 // indirect
 	github.com/prometheus/procfs v0.6.0 // indirect
-	github.com/stretchr/testify v1.7.0 // indirect
 	go.uber.org/atomic v1.7.0 // indirect
 	go.uber.org/multierr v1.6.0 // indirect
 	golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 // indirect

etcdctl/ctlv3/command/ep_command.go

@@ -22,7 +22,7 @@ import (
 
 	"go.etcd.io/etcd/api/v3/etcdserverpb"
 	"go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
-	v3 "go.etcd.io/etcd/client/v3"
+	"go.etcd.io/etcd/client/v3"
 	"go.etcd.io/etcd/pkg/v3/cobrautl"
 	"go.etcd.io/etcd/pkg/v3/flags"
 
@@ -100,9 +100,16 @@ func epHealthCommandFunc(cmd *cobra.Command, args []string) {
 	ka := keepAliveTimeFromCmd(cmd)
 	kat := keepAliveTimeoutFromCmd(cmd)
 	auth := authCfgFromCmd(cmd)
-	cfgs := []*v3.Config{}
+	cfgs := []*clientv3.Config{}
 	for _, ep := range endpointsFromCluster(cmd) {
-		cfg, err := newClientCfg([]string{ep}, dt, ka, kat, sec, auth)
+		cfg, err := clientv3.NewClientConfig(&clientv3.ConfigSpec{
+			Endpoints:        []string{ep},
+			DialTimeout:      dt,
+			KeepAliveTime:    ka,
+			KeepAliveTimeout: kat,
+			Secure:           sec,
+			Auth:             auth,
+		}, lg)
 		if err != nil {
 			cobrautl.ExitWithError(cobrautl.ExitBadArgs, err)
 		}
@@ -113,11 +120,11 @@ func epHealthCommandFunc(cmd *cobra.Command, args []string) {
 	hch := make(chan epHealth, len(cfgs))
 	for _, cfg := range cfgs {
 		wg.Add(1)
-		go func(cfg *v3.Config) {
+		go func(cfg *clientv3.Config) {
 			defer wg.Done()
 			ep := cfg.Endpoints[0]
 			cfg.Logger = lg.Named("client")
-			cli, err := v3.New(*cfg)
+			cli, err := clientv3.New(*cfg)
 			if err != nil {
 				hch <- epHealth{Ep: ep, Health: false, Error: err.Error()}
 				return
@@ -178,8 +185,8 @@ func epHealthCommandFunc(cmd *cobra.Command, args []string) {
 }
 
 type epStatus struct {
-	Ep   string             `json:"Endpoint"`
-	Resp *v3.StatusResponse `json:"Status"`
+	Ep   string                   `json:"Endpoint"`
+	Resp *clientv3.StatusResponse `json:"Status"`
 }
 
 func epStatusCommandFunc(cmd *cobra.Command, args []string) {
@@ -207,8 +214,8 @@ func epStatusCommandFunc(cmd *cobra.Command, args []string) {
 }
 
 type epHashKV struct {
-	Ep   string             `json:"Endpoint"`
-	Resp *v3.HashKVResponse `json:"HashKV"`
+	Ep   string                   `json:"Endpoint"`
+	Resp *clientv3.HashKVResponse `json:"HashKV"`
 }
 
 func epHashKVCommandFunc(cmd *cobra.Command, args []string) {
@@ -253,12 +260,18 @@ func endpointsFromCluster(cmd *cobra.Command) []string {
 		cobrautl.ExitWithError(cobrautl.ExitError, err)
 	}
 	// exclude auth for not asking needless password (MemberList() doesn't need authentication)
-
-	cfg, err := newClientCfg(eps, dt, ka, kat, sec, nil)
+	lg, _ := zap.NewProduction()
+	cfg, err := clientv3.NewClientConfig(&clientv3.ConfigSpec{
+		Endpoints:        eps,
+		DialTimeout:      dt,
+		KeepAliveTime:    ka,
+		KeepAliveTimeout: kat,
+		Secure:           sec,
+	}, lg)
 	if err != nil {
 		cobrautl.ExitWithError(cobrautl.ExitError, err)
 	}
-	c, err := v3.New(*cfg)
+	c, err := clientv3.New(*cfg)
 	if err != nil {
 		cobrautl.ExitWithError(cobrautl.ExitError, err)
 	}