Mirroristas/etcd
2
0
Fork 0
mirror of https://github.com/etcd-io/etcd.git synced 2024-09-27 06:25:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

functional: remove "embed" support in tests

Browse Source 
Signed-off-by: Gyuho Lee <leegyuho@amazon.com>
This commit is contained in:
Gyuho Lee 2019-08-02 15:56:52 -07:00
parent 7fbbb9c8bf
commit 189071dcd4
3 changed files with 17 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
functional/agent/handler.go
View File

@ -25,7 +25,6 @@ import (
"syscall"
"time"
"go.etcd.io/etcd/embed"
"go.etcd.io/etcd/functional/rpcpb"
"go.etcd.io/etcd/pkg/fileutil"
"go.etcd.io/etcd/pkg/proxy"
@ -97,42 +96,26 @@ func (srv *Server) createEtcdLogFile() error {
}
func (srv *Server) creatEtcd(fromSnapshot bool) error {
if !fileutil.Exist(srv.Member.EtcdExec) && srv.Member.EtcdExec != "embed" {
return fmt.Errorf("unknown etcd exec %q or path does not exist", srv.Member.EtcdExec)
if !fileutil.Exist(srv.Member.EtcdExec) {
return fmt.Errorf("unknown etcd exec path %q does not exist", srv.Member.EtcdExec)
}
if srv.Member.EtcdExec != "embed" {
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", etcdPath),
zap.Strings("etcd-flags", etcdFlags),
zap.String("failpoint-http-addr", srv.Member.FailpointHTTPAddr),
zap.String("failpoint-addr", u.Host),
)
srv.etcdCmd = exec.Command(etcdPath, etcdFlags...)
srv.etcdCmd.Env = []string{"GOFAIL_HTTP=" + u.Host}
srv.etcdCmd.Stdout = srv.etcdLogFile
srv.etcdCmd.Stderr = srv.etcdLogFile
return nil
etcdPath, etcdFlags := srv.Member.EtcdExec, srv.Member.Etcd.Flags()
if fromSnapshot {
etcdFlags = srv.Member.EtcdOnSnapshotRestore.Flags()
}
cfg, err := srv.Member.Etcd.EmbedConfig()
if err != nil {
return err
}
srv.lg.Info("starting embedded etcd", zap.String("name", cfg.Name))
srv.etcdServer, err = embed.StartEtcd(cfg)
if err != nil {
return err
}
srv.lg.Info("started embedded etcd", zap.String("name", cfg.Name))
u, _ := url.Parse(srv.Member.FailpointHTTPAddr)
srv.lg.Info(
"creating etcd command",
zap.String("etcd-exec", etcdPath),
zap.Strings("etcd-flags", etcdFlags),
zap.String("failpoint-http-addr", srv.Member.FailpointHTTPAddr),
zap.String("failpoint-addr", u.Host),
)
srv.etcdCmd = exec.Command(etcdPath, etcdFlags...)
srv.etcdCmd.Env = []string{"GOFAIL_HTTP=" + u.Host}
srv.etcdCmd.Stdout = srv.etcdLogFile
srv.etcdCmd.Stderr = srv.etcdLogFile
return nil
}

71
functional/rpcpb/etcd_config.go
View File

@ -18,10 +18,6 @@ import (
"fmt"
"reflect"
"strings"
"go.etcd.io/etcd/embed"
"go.etcd.io/etcd/pkg/transport"
"go.etcd.io/etcd/pkg/types"
)
var etcdFields = []string{
@ -105,70 +101,3 @@ func (e *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.SnapshotCount = uint64(e.SnapshotCount)
cfg.QuotaBackendBytes = e.QuotaBackendBytes
cfg.PreVote = e.PreVote
cfg.ExperimentalInitialCorruptCheck = e.InitialCorruptCheck
cfg.Logger = e.Logger
cfg.LogOutputs = e.LogOutputs
cfg.LogLevel = e.LogLevel
return cfg, nil
}

54
functional/rpcpb/etcd_config_test.go
View File

@ -17,9 +17,6 @@ package rpcpb
import (
"reflect"
"testing"
"go.etcd.io/etcd/embed"
"go.etcd.io/etcd/pkg/types"
)
func TestEtcd(t *testing.T) {
@ -91,55 +88,4 @@ func TestEtcd(t *testing.T) {
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.SnapshotCount = 10000
expc.QuotaBackendBytes = 10740000000
expc.PreVote = true
expc.ExperimentalInitialCorruptCheck = true
expc.Logger = "zap"
expc.LogOutputs = []string{"/tmp/etcd-functional-1/etcd.log"}
expc.LogLevel = "info"
cfg, err := e.EmbedConfig()
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(expc, cfg) {
t.Fatalf("expected %+v, got %+v", expc, cfg)
}
}