*: remove old flag support

These legacy flags support are here only because we do not want
CoreOS updates to break people.

Now people will be aware of that they switch to etcd3. Do not need
to support 0.x flags any more.

etcdmain/config.go

@@ -258,14 +258,6 @@ func NewConfig() *config {
 
 	fs.IntVar(&cfg.autoCompactionRetention, "auto-compaction-retention", 0, "Auto compaction retention for mvcc key value store in hour. 0 means disable auto compaction.")
 
-	// backwards-compatibility with v0.4.6
-	fs.Var(&flags.IPAddressPort{}, "addr", "DEPRECATED: Use --advertise-client-urls instead.")
-	fs.Var(&flags.IPAddressPort{}, "bind-addr", "DEPRECATED: Use --listen-client-urls instead.")
-	fs.Var(&flags.IPAddressPort{}, "peer-addr", "DEPRECATED: Use --initial-advertise-peer-urls instead.")
-	fs.Var(&flags.IPAddressPort{}, "peer-bind-addr", "DEPRECATED: Use --listen-peer-urls instead.")
-	fs.Var(&flags.DeprecatedFlag{Name: "peers"}, "peers", "DEPRECATED: Use --initial-cluster instead.")
-	fs.Var(&flags.DeprecatedFlag{Name: "peers-file"}, "peers-file", "DEPRECATED: Use --initial-cluster instead.")
-
 	// pprof profiler via HTTP
 	fs.BoolVar(&cfg.enablePprof, "enable-pprof", false, "Enable runtime profiling data via HTTP server. Address is at client URL + \"/debug/pprof\"")
 
@@ -315,25 +307,10 @@ func (cfg *config) configFromCmdLine() error {
 		plog.Fatalf("%v", err)
 	}
 
-	flags.SetBindAddrFromAddr(cfg.FlagSet, "peer-bind-addr", "peer-addr")
-	flags.SetBindAddrFromAddr(cfg.FlagSet, "bind-addr", "addr")
-
-	cfg.lpurls, err = flags.URLsFromFlags(cfg.FlagSet, "listen-peer-urls", "peer-bind-addr", cfg.peerTLSInfo)
-	if err != nil {
-		return err
-	}
-	cfg.apurls, err = flags.URLsFromFlags(cfg.FlagSet, "initial-advertise-peer-urls", "peer-addr", cfg.peerTLSInfo)
-	if err != nil {
-		return err
-	}
-	cfg.lcurls, err = flags.URLsFromFlags(cfg.FlagSet, "listen-client-urls", "bind-addr", cfg.clientTLSInfo)
-	if err != nil {
-		return err
-	}
-	cfg.acurls, err = flags.URLsFromFlags(cfg.FlagSet, "advertise-client-urls", "addr", cfg.clientTLSInfo)
-	if err != nil {
-		return err
-	}
+	cfg.lpurls = flags.URLsFromFlag(cfg.FlagSet, "listen-peer-urls")
+	cfg.apurls = flags.URLsFromFlag(cfg.FlagSet, "initial-advertise-peer-urls")
+	cfg.lcurls = flags.URLsFromFlag(cfg.FlagSet, "listen-client-urls")
+	cfg.acurls = flags.URLsFromFlag(cfg.FlagSet, "advertise-client-urls")
 
 	return cfg.validateConfig(func(field string) bool {
 		return flags.IsSet(cfg.FlagSet, field)

etcdmain/config_test.go

@@ -209,35 +209,6 @@ func TestConfigFileOtherFields(t *testing.T) {
 	validateOtherFlags(t, cfg)
 }
 
-func TestConfigParsingV1Flags(t *testing.T) {
-	args := []string{
-		"-peer-addr=127.0.0.1:2380",
-		"-addr=127.0.0.1:2379",
-	}
-	wcfg := NewConfig()
-	wcfg.lpurls = []url.URL{{Scheme: "http", Host: "[::]:2380"}}
-	wcfg.apurls = []url.URL{{Scheme: "http", Host: "127.0.0.1:2380"}}
-	wcfg.lcurls = []url.URL{{Scheme: "http", Host: "[::]:2379"}}
-	wcfg.acurls = []url.URL{{Scheme: "http", Host: "127.0.0.1:2379"}}
-
-	cfg := NewConfig()
-	if err := cfg.Parse(args); err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(cfg.lpurls, wcfg.lpurls) {
-		t.Errorf("listen peer urls = %+v, want %+v", cfg.lpurls, wcfg.lpurls)
-	}
-	if !reflect.DeepEqual(cfg.apurls, wcfg.apurls) {
-		t.Errorf("advertise peer urls = %+v, want %+v", cfg.apurls, wcfg.apurls)
-	}
-	if !reflect.DeepEqual(cfg.lcurls, wcfg.lcurls) {
-		t.Errorf("listen client urls = %+v, want %+v", cfg.lcurls, wcfg.lcurls)
-	}
-	if !reflect.DeepEqual(cfg.acurls, wcfg.acurls) {
-		t.Errorf("advertise client urls = %+v, want %+v", cfg.acurls, wcfg.acurls)
-	}
-}
-
 func TestConfigParsingConflictClusteringFlags(t *testing.T) {
 	conflictArgs := [][]string{
 		{

pkg/flags/flag.go

@@ -22,7 +22,6 @@ import (
 	"os"
 	"strings"
 
-	"github.com/coreos/etcd/pkg/transport"
 	"github.com/coreos/pkg/capnslog"
 	"github.com/spf13/pflag"
 )
@@ -148,54 +147,9 @@ func setFlagFromEnv(fs flagSetter, prefix, fname string, usedEnvKey, alreadySet
 	return nil
 }
 
-// SetBindAddrFromAddr sets the value of bindAddr flag from the value
-// of addr flag. Both flags' Value must be of type IPAddressPort. If the
-// bindAddr flag is set and the addr flag is unset, it will set bindAddr to
-// [::]:port of addr. Otherwise, it keeps the original values.
-func SetBindAddrFromAddr(fs *flag.FlagSet, bindAddrFlagName, addrFlagName string) {
-	if IsSet(fs, bindAddrFlagName) || !IsSet(fs, addrFlagName) {
-		return
-	}
-	addr := *fs.Lookup(addrFlagName).Value.(*IPAddressPort)
-	addr.IP = "::"
-	if err := fs.Set(bindAddrFlagName, addr.String()); err != nil {
-		plog.Panicf("unexpected flags set error: %v", err)
-	}
-}
-
-// URLsFromFlags decides what URLs should be using two different flags
-// as datasources. The first flag's Value must be of type URLs, while
-// the second must be of type IPAddressPort. If both of these flags
-// are set, an error will be returned. If only the first flag is set,
-// the underlying url.URL objects will be returned unmodified. If the
-// second flag happens to be set, the underlying IPAddressPort will be
-// converted to a url.URL and returned. The Scheme of the returned
-// url.URL will be http unless the provided TLSInfo object is non-empty.
-// If neither of the flags have been explicitly set, the default value
-// of the first flag will be returned unmodified.
-func URLsFromFlags(fs *flag.FlagSet, urlsFlagName string, addrFlagName string, tlsInfo transport.TLSInfo) ([]url.URL, error) {
-	visited := make(map[string]struct{})
-	fs.Visit(func(f *flag.Flag) {
-		visited[f.Name] = struct{}{}
-	})
-
-	_, urlsFlagIsSet := visited[urlsFlagName]
-	_, addrFlagIsSet := visited[addrFlagName]
-
-	if addrFlagIsSet {
-		if urlsFlagIsSet {
-			return nil, fmt.Errorf("Set only one of flags -%s and -%s", urlsFlagName, addrFlagName)
-		}
-
-		addr := *fs.Lookup(addrFlagName).Value.(*IPAddressPort)
-		addrURL := url.URL{Scheme: "http", Host: addr.String()}
-		if !tlsInfo.Empty() {
-			addrURL.Scheme = "https"
-		}
-		return []url.URL{addrURL}, nil
-	}
-
-	return []url.URL(*fs.Lookup(urlsFlagName).Value.(*URLsValue)), nil
+// URLsFromFlag returns a slices from url got from the flag.
+func URLsFromFlag(fs *flag.FlagSet, urlsFlagName string) []url.URL {
+	return []url.URL(*fs.Lookup(urlsFlagName).Value.(*URLsValue))
 }
 
 func IsSet(fs *flag.FlagSet, name string) bool {

pkg/flags/flag_test.go

@@ -16,12 +16,8 @@ package flags
 
 import (
 	"flag"
-	"net/url"
 	"os"
-	"reflect"
 	"testing"
-
-	"github.com/coreos/etcd/pkg/transport"
 )
 
 func TestSetFlagsFromEnv(t *testing.T) {
@@ -80,133 +76,3 @@ func TestSetFlagsFromEnvBad(t *testing.T) {
 		t.Errorf("err=nil, want != nil")
 	}
 }
-
-func TestSetBindAddrFromAddr(t *testing.T) {
-	tests := []struct {
-		args  []string
-		waddr *IPAddressPort
-	}{
-		// no flags set
-		{
-			args:  []string{},
-			waddr: &IPAddressPort{},
-		},
-		// addr flag set
-		{
-			args:  []string{"-addr=192.0.3.17:2379"},
-			waddr: &IPAddressPort{IP: "::", Port: 2379},
-		},
-		// bindAddr flag set
-		{
-			args:  []string{"-bind-addr=127.0.0.1:2379"},
-			waddr: &IPAddressPort{IP: "127.0.0.1", Port: 2379},
-		},
-		// both addr flags set
-		{
-			args:  []string{"-bind-addr=127.0.0.1:2379", "-addr=192.0.3.17:2379"},
-			waddr: &IPAddressPort{IP: "127.0.0.1", Port: 2379},
-		},
-		// both addr flags set, IPv6
-		{
-			args:  []string{"-bind-addr=[2001:db8::4:9]:2379", "-addr=[2001:db8::4:f0]:2379"},
-			waddr: &IPAddressPort{IP: "2001:db8::4:9", Port: 2379},
-		},
-	}
-	for i, tt := range tests {
-		fs := flag.NewFlagSet("test", flag.PanicOnError)
-		fs.Var(&IPAddressPort{}, "addr", "")
-		bindAddr := &IPAddressPort{}
-		fs.Var(bindAddr, "bind-addr", "")
-		if err := fs.Parse(tt.args); err != nil {
-			t.Errorf("#%d: failed to parse flags: %v", i, err)
-			continue
-		}
-		SetBindAddrFromAddr(fs, "bind-addr", "addr")
-
-		if !reflect.DeepEqual(bindAddr, tt.waddr) {
-			t.Errorf("#%d: bindAddr = %+v, want %+v", i, bindAddr, tt.waddr)
-		}
-	}
-}
-
-func TestURLsFromFlags(t *testing.T) {
-	tests := []struct {
-		args     []string
-		tlsInfo  transport.TLSInfo
-		wantURLs []url.URL
-		wantFail bool
-	}{
-		// use -urls default when no flags defined
-		{
-			args:    []string{},
-			tlsInfo: transport.TLSInfo{},
-			wantURLs: []url.URL{
-				{Scheme: "http", Host: "127.0.0.1:2379"},
-			},
-			wantFail: false,
-		},
-
-		// explicitly setting -urls should carry through
-		{
-			args:    []string{"-urls=https://192.0.3.17:2930,http://127.0.0.1:1024"},
-			tlsInfo: transport.TLSInfo{},
-			wantURLs: []url.URL{
-				{Scheme: "http", Host: "127.0.0.1:1024"},
-				{Scheme: "https", Host: "192.0.3.17:2930"},
-			},
-			wantFail: false,
-		},
-
-		// explicitly setting -addr should carry through
-		{
-			args:    []string{"-addr=192.0.2.3:1024"},
-			tlsInfo: transport.TLSInfo{},
-			wantURLs: []url.URL{
-				{Scheme: "http", Host: "192.0.2.3:1024"},
-			},
-			wantFail: false,
-		},
-
-		// scheme prepended to -addr should be https if TLSInfo non-empty
-		{
-			args: []string{"-addr=192.0.2.3:1024"},
-			tlsInfo: transport.TLSInfo{
-				CertFile: "/tmp/foo",
-				KeyFile:  "/tmp/bar",
-			},
-			wantURLs: []url.URL{
-				{Scheme: "https", Host: "192.0.2.3:1024"},
-			},
-			wantFail: false,
-		},
-
-		// explicitly setting both -urls and -addr should fail
-		{
-			args:     []string{"-urls=https://127.0.0.1:1024", "-addr=192.0.2.3:1024"},
-			tlsInfo:  transport.TLSInfo{},
-			wantURLs: nil,
-			wantFail: true,
-		},
-	}
-
-	for i, tt := range tests {
-		fs := flag.NewFlagSet("test", flag.PanicOnError)
-		fs.Var(NewURLsValue("http://127.0.0.1:2379"), "urls", "")
-		fs.Var(&IPAddressPort{}, "addr", "")
-
-		if err := fs.Parse(tt.args); err != nil {
-			t.Errorf("#%d: failed to parse flags: %v", i, err)
-			continue
-		}
-
-		gotURLs, err := URLsFromFlags(fs, "urls", "addr", tt.tlsInfo)
-		if tt.wantFail != (err != nil) {
-			t.Errorf("#%d: wantFail=%t, got err=%v", i, tt.wantFail, err)
-			continue
-		}
-
-		if !reflect.DeepEqual(tt.wantURLs, gotURLs) {
-			t.Errorf("#%d: incorrect URLs\nwant=%#v\ngot=%#v", i, tt.wantURLs, gotURLs)
-		}
-	}
-}

pkg/flags/ipaddressport.go

@@ -1,56 +0,0 @@
-// Copyright 2015 The etcd Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package flags
-
-import (
-	"errors"
-	"net"
-	"strconv"
-	"strings"
-)
-
-// IPAddressPort implements the flag.Value interface. The argument
-// is validated as "ip:port".
-type IPAddressPort struct {
-	IP   string
-	Port int
-}
-
-func (a *IPAddressPort) Set(arg string) error {
-	arg = strings.TrimSpace(arg)
-
-	host, portStr, err := net.SplitHostPort(arg)
-	if err != nil {
-		return err
-	}
-
-	if net.ParseIP(host) == nil {
-		return errors.New("bad IP in address specification")
-	}
-
-	port, err := strconv.Atoi(portStr)
-	if err != nil {
-		return errors.New("bad port in address specification")
-	}
-
-	a.IP = host
-	a.Port = port
-
-	return nil
-}
-
-func (a *IPAddressPort) String() string {
-	return net.JoinHostPort(a.IP, strconv.Itoa(a.Port))
-}

pkg/flags/ipaddressport_test.go

@@ -1,80 +0,0 @@
-// Copyright 2015 The etcd Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package flags
-
-import (
-	"testing"
-)
-
-func TestIPAddressPortSet(t *testing.T) {
-	pass := []string{
-		"1.2.3.4:8080",
-		"10.1.1.1:80",
-		"[2001:db8::1]:8080",
-	}
-
-	fail := []string{
-		// bad IP specification
-		":2379",
-		"127.0:8080",
-		"123:456",
-		// bad port specification
-		"127.0.0.1:foo",
-		"127.0.0.1:",
-		// unix sockets not supported
-		"unix://",
-		"unix://tmp/etcd.sock",
-		// bad strings
-		"somewhere",
-		"234#$",
-		"file://foo/bar",
-		"http://hello",
-		"2001:db8::1",
-		"2001:db8::1:1",
-	}
-
-	for i, tt := range pass {
-		f := &IPAddressPort{}
-		if err := f.Set(tt); err != nil {
-			t.Errorf("#%d: unexpected error from IPAddressPort.Set(%q): %v", i, tt, err)
-		}
-	}
-
-	for i, tt := range fail {
-		f := &IPAddressPort{}
-		if err := f.Set(tt); err == nil {
-			t.Errorf("#%d: expected error from IPAddressPort.Set(%q)", i, tt)
-		}
-	}
-}
-
-func TestIPAddressPortString(t *testing.T) {
-	addresses := []string{
-		"[2001:db8::1:1234]:2379",
-		"127.0.0.1:2379",
-	}
-	for i, tt := range addresses {
-		f := &IPAddressPort{}
-		if err := f.Set(tt); err != nil {
-			t.Errorf("#%d: unexpected error: %v", i, err)
-		}
-
-		want := tt
-		got := f.String()
-		if want != got {
-			t.Errorf("#%d: IPAddressPort.String() value should be %q, got %q", i, want, got)
-		}
-	}
-}