functional/rpcpb: add "*Etcd.EmbedConfig", and logger fields

Signed-off-by: Gyuho Lee <gyuhox@gmail.com>

functional.yaml

@@ -1,9 +1,8 @@
 agent-configs:
-- etcd-exec-path: ./bin/etcd
+- etcd-exec: ./bin/etcd
   agent-addr: 127.0.0.1:19027
   failpoint-http-addr: http://127.0.0.1:7381
   base-dir: /tmp/etcd-functional-1
-  etcd-log-path: /tmp/etcd-functional-1/etcd.log
   etcd-client-proxy: false
   etcd-peer-proxy: true
   etcd-client-endpoint: 127.0.0.1:1379
@@ -34,6 +33,9 @@ agent-configs:
     quota-backend-bytes: 10740000000 # 10 GiB
     pre-vote: true
     initial-corrupt-check: true
+    logger: zap
+    log-output: /tmp/etcd-functional-1/etcd.log
+    debug: true
   client-cert-data: ""
   client-cert-path: ""
   client-key-data: ""
@@ -48,11 +50,10 @@ agent-configs:
   peer-trusted-ca-path: ""
   snapshot-path: /tmp/etcd-functional-1.snapshot.db
 
-- etcd-exec-path: ./bin/etcd
+- etcd-exec: ./bin/etcd
   agent-addr: 127.0.0.1:29027
   failpoint-http-addr: http://127.0.0.1:7382
   base-dir: /tmp/etcd-functional-2
-  etcd-log-path: /tmp/etcd-functional-2/etcd.log
   etcd-client-proxy: false
   etcd-peer-proxy: true
   etcd-client-endpoint: 127.0.0.1:2379
@@ -83,6 +84,9 @@ agent-configs:
     quota-backend-bytes: 10740000000 # 10 GiB
     pre-vote: true
     initial-corrupt-check: true
+    logger: zap
+    log-output: /tmp/etcd-functional-2/etcd.log
+    debug: true
   client-cert-data: ""
   client-cert-path: ""
   client-key-data: ""
@@ -97,11 +101,10 @@ agent-configs:
   peer-trusted-ca-path: ""
   snapshot-path: /tmp/etcd-functional-2.snapshot.db
 
-- etcd-exec-path: ./bin/etcd
+- etcd-exec: ./bin/etcd
   agent-addr: 127.0.0.1:39027
   failpoint-http-addr: http://127.0.0.1:7383
   base-dir: /tmp/etcd-functional-3
-  etcd-log-path: /tmp/etcd-functional-3/etcd.log
   etcd-client-proxy: false
   etcd-peer-proxy: true
   etcd-client-endpoint: 127.0.0.1:3379
@@ -132,6 +135,9 @@ agent-configs:
     quota-backend-bytes: 10740000000 # 10 GiB
     pre-vote: true
     initial-corrupt-check: true
+    logger: zap
+    log-output: /tmp/etcd-functional-3/etcd.log
+    debug: true
   client-cert-data: ""
   client-cert-path: ""
   client-key-data: ""

functional/agent/handler.go

@@ -233,13 +233,13 @@ func (srv *Server) createEtcdLogFile() error {
 }
 
 func (srv *Server) creatEtcdCmd(fromSnapshot bool) {
-	etcdPath, etcdFlags := srv.Member.EtcdExecPath, srv.Member.Etcd.Flags()
+	etcdPath, etcdFlags := srv.Member.EtcdExec, srv.Member.Etcd.Flags()
 	if fromSnapshot {
 		etcdFlags = srv.Member.EtcdOnSnapshotRestore.Flags()
 	}
 	u, _ := url.Parse(srv.Member.FailpointHTTPAddr)
 	srv.lg.Info("creating etcd command",
-		zap.String("etcd-exec-path", etcdPath),
+		zap.String("etcd-exec", etcdPath),
 		zap.Strings("etcd-flags", etcdFlags),
 		zap.String("failpoint-http-addr", srv.Member.FailpointHTTPAddr),
 		zap.String("failpoint-addr", u.Host),

functional/rpcpb/etcd_config.go

@@ -18,6 +18,10 @@ import (
 	"fmt"
 	"reflect"
 	"strings"
+
+	"github.com/coreos/etcd/embed"
+	"github.com/coreos/etcd/pkg/transport"
+	"github.com/coreos/etcd/pkg/types"
 )
 
 var etcdFields = []string{
@@ -53,12 +57,16 @@ var etcdFields = []string{
 
 	"PreVote",
 	"InitialCorruptCheck",
+
+	"Logger",
+	"LogOutput",
+	"Debug",
 }
 
 // Flags returns etcd flags in string slice.
-func (cfg *Etcd) Flags() (fs []string) {
-	tp := reflect.TypeOf(*cfg)
-	vo := reflect.ValueOf(*cfg)
+func (e *Etcd) Flags() (fs []string) {
+	tp := reflect.TypeOf(*e)
+	vo := reflect.ValueOf(*e)
 	for _, name := range etcdFields {
 		field, ok := tp.FieldByName(name)
 		if !ok {
@@ -97,3 +105,70 @@ func (cfg *Etcd) Flags() (fs []string) {
 	}
 	return fs
 }
+
+// EmbedConfig returns etcd embed.Config.
+func (e *Etcd) EmbedConfig() (cfg *embed.Config, err error) {
+	var lcURLs types.URLs
+	lcURLs, err = types.NewURLs(e.ListenClientURLs)
+	if err != nil {
+		return nil, err
+	}
+	var acURLs types.URLs
+	acURLs, err = types.NewURLs(e.AdvertiseClientURLs)
+	if err != nil {
+		return nil, err
+	}
+	var lpURLs types.URLs
+	lpURLs, err = types.NewURLs(e.ListenPeerURLs)
+	if err != nil {
+		return nil, err
+	}
+	var apURLs types.URLs
+	apURLs, err = types.NewURLs(e.AdvertisePeerURLs)
+	if err != nil {
+		return nil, err
+	}
+
+	cfg = embed.NewConfig()
+	cfg.Name = e.Name
+	cfg.Dir = e.DataDir
+	cfg.WalDir = e.WALDir
+	cfg.TickMs = uint(e.HeartbeatIntervalMs)
+	cfg.ElectionMs = uint(e.ElectionTimeoutMs)
+
+	cfg.LCUrls = lcURLs
+	cfg.ACUrls = acURLs
+	cfg.ClientAutoTLS = e.ClientAutoTLS
+	cfg.ClientTLSInfo = transport.TLSInfo{
+		ClientCertAuth: e.ClientCertAuth,
+		CertFile:       e.ClientCertFile,
+		KeyFile:        e.ClientKeyFile,
+		TrustedCAFile:  e.ClientTrustedCAFile,
+	}
+
+	cfg.LPUrls = lpURLs
+	cfg.APUrls = apURLs
+	cfg.PeerAutoTLS = e.PeerAutoTLS
+	cfg.PeerTLSInfo = transport.TLSInfo{
+		ClientCertAuth: e.PeerClientCertAuth,
+		CertFile:       e.PeerCertFile,
+		KeyFile:        e.PeerKeyFile,
+		TrustedCAFile:  e.PeerTrustedCAFile,
+	}
+
+	cfg.InitialCluster = e.InitialCluster
+	cfg.ClusterState = e.InitialClusterState
+	cfg.InitialClusterToken = e.InitialClusterToken
+
+	cfg.SnapCount = uint64(e.SnapshotCount)
+	cfg.QuotaBackendBytes = e.QuotaBackendBytes
+
+	cfg.PreVote = e.PreVote
+	cfg.ExperimentalInitialCorruptCheck = e.InitialCorruptCheck
+
+	cfg.Logger = e.Logger
+	cfg.LogOutput = e.LogOutput
+	cfg.Debug = e.Debug
+
+	return cfg, nil
+}

functional/rpcpb/etcd_config_test.go

@@ -17,13 +17,16 @@ package rpcpb
 import (
 	"reflect"
 	"testing"
+
+	"github.com/coreos/etcd/embed"
+	"github.com/coreos/etcd/pkg/types"
 )
 
-func TestEtcdFlags(t *testing.T) {
-	cfg := &Etcd{
+func TestEtcd(t *testing.T) {
+	e := &Etcd{
 		Name:    "s1",
-		DataDir: "/tmp/etcd-agent-data-1/etcd.data",
-		WALDir:  "/tmp/etcd-agent-data-1/etcd.data/member/wal",
+		DataDir: "/tmp/etcd-functionl-1/etcd.data",
+		WALDir:  "/tmp/etcd-functionl-1/etcd.data/member/wal",
 
 		HeartbeatIntervalMs: 100,
 		ElectionTimeoutMs:   1000,
@@ -53,12 +56,16 @@ func TestEtcdFlags(t *testing.T) {
 
 		PreVote:             true,
 		InitialCorruptCheck: true,
+
+		Logger:    "zap",
+		LogOutput: "/tmp/etcd-functional-1/etcd.log",
+		Debug:     true,
 	}
 
-	exp := []string{
+	exps := []string{
 		"--name=s1",
-		"--data-dir=/tmp/etcd-agent-data-1/etcd.data",
-		"--wal-dir=/tmp/etcd-agent-data-1/etcd.data/member/wal",
+		"--data-dir=/tmp/etcd-functionl-1/etcd.data",
+		"--wal-dir=/tmp/etcd-functionl-1/etcd.data/member/wal",
 		"--heartbeat-interval=100",
 		"--election-timeout=1000",
 		"--listen-client-urls=https://127.0.0.1:1379",
@@ -76,9 +83,63 @@ func TestEtcdFlags(t *testing.T) {
 		"--quota-backend-bytes=10740000000",
 		"--pre-vote=true",
 		"--experimental-initial-corrupt-check=true",
+		"--logger=zap",
+		"--log-output=/tmp/etcd-functional-1/etcd.log",
+		"--debug=true",
+	}
+	fs := e.Flags()
+	if !reflect.DeepEqual(exps, fs) {
+		t.Fatalf("expected %q, got %q", exps, fs)
+	}
+
+	var err error
+	var lcURLs types.URLs
+	lcURLs, err = types.NewURLs([]string{"https://127.0.0.1:1379"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var acURLs types.URLs
+	acURLs, err = types.NewURLs([]string{"https://127.0.0.1:13790"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var lpURLs types.URLs
+	lpURLs, err = types.NewURLs([]string{"https://127.0.0.1:1380"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var apURLs types.URLs
+	apURLs, err = types.NewURLs([]string{"https://127.0.0.1:13800"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	expc := embed.NewConfig()
+	expc.Name = "s1"
+	expc.Dir = "/tmp/etcd-functionl-1/etcd.data"
+	expc.WalDir = "/tmp/etcd-functionl-1/etcd.data/member/wal"
+	expc.TickMs = 100
+	expc.ElectionMs = 1000
+	expc.LCUrls = lcURLs
+	expc.ACUrls = acURLs
+	expc.ClientAutoTLS = true
+	expc.LPUrls = lpURLs
+	expc.APUrls = apURLs
+	expc.PeerAutoTLS = true
+	expc.InitialCluster = "s1=https://127.0.0.1:13800,s2=https://127.0.0.1:23800,s3=https://127.0.0.1:33800"
+	expc.ClusterState = "new"
+	expc.InitialClusterToken = "tkn"
+	expc.SnapCount = 10000
+	expc.QuotaBackendBytes = 10740000000
+	expc.PreVote = true
+	expc.ExperimentalInitialCorruptCheck = true
+	expc.Logger = "zap"
+	expc.LogOutput = "/tmp/etcd-functional-1/etcd.log"
+	expc.Debug = true
+	cfg, err := e.EmbedConfig()
+	if err != nil {
+		t.Fatal(err)
 	}
-	fs := cfg.Flags()
-	if !reflect.DeepEqual(exp, fs) {
-		t.Fatalf("expected %q, got %q", exp, fs)
+	if !reflect.DeepEqual(expc, cfg) {
+		t.Fatalf("expected %+v, got %+v", expc, cfg)
 	}
 }