mirrors/etcd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor: Use proper variable names for urls

Browse Source 
Signed-off-by: Marek Siarkowicz <siarkowicz@google.com>
This commit is contained in:
Marek Siarkowicz
2023-03-10 13:35:18 +01:00
parent fe37277c7e
commit 63576a25f5
12 changed files with 157 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
server/embed/config.go
View File

@ -205,8 +205,8 @@ type Config struct {
// streams that each client can open at a time. // streams that each client can open at a time.
MaxConcurrentStreams uint32 `json:"max-concurrent-streams"` MaxConcurrentStreams uint32 `json:"max-concurrent-streams"`
LPUrls, LCUrls []url.URL ListenPeerUrls, ListenClientUrls []url.URL
APUrls, ACUrls []url.URL AdvertisePeerUrls, AdvertiseClientUrls []url.URL
ClientTLSInfo transport.TLSInfo ClientTLSInfo transport.TLSInfo
ClientAutoTLS bool ClientAutoTLS bool
PeerTLSInfo transport.TLSInfo PeerTLSInfo transport.TLSInfo
@ -423,10 +423,10 @@ type configYAML struct {
// configJSON has file options that are translated into Config options // configJSON has file options that are translated into Config options
type configJSON struct { type configJSON struct {
LPUrlsJSON string `json:"listen-peer-urls"` ListenPeerUrls string `json:"listen-peer-urls"`
LCUrlsJSON string `json:"listen-client-urls"` ListenClientUrls string `json:"listen-client-urls"`
APUrlsJSON string `json:"initial-advertise-peer-urls"` AdvertisePeerUrls string `json:"initial-advertise-peer-urls"`
ACUrlsJSON string `json:"advertise-client-urls"` AdvertiseClientUrls string `json:"advertise-client-urls"`
CORSJSON string `json:"cors"` CORSJSON string `json:"cors"`
HostWhitelistJSON string `json:"host-whitelist"` HostWhitelistJSON string `json:"host-whitelist"`
@ -475,10 +475,10 @@ func NewConfig() *Config {
ElectionMs: 1000, ElectionMs: 1000,
InitialElectionTickAdvance: true, InitialElectionTickAdvance: true,
LPUrls: []url.URL{*lpurl}, ListenPeerUrls: []url.URL{*lpurl},
LCUrls: []url.URL{*lcurl}, ListenClientUrls: []url.URL{*lcurl},
APUrls: []url.URL{*apurl}, AdvertisePeerUrls: []url.URL{*apurl},
ACUrls: []url.URL{*acurl}, AdvertiseClientUrls: []url.URL{*acurl},
ClusterState: ClusterStateFlagNew, ClusterState: ClusterStateFlagNew,
InitialClusterToken: "etcd-cluster", InitialClusterToken: "etcd-cluster",
@ -539,40 +539,40 @@ func (cfg *configYAML) configFromFile(path string) error {
return err return err
} }
if cfg.LPUrlsJSON != "" { if cfg.configJSON.ListenPeerUrls != "" {
u, err := types.NewURLs(strings.Split(cfg.LPUrlsJSON, ",")) u, err := types.NewURLs(strings.Split(cfg.configJSON.ListenPeerUrls, ","))
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "unexpected error setting up listen-peer-urls: %v\n", err) fmt.Fprintf(os.Stderr, "unexpected error setting up listen-peer-urls: %v\n", err)
os.Exit(1) os.Exit(1)
} }
cfg.LPUrls = []url.URL(u) cfg.Config.ListenPeerUrls = u
} }
if cfg.LCUrlsJSON != "" { if cfg.configJSON.ListenClientUrls != "" {
u, err := types.NewURLs(strings.Split(cfg.LCUrlsJSON, ",")) u, err := types.NewURLs(strings.Split(cfg.configJSON.ListenClientUrls, ","))
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "unexpected error setting up listen-client-urls: %v\n", err) fmt.Fprintf(os.Stderr, "unexpected error setting up listen-client-urls: %v\n", err)
os.Exit(1) os.Exit(1)
} }
cfg.LCUrls = []url.URL(u) cfg.Config.ListenClientUrls = u
} }
if cfg.APUrlsJSON != "" { if cfg.configJSON.AdvertisePeerUrls != "" {
u, err := types.NewURLs(strings.Split(cfg.APUrlsJSON, ",")) u, err := types.NewURLs(strings.Split(cfg.configJSON.AdvertisePeerUrls, ","))
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "unexpected error setting up initial-advertise-peer-urls: %v\n", err) fmt.Fprintf(os.Stderr, "unexpected error setting up initial-advertise-peer-urls: %v\n", err)
os.Exit(1) os.Exit(1)
} }
cfg.APUrls = []url.URL(u) cfg.Config.AdvertisePeerUrls = u
} }
if cfg.ACUrlsJSON != "" { if cfg.configJSON.AdvertiseClientUrls != "" {
u, err := types.NewURLs(strings.Split(cfg.ACUrlsJSON, ",")) u, err := types.NewURLs(strings.Split(cfg.configJSON.AdvertiseClientUrls, ","))
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "unexpected error setting up advertise-peer-urls: %v\n", err) fmt.Fprintf(os.Stderr, "unexpected error setting up advertise-peer-urls: %v\n", err)
os.Exit(1) os.Exit(1)
} }
cfg.ACUrls = []url.URL(u) cfg.Config.AdvertiseClientUrls = u
} }
if cfg.ListenMetricsUrlsJSON != "" { if cfg.ListenMetricsUrlsJSON != "" {
@ -650,21 +650,21 @@ func (cfg *Config) Validate() error {
if err := cfg.setupLogging(); err != nil { if err := cfg.setupLogging(); err != nil {
return err return err
} }
if err := checkBindURLs(cfg.LPUrls); err != nil { if err := checkBindURLs(cfg.ListenPeerUrls); err != nil {
return err return err
} }
if err := checkBindURLs(cfg.LCUrls); err != nil { if err := checkBindURLs(cfg.ListenClientUrls); err != nil {
return err return err
} }
if err := checkBindURLs(cfg.ListenMetricsUrls); err != nil { if err := checkBindURLs(cfg.ListenMetricsUrls); err != nil {
return err return err
} }
if err := checkHostURLs(cfg.APUrls); err != nil { if err := checkHostURLs(cfg.AdvertisePeerUrls); err != nil {
addrs := cfg.getAPURLs() addrs := cfg.getAdvertisePeerUrls()
return fmt.Errorf(`--initial-advertise-peer-urls %q must be "host:port" (%v)`, strings.Join(addrs, ","), err) return fmt.Errorf(`--initial-advertise-peer-urls %q must be "host:port" (%v)`, strings.Join(addrs, ","), err)
} }
if err := checkHostURLs(cfg.ACUrls); err != nil { if err := checkHostURLs(cfg.AdvertiseClientUrls); err != nil {
addrs := cfg.getACURLs() addrs := cfg.getAdvertiseClientUrls()
return fmt.Errorf(`--advertise-client-urls %q must be "host:port" (%v)`, strings.Join(addrs, ","), err) return fmt.Errorf(`--advertise-client-urls %q must be "host:port" (%v)`, strings.Join(addrs, ","), err)
} }
// Check if conflicting flags are passed. // Check if conflicting flags are passed.
@ -697,7 +697,7 @@ func (cfg *Config) Validate() error {
} }
// check this last since proxying in etcdmain may make this OK // check this last since proxying in etcdmain may make this OK
if cfg.LCUrls != nil && cfg.ACUrls == nil { if cfg.ListenClientUrls != nil && cfg.AdvertiseClientUrls == nil {
return ErrUnsetAdvertiseClientURLsFlag return ErrUnsetAdvertiseClientURLsFlag
} }
@ -750,7 +750,7 @@ func (cfg *Config) PeerURLsMapAndToken(which string) (urlsmap types.URLsMap, tok
urlsmap = types.URLsMap{} urlsmap = types.URLsMap{}
// If using discovery, generate a temporary cluster based on // If using discovery, generate a temporary cluster based on
// self's advertised peer URLs // self's advertised peer URLs
urlsmap[cfg.Name] = cfg.APUrls urlsmap[cfg.Name] = cfg.AdvertisePeerUrls
token = cfg.Durl token = cfg.Durl
case cfg.DNSCluster != "": case cfg.DNSCluster != "":
@ -804,7 +804,7 @@ func (cfg *Config) GetDNSClusterNames() ([]string, error) {
// Use both etcd-server-ssl and etcd-server for discovery. // Use both etcd-server-ssl and etcd-server for discovery.
// Combine the results if both are available. // Combine the results if both are available.
clusterStrs, cerr = getCluster("https", "etcd-server-ssl"+serviceNameSuffix, cfg.Name, cfg.DNSCluster, cfg.APUrls) clusterStrs, cerr = getCluster("https", "etcd-server-ssl"+serviceNameSuffix, cfg.Name, cfg.DNSCluster, cfg.AdvertisePeerUrls)
if cerr != nil { if cerr != nil {
clusterStrs = make([]string, 0) clusterStrs = make([]string, 0)
} }
@ -814,12 +814,12 @@ func (cfg *Config) GetDNSClusterNames() ([]string, error) {
zap.String("service-name", "etcd-server-ssl"+serviceNameSuffix), zap.String("service-name", "etcd-server-ssl"+serviceNameSuffix),
zap.String("server-name", cfg.Name), zap.String("server-name", cfg.Name),
zap.String("discovery-srv", cfg.DNSCluster), zap.String("discovery-srv", cfg.DNSCluster),
zap.Strings("advertise-peer-urls", cfg.getAPURLs()), zap.Strings("advertise-peer-urls", cfg.getAdvertisePeerUrls()),
zap.Strings("found-cluster", clusterStrs), zap.Strings("found-cluster", clusterStrs),
zap.Error(cerr), zap.Error(cerr),
) )
defaultHTTPClusterStrs, httpCerr := getCluster("http", "etcd-server"+serviceNameSuffix, cfg.Name, cfg.DNSCluster, cfg.APUrls) defaultHTTPClusterStrs, httpCerr := getCluster("http", "etcd-server"+serviceNameSuffix, cfg.Name, cfg.DNSCluster, cfg.AdvertisePeerUrls)
if httpCerr == nil { if httpCerr == nil {
clusterStrs = append(clusterStrs, defaultHTTPClusterStrs...) clusterStrs = append(clusterStrs, defaultHTTPClusterStrs...)
} }
@ -829,7 +829,7 @@ func (cfg *Config) GetDNSClusterNames() ([]string, error) {
zap.String("service-name", "etcd-server"+serviceNameSuffix), zap.String("service-name", "etcd-server"+serviceNameSuffix),
zap.String("server-name", cfg.Name), zap.String("server-name", cfg.Name),
zap.String("discovery-srv", cfg.DNSCluster), zap.String("discovery-srv", cfg.DNSCluster),
zap.Strings("advertise-peer-urls", cfg.getAPURLs()), zap.Strings("advertise-peer-urls", cfg.getAdvertisePeerUrls()),
zap.Strings("found-cluster", clusterStrs), zap.Strings("found-cluster", clusterStrs),
zap.Error(httpCerr), zap.Error(httpCerr),
) )
@ -838,15 +838,15 @@ func (cfg *Config) GetDNSClusterNames() ([]string, error) {
} }
func (cfg Config) InitialClusterFromName(name string) (ret string) { func (cfg Config) InitialClusterFromName(name string) (ret string) {
if len(cfg.APUrls) == 0 { if len(cfg.AdvertisePeerUrls) == 0 {
return "" return ""
} }
n := name n := name
if name == "" { if name == "" {
n = DefaultName n = DefaultName
} }
for i := range cfg.APUrls { for i := range cfg.AdvertisePeerUrls {
ret = ret + "," + n + "=" + cfg.APUrls[i].String() ret = ret + "," + n + "=" + cfg.AdvertisePeerUrls[i].String()
} }
return ret[1:] return ret[1:]
} }
@ -862,11 +862,11 @@ func (cfg Config) V2DeprecationEffective() config.V2DeprecationEnum {
} }
func (cfg Config) defaultPeerHost() bool { func (cfg Config) defaultPeerHost() bool {
return len(cfg.APUrls) == 1 && cfg.APUrls[0].String() == DefaultInitialAdvertisePeerURLs return len(cfg.AdvertisePeerUrls) == 1 && cfg.AdvertisePeerUrls[0].String() == DefaultInitialAdvertisePeerURLs
} }
func (cfg Config) defaultClientHost() bool { func (cfg Config) defaultClientHost() bool {
return len(cfg.ACUrls) == 1 && cfg.ACUrls[0].String() == DefaultAdvertiseClientURLs return len(cfg.AdvertiseClientUrls) == 1 && cfg.AdvertiseClientUrls[0].String() == DefaultAdvertiseClientURLs
} }
func (cfg *Config) ClientSelfCert() (err error) { func (cfg *Config) ClientSelfCert() (err error) {
@ -877,8 +877,8 @@ func (cfg *Config) ClientSelfCert() (err error) {
cfg.logger.Warn("ignoring client auto TLS since certs given") cfg.logger.Warn("ignoring client auto TLS since certs given")
return nil return nil
} }
chosts := make([]string, len(cfg.LCUrls)) chosts := make([]string, len(cfg.ListenClientUrls))
for i, u := range cfg.LCUrls { for i, u := range cfg.ListenClientUrls {
chosts[i] = u.Host chosts[i] = u.Host
} }
cfg.ClientTLSInfo, err = transport.SelfCert(cfg.logger, filepath.Join(cfg.Dir, "fixtures", "client"), chosts, cfg.SelfSignedCertValidity) cfg.ClientTLSInfo, err = transport.SelfCert(cfg.logger, filepath.Join(cfg.Dir, "fixtures", "client"), chosts, cfg.SelfSignedCertValidity)
@ -896,8 +896,8 @@ func (cfg *Config) PeerSelfCert() (err error) {
cfg.logger.Warn("ignoring peer auto TLS since certs given") cfg.logger.Warn("ignoring peer auto TLS since certs given")
return nil return nil
} }
phosts := make([]string, len(cfg.LPUrls)) phosts := make([]string, len(cfg.ListenPeerUrls))
for i, u := range cfg.LPUrls { for i, u := range cfg.ListenPeerUrls {
phosts[i] = u.Host phosts[i] = u.Host
} }
cfg.PeerTLSInfo, err = transport.SelfCert(cfg.logger, filepath.Join(cfg.Dir, "fixtures", "peer"), phosts, cfg.SelfSignedCertValidity) cfg.PeerTLSInfo, err = transport.SelfCert(cfg.logger, filepath.Join(cfg.Dir, "fixtures", "peer"), phosts, cfg.SelfSignedCertValidity)
@ -925,9 +925,9 @@ func (cfg *Config) UpdateDefaultClusterFromName(defaultInitialCluster string) (s
} }
used := false used := false
pip, pport := cfg.LPUrls[0].Hostname(), cfg.LPUrls[0].Port() pip, pport := cfg.ListenPeerUrls[0].Hostname(), cfg.ListenPeerUrls[0].Port()
if cfg.defaultPeerHost() && pip == "0.0.0.0" { if cfg.defaultPeerHost() && pip == "0.0.0.0" {
cfg.APUrls[0] = url.URL{Scheme: cfg.APUrls[0].Scheme, Host: fmt.Sprintf("%s:%s", defaultHostname, pport)} cfg.AdvertisePeerUrls[0] = url.URL{Scheme: cfg.AdvertisePeerUrls[0].Scheme, Host: fmt.Sprintf("%s:%s", defaultHostname, pport)}
used = true used = true
} }
// update 'initial-cluster' when only the name is specified (e.g. 'etcd --name=abc') // update 'initial-cluster' when only the name is specified (e.g. 'etcd --name=abc')
@ -935,9 +935,9 @@ func (cfg *Config) UpdateDefaultClusterFromName(defaultInitialCluster string) (s
cfg.InitialCluster = cfg.InitialClusterFromName(cfg.Name) cfg.InitialCluster = cfg.InitialClusterFromName(cfg.Name)
} }
cip, cport := cfg.LCUrls[0].Hostname(), cfg.LCUrls[0].Port() cip, cport := cfg.ListenClientUrls[0].Hostname(), cfg.ListenClientUrls[0].Port()
if cfg.defaultClientHost() && cip == "0.0.0.0" { if cfg.defaultClientHost() && cip == "0.0.0.0" {
cfg.ACUrls[0] = url.URL{Scheme: cfg.ACUrls[0].Scheme, Host: fmt.Sprintf("%s:%s", defaultHostname, cport)} cfg.AdvertiseClientUrls[0] = url.URL{Scheme: cfg.AdvertiseClientUrls[0].Scheme, Host: fmt.Sprintf("%s:%s", defaultHostname, cport)}
used = true used = true
} }
dhost := defaultHostname dhost := defaultHostname
@ -982,34 +982,34 @@ func checkHostURLs(urls []url.URL) error {
return nil return nil
} }
func (cfg *Config) getAPURLs() (ss []string) { func (cfg *Config) getAdvertisePeerUrls() (ss []string) {
ss = make([]string, len(cfg.APUrls)) ss = make([]string, len(cfg.AdvertisePeerUrls))
for i := range cfg.APUrls { for i := range cfg.AdvertisePeerUrls {
ss[i] = cfg.APUrls[i].String() ss[i] = cfg.AdvertisePeerUrls[i].String()
} }
return ss return ss
} }
func (cfg *Config) getLPURLs() (ss []string) { func (cfg *Config) getListenPeerUrls() (ss []string) {
ss = make([]string, len(cfg.LPUrls)) ss = make([]string, len(cfg.ListenPeerUrls))
for i := range cfg.LPUrls { for i := range cfg.ListenPeerUrls {
ss[i] = cfg.LPUrls[i].String() ss[i] = cfg.ListenPeerUrls[i].String()
} }
return ss return ss
} }
func (cfg *Config) getACURLs() (ss []string) { func (cfg *Config) getAdvertiseClientUrls() (ss []string) {
ss = make([]string, len(cfg.ACUrls)) ss = make([]string, len(cfg.AdvertiseClientUrls))
for i := range cfg.ACUrls { for i := range cfg.AdvertiseClientUrls {
ss[i] = cfg.ACUrls[i].String() ss[i] = cfg.AdvertiseClientUrls[i].String()
} }
return ss return ss
} }
func (cfg *Config) getLCURLs() (ss []string) { func (cfg *Config) getListenClientUrls() (ss []string) {
ss = make([]string, len(cfg.LCUrls)) ss = make([]string, len(cfg.ListenClientUrls))
for i := range cfg.LCUrls { for i := range cfg.ListenClientUrls {
ss[i] = cfg.LCUrls[i].String() ss[i] = cfg.ListenClientUrls[i].String()
} }
return ss return ss
} }

32
server/embed/config_test.go
View File

@ -86,12 +86,12 @@ func TestConfigFileOtherFields(t *testing.T) {
func TestUpdateDefaultClusterFromName(t *testing.T) { func TestUpdateDefaultClusterFromName(t *testing.T) {
cfg := NewConfig() cfg := NewConfig()
defaultInitialCluster := cfg.InitialCluster defaultInitialCluster := cfg.InitialCluster
oldscheme := cfg.APUrls[0].Scheme oldscheme := cfg.AdvertisePeerUrls[0].Scheme
origpeer := cfg.APUrls[0].String() origpeer := cfg.AdvertisePeerUrls[0].String()
origadvc := cfg.ACUrls[0].String() origadvc := cfg.AdvertiseClientUrls[0].String()
cfg.Name = "abc" cfg.Name = "abc"
lpport := cfg.LPUrls[0].Port() lpport := cfg.ListenPeerUrls[0].Port()
// in case of 'etcd --name=abc' // in case of 'etcd --name=abc'
exp := fmt.Sprintf("%s=%s://localhost:%s", cfg.Name, oldscheme, lpport) exp := fmt.Sprintf("%s=%s://localhost:%s", cfg.Name, oldscheme, lpport)
@ -100,12 +100,12 @@ func TestUpdateDefaultClusterFromName(t *testing.T) {
t.Fatalf("initial-cluster expected %q, got %q", exp, cfg.InitialCluster) t.Fatalf("initial-cluster expected %q, got %q", exp, cfg.InitialCluster)
} }
// advertise peer URL should not be affected // advertise peer URL should not be affected
if origpeer != cfg.APUrls[0].String() { if origpeer != cfg.AdvertisePeerUrls[0].String() {
t.Fatalf("advertise peer url expected %q, got %q", origadvc, cfg.APUrls[0].String()) t.Fatalf("advertise peer url expected %q, got %q", origadvc, cfg.AdvertisePeerUrls[0].String())
} }
// advertise client URL should not be affected // advertise client URL should not be affected
if origadvc != cfg.ACUrls[0].String() { if origadvc != cfg.AdvertiseClientUrls[0].String() {
t.Fatalf("advertise client url expected %q, got %q", origadvc, cfg.ACUrls[0].String()) t.Fatalf("advertise client url expected %q, got %q", origadvc, cfg.AdvertiseClientUrls[0].String())
} }
} }
@ -118,17 +118,17 @@ func TestUpdateDefaultClusterFromNameOverwrite(t *testing.T) {
cfg := NewConfig() cfg := NewConfig()
defaultInitialCluster := cfg.InitialCluster defaultInitialCluster := cfg.InitialCluster
oldscheme := cfg.APUrls[0].Scheme oldscheme := cfg.AdvertisePeerUrls[0].Scheme
origadvc := cfg.ACUrls[0].String() origadvc := cfg.AdvertiseClientUrls[0].String()
cfg.Name = "abc" cfg.Name = "abc"
lpport := cfg.LPUrls[0].Port() lpport := cfg.ListenPeerUrls[0].Port()
cfg.LPUrls[0] = url.URL{Scheme: cfg.LPUrls[0].Scheme, Host: fmt.Sprintf("0.0.0.0:%s", lpport)} cfg.ListenPeerUrls[0] = url.URL{Scheme: cfg.ListenPeerUrls[0].Scheme, Host: fmt.Sprintf("0.0.0.0:%s", lpport)}
dhost, _ := cfg.UpdateDefaultClusterFromName(defaultInitialCluster) dhost, _ := cfg.UpdateDefaultClusterFromName(defaultInitialCluster)
if dhost != defaultHostname { if dhost != defaultHostname {
t.Fatalf("expected default host %q, got %q", defaultHostname, dhost) t.Fatalf("expected default host %q, got %q", defaultHostname, dhost)
} }
aphost, apport := cfg.APUrls[0].Hostname(), cfg.APUrls[0].Port() aphost, apport := cfg.AdvertisePeerUrls[0].Hostname(), cfg.AdvertisePeerUrls[0].Port()
if apport != lpport { if apport != lpport {
t.Fatalf("advertise peer url got different port %s, expected %s", apport, lpport) t.Fatalf("advertise peer url got different port %s, expected %s", apport, lpport)
} }
@ -141,8 +141,8 @@ func TestUpdateDefaultClusterFromNameOverwrite(t *testing.T) {
} }
// advertise client URL should not be affected // advertise client URL should not be affected
if origadvc != cfg.ACUrls[0].String() { if origadvc != cfg.AdvertiseClientUrls[0].String() {
t.Fatalf("advertise-client-url expected %q, got %q", origadvc, cfg.ACUrls[0].String()) t.Fatalf("advertise-client-url expected %q, got %q", origadvc, cfg.AdvertiseClientUrls[0].String())
} }
} }
@ -276,7 +276,7 @@ func TestPeerURLsMapAndTokenFromSRV(t *testing.T) {
cfg.InitialCluster = "" cfg.InitialCluster = ""
cfg.InitialClusterToken = "" cfg.InitialClusterToken = ""
cfg.DNSCluster = "example.com" cfg.DNSCluster = "example.com"
cfg.APUrls = types.MustNewURLs(tt.apurls) cfg.AdvertisePeerUrls = types.MustNewURLs(tt.apurls)
if err := cfg.Validate(); err != nil { if err := cfg.Validate(); err != nil {
t.Errorf("#%d: failed to validate test Config: %v", i, err) t.Errorf("#%d: failed to validate test Config: %v", i, err)

36
server/embed/etcd.go
View File

@ -123,7 +123,7 @@ func StartEtcd(inCfg *Config) (e *Etcd, err error) {
} }
e.cfg.logger.Info( e.cfg.logger.Info(
"configuring peer listeners", "configuring peer listeners",
zap.Strings("listen-peer-urls", e.cfg.getLPURLs()), zap.Strings("listen-peer-urls", e.cfg.getListenPeerUrls()),
) )
if e.Peers, err = configurePeerListeners(cfg); err != nil { if e.Peers, err = configurePeerListeners(cfg); err != nil {
return e, err return e, err
@ -131,7 +131,7 @@ func StartEtcd(inCfg *Config) (e *Etcd, err error) {
e.cfg.logger.Info( e.cfg.logger.Info(
"configuring client listeners", "configuring client listeners",
zap.Strings("listen-client-urls", e.cfg.getLCURLs()), zap.Strings("listen-client-urls", e.cfg.getListenClientUrls()),
) )
if e.sctxs, err = configureClientListeners(cfg); err != nil { if e.sctxs, err = configureClientListeners(cfg); err != nil {
return e, err return e, err
@ -167,8 +167,8 @@ func StartEtcd(inCfg *Config) (e *Etcd, err error) {
srvcfg := config.ServerConfig{ srvcfg := config.ServerConfig{
Name: cfg.Name, Name: cfg.Name,
ClientURLs: cfg.ACUrls, ClientURLs: cfg.AdvertiseClientUrls,
PeerURLs: cfg.APUrls, PeerURLs: cfg.AdvertisePeerUrls,
DataDir: cfg.Dir, DataDir: cfg.Dir,
DedicatedWALDir: cfg.WalDir, DedicatedWALDir: cfg.WalDir,
SnapshotCount: cfg.SnapshotCount, SnapshotCount: cfg.SnapshotCount,
@ -275,10 +275,10 @@ func StartEtcd(inCfg *Config) (e *Etcd, err error) {
e.cfg.logger.Info( e.cfg.logger.Info(
"now serving peer/client/metrics", "now serving peer/client/metrics",
zap.String("local-member-id", e.Server.ID().String()), zap.String("local-member-id", e.Server.ID().String()),
zap.Strings("initial-advertise-peer-urls", e.cfg.getAPURLs()), zap.Strings("initial-advertise-peer-urls", e.cfg.getAdvertisePeerUrls()),
zap.Strings("listen-peer-urls", e.cfg.getLPURLs()), zap.Strings("listen-peer-urls", e.cfg.getListenPeerUrls()),
zap.Strings("advertise-client-urls", e.cfg.getACURLs()), zap.Strings("advertise-client-urls", e.cfg.getAdvertiseClientUrls()),
zap.Strings("listen-client-urls", e.cfg.getLCURLs()), zap.Strings("listen-client-urls", e.cfg.getListenClientUrls()),
zap.Strings("listen-metrics-urls", e.cfg.getMetricsURLs()), zap.Strings("listen-metrics-urls", e.cfg.getMetricsURLs()),
) )
serving = true serving = true
@ -326,10 +326,10 @@ func print(lg *zap.Logger, ec Config, sc config.ServerConfig, memberInitialized
zap.Uint("max-wals", sc.MaxWALFiles), zap.Uint("max-wals", sc.MaxWALFiles),
zap.Uint("max-snapshots", sc.MaxSnapFiles), zap.Uint("max-snapshots", sc.MaxSnapFiles),
zap.Uint64("snapshot-catchup-entries", sc.SnapshotCatchUpEntries), zap.Uint64("snapshot-catchup-entries", sc.SnapshotCatchUpEntries),
zap.Strings("initial-advertise-peer-urls", ec.getAPURLs()), zap.Strings("initial-advertise-peer-urls", ec.getAdvertisePeerUrls()),
zap.Strings("listen-peer-urls", ec.getLPURLs()), zap.Strings("listen-peer-urls", ec.getListenPeerUrls()),
zap.Strings("advertise-client-urls", ec.getACURLs()), zap.Strings("advertise-client-urls", ec.getAdvertiseClientUrls()),
zap.Strings("listen-client-urls", ec.getLCURLs()), zap.Strings("listen-client-urls", ec.getListenClientUrls()),
zap.Strings("listen-metrics-urls", ec.getMetricsURLs()), zap.Strings("listen-metrics-urls", ec.getMetricsURLs()),
zap.Strings("cors", cors), zap.Strings("cors", cors),
zap.Strings("host-whitelist", hss), zap.Strings("host-whitelist", hss),
@ -366,8 +366,8 @@ func (e *Etcd) Close() {
fields := []zap.Field{ fields := []zap.Field{
zap.String("name", e.cfg.Name), zap.String("name", e.cfg.Name),
zap.String("data-dir", e.cfg.Dir), zap.String("data-dir", e.cfg.Dir),
zap.Strings("advertise-peer-urls", e.cfg.getAPURLs()), zap.Strings("advertise-peer-urls", e.cfg.getAdvertisePeerUrls()),
zap.Strings("advertise-client-urls", e.cfg.getACURLs()), zap.Strings("advertise-client-urls", e.cfg.getAdvertiseClientUrls()),
} }
lg := e.GetLogger() lg := e.GetLogger()
lg.Info("closing etcd server", fields...) lg.Info("closing etcd server", fields...)
@ -491,7 +491,7 @@ func configurePeerListeners(cfg *Config) (peers []*peerListener, err error) {
) )
} }
peers = make([]*peerListener, len(cfg.LPUrls)) peers = make([]*peerListener, len(cfg.ListenPeerUrls))
defer func() { defer func() {
if err == nil { if err == nil {
return return
@ -500,7 +500,7 @@ func configurePeerListeners(cfg *Config) (peers []*peerListener, err error) {
if peers[i] != nil && peers[i].close != nil { if peers[i] != nil && peers[i].close != nil {
cfg.logger.Warn( cfg.logger.Warn(
"closing peer listener", "closing peer listener",
zap.String("address", cfg.LPUrls[i].String()), zap.String("address", cfg.ListenPeerUrls[i].String()),
zap.Error(err), zap.Error(err),
) )
ctx, cancel := context.WithTimeout(context.Background(), time.Second) ctx, cancel := context.WithTimeout(context.Background(), time.Second)
@ -510,7 +510,7 @@ func configurePeerListeners(cfg *Config) (peers []*peerListener, err error) {
} }
}() }()
for i, u := range cfg.LPUrls { for i, u := range cfg.ListenPeerUrls {
if u.Scheme == "http" { if u.Scheme == "http" {
if !cfg.PeerTLSInfo.Empty() { if !cfg.PeerTLSInfo.Empty() {
cfg.logger.Warn("scheme is HTTP while key and cert files are present; ignoring key and cert files", zap.String("peer-url", u.String())) cfg.logger.Warn("scheme is HTTP while key and cert files are present; ignoring key and cert files", zap.String("peer-url", u.String()))
@ -611,7 +611,7 @@ func configureClientListeners(cfg *Config) (sctxs map[string]*serveCtx, err erro
} }
sctxs = make(map[string]*serveCtx) sctxs = make(map[string]*serveCtx)
for _, u := range cfg.LCUrls { for _, u := range cfg.ListenClientUrls {
sctx := newServeCtx(cfg.logger) sctx := newServeCtx(cfg.logger)
if u.Scheme == "http" || u.Scheme == "unix" { if u.Scheme == "http" || u.Scheme == "unix" {
if !cfg.ClientTLSInfo.Empty() { if !cfg.ClientTLSInfo.Empty() {

4
server/embed/serve_test.go
View File

@ -38,8 +38,8 @@ func TestStartEtcdWrongToken(t *testing.T) {
urls := newEmbedURLs(2) urls := newEmbedURLs(2)
curls := []url.URL{urls[0]} curls := []url.URL{urls[0]}
purls := []url.URL{urls[1]} purls := []url.URL{urls[1]}
cfg.LCUrls, cfg.ACUrls = curls, curls cfg.ListenClientUrls, cfg.AdvertiseClientUrls = curls, curls
cfg.LPUrls, cfg.APUrls = purls, purls cfg.ListenPeerUrls, cfg.AdvertisePeerUrls = purls, purls
cfg.InitialCluster = "" cfg.InitialCluster = ""
for i := range purls { for i := range purls {
cfg.InitialCluster += ",default=" + purls[i].String() cfg.InitialCluster += ",default=" + purls[i].String()

10
server/etcdmain/config.go
View File

@ -392,10 +392,10 @@ func (cfg *config) configFromCmdLine() error {
lg.Info(fmt.Sprintf("raft-write-timeout increased to minimum value: %v", rafthttp.DefaultConnWriteTimeout)) lg.Info(fmt.Sprintf("raft-write-timeout increased to minimum value: %v", rafthttp.DefaultConnWriteTimeout))
} }
cfg.ec.LPUrls = flags.UniqueURLsFromFlag(cfg.cf.flagSet, "listen-peer-urls") cfg.ec.ListenPeerUrls = flags.UniqueURLsFromFlag(cfg.cf.flagSet, "listen-peer-urls")
cfg.ec.APUrls = flags.UniqueURLsFromFlag(cfg.cf.flagSet, "initial-advertise-peer-urls") cfg.ec.AdvertisePeerUrls = flags.UniqueURLsFromFlag(cfg.cf.flagSet, "initial-advertise-peer-urls")
cfg.ec.LCUrls = flags.UniqueURLsFromFlag(cfg.cf.flagSet, "listen-client-urls") cfg.ec.ListenClientUrls = flags.UniqueURLsFromFlag(cfg.cf.flagSet, "listen-client-urls")
cfg.ec.ACUrls = flags.UniqueURLsFromFlag(cfg.cf.flagSet, "advertise-client-urls") cfg.ec.AdvertiseClientUrls = flags.UniqueURLsFromFlag(cfg.cf.flagSet, "advertise-client-urls")
cfg.ec.ListenMetricsUrls = flags.UniqueURLsFromFlag(cfg.cf.flagSet, "listen-metrics-urls") cfg.ec.ListenMetricsUrls = flags.UniqueURLsFromFlag(cfg.cf.flagSet, "listen-metrics-urls")
cfg.ec.CORS = flags.UniqueURLsMapFromFlag(cfg.cf.flagSet, "cors") cfg.ec.CORS = flags.UniqueURLsMapFromFlag(cfg.cf.flagSet, "cors")
@ -416,7 +416,7 @@ func (cfg *config) configFromCmdLine() error {
// disable default advertise-client-urls if lcurls is set // disable default advertise-client-urls if lcurls is set
missingAC := flags.IsSet(cfg.cf.flagSet, "listen-client-urls") && !flags.IsSet(cfg.cf.flagSet, "advertise-client-urls") missingAC := flags.IsSet(cfg.cf.flagSet, "listen-client-urls") && !flags.IsSet(cfg.cf.flagSet, "advertise-client-urls")
if !cfg.mayBeProxy() && missingAC { if !cfg.mayBeProxy() && missingAC {
cfg.ec.ACUrls = nil cfg.ec.AdvertiseClientUrls = nil
} }
// disable default initial-cluster if discovery is set // disable default initial-cluster if discovery is set

30
server/etcdmain/config_test.go
View File

@ -56,9 +56,9 @@ func TestConfigFileMemberFields(t *testing.T) {
MaxWalFiles uint `json:"max-wals"` MaxWalFiles uint `json:"max-wals"`
Name string `json:"name"` Name string `json:"name"`
SnapshotCount uint64 `json:"snapshot-count"` SnapshotCount uint64 `json:"snapshot-count"`
LPUrls string `json:"listen-peer-urls"` ListenPeerUrls string `json:"listen-peer-urls"`
LCUrls string `json:"listen-client-urls"` ListenClientUrls string `json:"listen-client-urls"`
AcurlsCfgFile string `json:"advertise-client-urls"` AdvertiseClientUrls string `json:"advertise-client-urls"`
}{ }{
"testdir", "testdir",
10, 10,
@ -514,8 +514,8 @@ func mustCreateCfgFile(t *testing.T, b []byte) *os.File {
func validateMemberFlags(t *testing.T, cfg *config) { func validateMemberFlags(t *testing.T, cfg *config) {
wcfg := &embed.Config{ wcfg := &embed.Config{
Dir: "testdir", Dir: "testdir",
LPUrls: []url.URL{{Scheme: "http", Host: "localhost:8000"}, {Scheme: "https", Host: "localhost:8001"}}, ListenPeerUrls: []url.URL{{Scheme: "http", Host: "localhost:8000"}, {Scheme: "https", Host: "localhost:8001"}},
LCUrls: []url.URL{{Scheme: "http", Host: "localhost:7000"}, {Scheme: "https", Host: "localhost:7001"}}, ListenClientUrls: []url.URL{{Scheme: "http", Host: "localhost:7000"}, {Scheme: "https", Host: "localhost:7001"}},
MaxSnapFiles: 10, MaxSnapFiles: 10,
MaxWalFiles: 10, MaxWalFiles: 10,
Name: "testname", Name: "testname",
@ -537,18 +537,18 @@ func validateMemberFlags(t *testing.T, cfg *config) {
if cfg.ec.SnapshotCount != wcfg.SnapshotCount { if cfg.ec.SnapshotCount != wcfg.SnapshotCount {
t.Errorf("snapcount = %v, want %v", cfg.ec.SnapshotCount, wcfg.SnapshotCount) t.Errorf("snapcount = %v, want %v", cfg.ec.SnapshotCount, wcfg.SnapshotCount)
} }
if !reflect.DeepEqual(cfg.ec.LPUrls, wcfg.LPUrls) { if !reflect.DeepEqual(cfg.ec.ListenPeerUrls, wcfg.ListenPeerUrls) {
t.Errorf("listen-peer-urls = %v, want %v", cfg.ec.LPUrls, wcfg.LPUrls) t.Errorf("listen-peer-urls = %v, want %v", cfg.ec.ListenPeerUrls, wcfg.ListenPeerUrls)
} }
if !reflect.DeepEqual(cfg.ec.LCUrls, wcfg.LCUrls) { if !reflect.DeepEqual(cfg.ec.ListenClientUrls, wcfg.ListenClientUrls) {
t.Errorf("listen-client-urls = %v, want %v", cfg.ec.LCUrls, wcfg.LCUrls) t.Errorf("listen-client-urls = %v, want %v", cfg.ec.ListenClientUrls, wcfg.ListenClientUrls)
} }
} }
func validateClusteringFlags(t *testing.T, cfg *config) { func validateClusteringFlags(t *testing.T, cfg *config) {
wcfg := newConfig() wcfg := newConfig()
wcfg.ec.APUrls = []url.URL{{Scheme: "http", Host: "localhost:8000"}, {Scheme: "https", Host: "localhost:8001"}} wcfg.ec.AdvertisePeerUrls = []url.URL{{Scheme: "http", Host: "localhost:8000"}, {Scheme: "https", Host: "localhost:8001"}}
wcfg.ec.ACUrls = []url.URL{{Scheme: "http", Host: "localhost:7000"}, {Scheme: "https", Host: "localhost:7001"}} wcfg.ec.AdvertiseClientUrls = []url.URL{{Scheme: "http", Host: "localhost:7000"}, {Scheme: "https", Host: "localhost:7001"}}
wcfg.ec.ClusterState = embed.ClusterStateFlagExisting wcfg.ec.ClusterState = embed.ClusterStateFlagExisting
wcfg.cf.fallback.Set(fallbackFlagExit) wcfg.cf.fallback.Set(fallbackFlagExit)
wcfg.ec.InitialCluster = "0=http://localhost:8000" wcfg.ec.InitialCluster = "0=http://localhost:8000"
@ -566,11 +566,11 @@ func validateClusteringFlags(t *testing.T, cfg *config) {
if cfg.ec.InitialClusterToken != wcfg.ec.InitialClusterToken { if cfg.ec.InitialClusterToken != wcfg.ec.InitialClusterToken {
t.Errorf("initialClusterToken = %v, want %v", cfg.ec.InitialClusterToken, wcfg.ec.InitialClusterToken) t.Errorf("initialClusterToken = %v, want %v", cfg.ec.InitialClusterToken, wcfg.ec.InitialClusterToken)
} }
if !reflect.DeepEqual(cfg.ec.APUrls, wcfg.ec.APUrls) { if !reflect.DeepEqual(cfg.ec.AdvertisePeerUrls, wcfg.ec.AdvertisePeerUrls) {
t.Errorf("initial-advertise-peer-urls = %v, want %v", cfg.ec.APUrls, wcfg.ec.APUrls) t.Errorf("initial-advertise-peer-urls = %v, want %v", cfg.ec.AdvertisePeerUrls, wcfg.ec.AdvertisePeerUrls)
} }
if !reflect.DeepEqual(cfg.ec.ACUrls, wcfg.ec.ACUrls) { if !reflect.DeepEqual(cfg.ec.AdvertiseClientUrls, wcfg.ec.AdvertiseClientUrls) {
t.Errorf("advertise-client-urls = %v, want %v", cfg.ec.ACUrls, wcfg.ec.ACUrls) t.Errorf("advertise-client-urls = %v, want %v", cfg.ec.AdvertiseClientUrls, wcfg.ec.AdvertiseClientUrls)
} }
} }

8
server/etcdmain/etcd.go
View File

@ -193,7 +193,7 @@ func startEtcdOrProxyV2(args []string) {
if cfg.ec.InitialCluster == cfg.ec.InitialClusterFromName(cfg.ec.Name) { if cfg.ec.InitialCluster == cfg.ec.InitialClusterFromName(cfg.ec.Name) {
lg.Warn("forgot to set --initial-cluster?") lg.Warn("forgot to set --initial-cluster?")
} }
if types.URLs(cfg.ec.APUrls).String() == embed.DefaultInitialAdvertisePeerURLs { if types.URLs(cfg.ec.AdvertisePeerUrls).String() == embed.DefaultInitialAdvertisePeerURLs {
lg.Warn("forgot to set --initial-advertise-peer-urls?") lg.Warn("forgot to set --initial-advertise-peer-urls?")
} }
if cfg.ec.InitialCluster == cfg.ec.InitialClusterFromName(cfg.ec.Name) && len(cfg.ec.Durl) == 0 { if cfg.ec.InitialCluster == cfg.ec.InitialClusterFromName(cfg.ec.Name) && len(cfg.ec.Durl) == 0 {
@ -389,11 +389,11 @@ func startProxy(cfg *config) error {
// setup self signed certs when serving https // setup self signed certs when serving https
cHosts, cTLS := []string{}, false cHosts, cTLS := []string{}, false
for _, u := range cfg.ec.LCUrls { for _, u := range cfg.ec.ListenClientUrls {
cHosts = append(cHosts, u.Host) cHosts = append(cHosts, u.Host)
cTLS = cTLS || u.Scheme == "https" cTLS = cTLS || u.Scheme == "https"
} }
for _, u := range cfg.ec.ACUrls { for _, u := range cfg.ec.AdvertiseClientUrls {
cHosts = append(cHosts, u.Host) cHosts = append(cHosts, u.Host)
cTLS = cTLS || u.Scheme == "https" cTLS = cTLS || u.Scheme == "https"
} }
@ -406,7 +406,7 @@ func startProxy(cfg *config) error {
} }
// Start a proxy server goroutine for each listen address // Start a proxy server goroutine for each listen address
for _, u := range cfg.ec.LCUrls { for _, u := range cfg.ec.ListenClientUrls {
l, err := transport.NewListener(u.Host, u.Scheme, &listenerTLS) l, err := transport.NewListener(u.Host, u.Scheme, &listenerTLS)
if err != nil { if err != nil {
return err return err

6
tests/integration/clientv3/snapshot/v3_snapshot_test.go
View File

@ -66,8 +66,8 @@ func createSnapshotFile(t *testing.T, kvs []kv) string {
cfg := integration.NewEmbedConfig(t, "default") cfg := integration.NewEmbedConfig(t, "default")
cfg.ClusterState = "new" cfg.ClusterState = "new"
cfg.LCUrls, cfg.ACUrls = cURLs, cURLs cfg.ListenClientUrls, cfg.AdvertiseClientUrls = cURLs, cURLs
cfg.LPUrls, cfg.APUrls = pURLs, pURLs cfg.ListenPeerUrls, cfg.AdvertisePeerUrls = pURLs, pURLs
cfg.InitialCluster = fmt.Sprintf("%s=%s", cfg.Name, pURLs[0].String()) cfg.InitialCluster = fmt.Sprintf("%s=%s", cfg.Name, pURLs[0].String())
srv, err := embed.StartEtcd(cfg) srv, err := embed.StartEtcd(cfg)
if err != nil { if err != nil {
@ -82,7 +82,7 @@ func createSnapshotFile(t *testing.T, kvs []kv) string {
t.Fatalf("failed to start embed.Etcd for creating snapshots") t.Fatalf("failed to start embed.Etcd for creating snapshots")
} }
ccfg := clientv3.Config{Endpoints: []string{cfg.ACUrls[0].String()}} ccfg := clientv3.Config{Endpoints: []string{cfg.AdvertiseClientUrls[0].String()}}
cli, err := integration.NewClient(t, ccfg) cli, err := integration.NewClient(t, ccfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)

10
tests/integration/embed/embed_test.go
View File

@ -78,7 +78,7 @@ func TestEmbedEtcd(t *testing.T) {
tests[0].cfg.Durl = "abc" tests[0].cfg.Durl = "abc"
setupEmbedCfg(&tests[1].cfg, []url.URL{urls[0]}, []url.URL{urls[1]}) setupEmbedCfg(&tests[1].cfg, []url.URL{urls[0]}, []url.URL{urls[1]})
tests[1].cfg.ACUrls = nil tests[1].cfg.AdvertiseClientUrls = nil
tests[2].cfg.TickMs = tests[2].cfg.ElectionMs - 1 tests[2].cfg.TickMs = tests[2].cfg.ElectionMs - 1
tests[3].cfg.ElectionMs = 999999 tests[3].cfg.ElectionMs = 999999
setupEmbedCfg(&tests[4].cfg, []url.URL{urls[2]}, []url.URL{urls[3]}) setupEmbedCfg(&tests[4].cfg, []url.URL{urls[2]}, []url.URL{urls[3]})
@ -86,8 +86,8 @@ func TestEmbedEtcd(t *testing.T) {
setupEmbedCfg(&tests[6].cfg, []url.URL{urls[7], urls[8]}, []url.URL{urls[9]}) setupEmbedCfg(&tests[6].cfg, []url.URL{urls[7], urls[8]}, []url.URL{urls[9]})
dnsURL, _ := url.Parse("http://whatever.test:12345") dnsURL, _ := url.Parse("http://whatever.test:12345")
tests[7].cfg.LCUrls = []url.URL{*dnsURL} tests[7].cfg.ListenClientUrls = []url.URL{*dnsURL}
tests[8].cfg.LPUrls = []url.URL{*dnsURL} tests[8].cfg.ListenPeerUrls = []url.URL{*dnsURL}
dir := filepath.Join(t.TempDir(), fmt.Sprintf("embed-etcd")) dir := filepath.Join(t.TempDir(), fmt.Sprintf("embed-etcd"))
@ -202,8 +202,8 @@ func setupEmbedCfg(cfg *embed.Config, curls []url.URL, purls []url.URL) {
cfg.LogOutputs = []string{"/dev/null"} cfg.LogOutputs = []string{"/dev/null"}
cfg.ClusterState = "new" cfg.ClusterState = "new"
cfg.LCUrls, cfg.ACUrls = curls, curls cfg.ListenClientUrls, cfg.AdvertiseClientUrls = curls, curls
cfg.LPUrls, cfg.APUrls = purls, purls cfg.ListenPeerUrls, cfg.AdvertisePeerUrls = purls, purls
cfg.InitialCluster = "" cfg.InitialCluster = ""
for i := range purls { for i := range purls {
cfg.InitialCluster += ",default=" + purls[i].String() cfg.InitialCluster += ",default=" + purls[i].String()

4
tests/integration/snapshot/member_test.go
View File

@ -66,8 +66,8 @@ func TestSnapshotV3RestoreMultiMemberAdd(t *testing.T) {
cfg := integration.NewEmbedConfig(t, "3") cfg := integration.NewEmbedConfig(t, "3")
cfg.InitialClusterToken = testClusterTkn cfg.InitialClusterToken = testClusterTkn
cfg.ClusterState = "existing" cfg.ClusterState = "existing"
cfg.LCUrls, cfg.ACUrls = newCURLs, newCURLs cfg.ListenClientUrls, cfg.AdvertiseClientUrls = newCURLs, newCURLs
cfg.LPUrls, cfg.APUrls = newPURLs, newPURLs cfg.ListenPeerUrls, cfg.AdvertisePeerUrls = newPURLs, newPURLs
cfg.InitialCluster = "" cfg.InitialCluster = ""
for i := 0; i < clusterN; i++ { for i := 0; i < clusterN; i++ {
cfg.InitialCluster += fmt.Sprintf(",%d=%s", i, pURLs[i].String()) cfg.InitialCluster += fmt.Sprintf(",%d=%s", i, pURLs[i].String())

16
tests/integration/snapshot/v3_snapshot_test.go
View File

@ -48,8 +48,8 @@ func TestSnapshotV3RestoreSingle(t *testing.T) {
cfg := integration.NewEmbedConfig(t, "s1") cfg := integration.NewEmbedConfig(t, "s1")
cfg.InitialClusterToken = testClusterTkn cfg.InitialClusterToken = testClusterTkn
cfg.ClusterState = "existing" cfg.ClusterState = "existing"
cfg.LCUrls, cfg.ACUrls = cURLs, cURLs cfg.ListenClientUrls, cfg.AdvertiseClientUrls = cURLs, cURLs
cfg.LPUrls, cfg.APUrls = pURLs, pURLs cfg.ListenPeerUrls, cfg.AdvertisePeerUrls = pURLs, pURLs
cfg.InitialCluster = fmt.Sprintf("%s=%s", cfg.Name, pURLs[0].String()) cfg.InitialCluster = fmt.Sprintf("%s=%s", cfg.Name, pURLs[0].String())
sp := snapshot.NewV3(zaptest.NewLogger(t)) sp := snapshot.NewV3(zaptest.NewLogger(t))
@ -82,7 +82,7 @@ func TestSnapshotV3RestoreSingle(t *testing.T) {
} }
var cli *clientv3.Client var cli *clientv3.Client
cli, err = integration.NewClient(t, clientv3.Config{Endpoints: []string{cfg.ACUrls[0].String()}}) cli, err = integration.NewClient(t, clientv3.Config{Endpoints: []string{cfg.AdvertiseClientUrls[0].String()}})
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -177,8 +177,8 @@ func createSnapshotFile(t *testing.T, kvs []kv) string {
cfg := integration.NewEmbedConfig(t, "default") cfg := integration.NewEmbedConfig(t, "default")
cfg.ClusterState = "new" cfg.ClusterState = "new"
cfg.LCUrls, cfg.ACUrls = cURLs, cURLs cfg.ListenClientUrls, cfg.AdvertiseClientUrls = cURLs, cURLs
cfg.LPUrls, cfg.APUrls = pURLs, pURLs cfg.ListenPeerUrls, cfg.AdvertisePeerUrls = pURLs, pURLs
cfg.InitialCluster = fmt.Sprintf("%s=%s", cfg.Name, pURLs[0].String()) cfg.InitialCluster = fmt.Sprintf("%s=%s", cfg.Name, pURLs[0].String())
srv, err := embed.StartEtcd(cfg) srv, err := embed.StartEtcd(cfg)
if err != nil { if err != nil {
@ -193,7 +193,7 @@ func createSnapshotFile(t *testing.T, kvs []kv) string {
t.Fatalf("failed to start embed.Etcd for creating snapshots") t.Fatalf("failed to start embed.Etcd for creating snapshots")
} }
ccfg := clientv3.Config{Endpoints: []string{cfg.ACUrls[0].String()}} ccfg := clientv3.Config{Endpoints: []string{cfg.AdvertiseClientUrls[0].String()}}
cli, err := integration.NewClient(t, ccfg) cli, err := integration.NewClient(t, ccfg)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
@ -237,8 +237,8 @@ func restoreCluster(t *testing.T, clusterN int, dbPath string) (
cfg := integration.NewEmbedConfig(t, fmt.Sprintf("m%d", i)) cfg := integration.NewEmbedConfig(t, fmt.Sprintf("m%d", i))
cfg.InitialClusterToken = testClusterTkn cfg.InitialClusterToken = testClusterTkn
cfg.ClusterState = "existing" cfg.ClusterState = "existing"
cfg.LCUrls, cfg.ACUrls = []url.URL{cURLs[i]}, []url.URL{cURLs[i]} cfg.ListenClientUrls, cfg.AdvertiseClientUrls = []url.URL{cURLs[i]}, []url.URL{cURLs[i]}
cfg.LPUrls, cfg.APUrls = []url.URL{pURLs[i]}, []url.URL{pURLs[i]} cfg.ListenPeerUrls, cfg.AdvertisePeerUrls = []url.URL{pURLs[i]}, []url.URL{pURLs[i]}
cfg.InitialCluster = ics cfg.InitialCluster = ics
sp := snapshot.NewV3( sp := snapshot.NewV3(

4
tools/etcd-dump-metrics/etcd.go
View File

@ -51,8 +51,8 @@ func setupEmbedCfg(cfg *embed.Config, curls, purls, ics []url.URL) {
os.RemoveAll(cfg.Dir) os.RemoveAll(cfg.Dir)
cfg.ClusterState = "new" cfg.ClusterState = "new"
cfg.LCUrls, cfg.ACUrls = curls, curls cfg.ListenClientUrls, cfg.AdvertiseClientUrls = curls, curls
cfg.LPUrls, cfg.APUrls = purls, purls cfg.ListenPeerUrls, cfg.AdvertisePeerUrls = purls, purls
cfg.InitialCluster = "" cfg.InitialCluster = ""
for i := range ics { for i := range ics {