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

*: update to use IANA-assigned ports

Browse Source
This commit is contained in:
Alex Crawford 2015-04-06 08:38:13 -07:00
parent 27083093d3
commit d9ad6aa2a9
25 changed files with 148 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
README.md
View File

@ -44,13 +44,13 @@ First start a single-member cluster of etcd:
./bin/etcd ./bin/etcd
``` ```
This will bring up etcd listening on port 4001 for client communication and on port 7001 for server-to-server communication. This will bring up etcd listening on port 2379 for client communication and on port 2380 for server-to-server communication.
Next, let's set a single key, and then retrieve it: Next, let's set a single key, and then retrieve it:
``` ```
curl -L http://127.0.0.1:4001/v2/keys/mykey -XPUT -d value="this is awesome" curl -L http://127.0.0.1:2379/v2/keys/mykey -XPUT -d value="this is awesome"
curl -L http://127.0.0.1:4001/v2/keys/mykey curl -L http://127.0.0.1:2379/v2/keys/mykey
``` ```
You have successfully started an etcd and written a key to the store. You have successfully started an etcd and written a key to the store.
@ -112,7 +112,7 @@ New minor versions may add additional features to the API.
You can get the version of etcd by issuing a request to /version: You can get the version of etcd by issuing a request to /version:
```sh ```sh
curl -L http://127.0.0.1:4001/version curl -L http://127.0.0.1:2379/version
``` ```
#### API Versioning #### API Versioning

4
client/client.go
View File

@ -50,9 +50,9 @@ type Config struct {
// example, a three-node cluster could be provided like so: // example, a three-node cluster could be provided like so:
// //
// Endpoints: []string{ // Endpoints: []string{
// "http://node1.example.com:4001", // "http://node1.example.com:2379",
// "http://node2.example.com:2379", // "http://node2.example.com:2379",
// "http://node3.example.com:4001", // "http://node3.example.com:2379",
// } // }
// //
// If multiple endpoints are provided, the Client will attempt to // If multiple endpoints are provided, the Client will attempt to

8
client/client_test.go
View File

@ -626,12 +626,12 @@ func TestHTTPClusterClientSync(t *testing.T) {
}) })
hc := &httpClusterClient{clientFactory: cf} hc := &httpClusterClient{clientFactory: cf}
err := hc.reset([]string{"http://127.0.0.1:4001"}) err := hc.reset([]string{"http://127.0.0.1:2379"})
if err != nil { if err != nil {
t.Fatalf("unexpected error during setup: %#v", err) t.Fatalf("unexpected error during setup: %#v", err)
} }
want := []string{"http://127.0.0.1:4001"} want := []string{"http://127.0.0.1:2379"}
got := hc.Endpoints() got := hc.Endpoints()
if !reflect.DeepEqual(want, got) { if !reflect.DeepEqual(want, got) {
t.Fatalf("incorrect endpoints: want=%#v got=%#v", want, got) t.Fatalf("incorrect endpoints: want=%#v got=%#v", want, got)
@ -666,12 +666,12 @@ func TestHTTPClusterClientSyncFail(t *testing.T) {
}) })
hc := &httpClusterClient{clientFactory: cf} hc := &httpClusterClient{clientFactory: cf}
err := hc.reset([]string{"http://127.0.0.1:4001"}) err := hc.reset([]string{"http://127.0.0.1:2379"})
if err != nil { if err != nil {
t.Fatalf("unexpected error during setup: %#v", err) t.Fatalf("unexpected error during setup: %#v", err)
} }
want := []string{"http://127.0.0.1:4001"} want := []string{"http://127.0.0.1:2379"}
got := hc.Endpoints() got := hc.Endpoints()
if !reflect.DeepEqual(want, got) { if !reflect.DeepEqual(want, got) {
t.Fatalf("incorrect endpoints: want=%#v got=%#v", want, got) t.Fatalf("incorrect endpoints: want=%#v got=%#v", want, got)

2
client/doc.go
View File

@ -25,7 +25,7 @@ Create a Config and exchange it for a Client:
) )
cfg := client.Config{ cfg := client.Config{
Endpoints: []string{"http://127.0.0.1:4001"}, Endpoints: []string{"http://127.0.0.1:2379"},
Transport: DefaultTransport, Transport: DefaultTransport,
} }

16
client/members_test.go
View File

@ -128,23 +128,23 @@ func TestMemberUnmarshal(t *testing.T) {
// both client and peer URLs // both client and peer URLs
{ {
body: []byte(`{"peerURLs": ["http://127.0.0.1:4001"], "clientURLs": ["http://127.0.0.1:4001"]}`), body: []byte(`{"peerURLs": ["http://127.0.0.1:2379"], "clientURLs": ["http://127.0.0.1:2379"]}`),
wantMember: Member{ wantMember: Member{
PeerURLs: []string{ PeerURLs: []string{
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
}, },
ClientURLs: []string{ ClientURLs: []string{
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
}, },
}, },
}, },
// multiple peer URLs // multiple peer URLs
{ {
body: []byte(`{"peerURLs": ["http://127.0.0.1:4001", "https://example.com"]}`), body: []byte(`{"peerURLs": ["http://127.0.0.1:2379", "https://example.com"]}`),
wantMember: Member{ wantMember: Member{
PeerURLs: []string{ PeerURLs: []string{
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
"https://example.com", "https://example.com",
}, },
ClientURLs: nil, ClientURLs: nil,
@ -153,11 +153,11 @@ func TestMemberUnmarshal(t *testing.T) {
// multiple client URLs // multiple client URLs
{ {
body: []byte(`{"clientURLs": ["http://127.0.0.1:4001", "https://example.com"]}`), body: []byte(`{"clientURLs": ["http://127.0.0.1:2379", "https://example.com"]}`),
wantMember: Member{ wantMember: Member{
PeerURLs: nil, PeerURLs: nil,
ClientURLs: []string{ ClientURLs: []string{
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
"https://example.com", "https://example.com",
}, },
}, },
@ -311,7 +311,7 @@ func TestHTTPMembersAPIAddSuccess(t *testing.T) {
} }
func TestHTTPMembersAPIAddError(t *testing.T) { func TestHTTPMembersAPIAddError(t *testing.T) {
okPeer := "http://example.com:4001" okPeer := "http://example.com:2379"
tests := []struct { tests := []struct {
peerURL string peerURL string
client httpClient client httpClient

8
discovery/srv_test.go
View File

@ -55,10 +55,10 @@ func TestSRVGetCluster(t *testing.T) {
&net.SRV{Target: "10.0.0.3", Port: 2480}, &net.SRV{Target: "10.0.0.3", Port: 2480},
}, },
[]*net.SRV{ []*net.SRV{
&net.SRV{Target: "10.0.0.1", Port: 7001}, &net.SRV{Target: "10.0.0.1", Port: 2380},
}, },
nil, nil,
"0=https://10.0.0.1:2480,1=https://10.0.0.2:2480,2=https://10.0.0.3:2480,3=http://10.0.0.1:7001", "0=https://10.0.0.1:2480,1=https://10.0.0.2:2480,2=https://10.0.0.3:2480,3=http://10.0.0.1:2380",
}, },
{ {
[]*net.SRV{ []*net.SRV{
@ -67,10 +67,10 @@ func TestSRVGetCluster(t *testing.T) {
&net.SRV{Target: "10.0.0.3", Port: 2480}, &net.SRV{Target: "10.0.0.3", Port: 2480},
}, },
[]*net.SRV{ []*net.SRV{
&net.SRV{Target: "10.0.0.1", Port: 7001}, &net.SRV{Target: "10.0.0.1", Port: 2380},
}, },
[]string{"https://10.0.0.1:2480"}, []string{"https://10.0.0.1:2480"},
"dnsClusterTest=https://10.0.0.1:2480,0=https://10.0.0.2:2480,1=https://10.0.0.3:2480,2=http://10.0.0.1:7001", "dnsClusterTest=https://10.0.0.1:2480,0=https://10.0.0.2:2480,1=https://10.0.0.3:2480,2=http://10.0.0.1:2380",
}, },
} }

2
etcdctl/README.md
View File

@ -233,7 +233,7 @@ The following exit codes can be returned from etcdctl:
## Peers ## Peers
If your etcd cluster isn't available on `http://127.0.0.1:4001` you can specify If your etcd cluster isn't available on `http://127.0.0.1:2379` you can specify
a `--peers` flag or `ETCDCTL_PEERS` environment variable. You can list one peer, a `--peers` flag or `ETCDCTL_PEERS` environment variable. You can list one peer,
or a comma-separated list of peers. or a comma-separated list of peers.

2
etcdctl/main.go
View File

@ -31,7 +31,7 @@ func main() {
cli.BoolFlag{Name: "debug", Usage: "output cURL commands which can be used to reproduce the request"}, cli.BoolFlag{Name: "debug", Usage: "output cURL commands which can be used to reproduce the request"},
cli.BoolFlag{Name: "no-sync", Usage: "don't synchronize cluster information before sending request"}, cli.BoolFlag{Name: "no-sync", Usage: "don't synchronize cluster information before sending request"},
cli.StringFlag{Name: "output, o", Value: "simple", Usage: "output response in the given format (`simple` or `json`)"}, cli.StringFlag{Name: "output, o", Value: "simple", Usage: "output response in the given format (`simple` or `json`)"},
cli.StringFlag{Name: "peers, C", Value: "", Usage: "a comma-delimited list of machine addresses in the cluster (default: \"127.0.0.1:4001\")"}, cli.StringFlag{Name: "peers, C", Value: "", Usage: "a comma-delimited list of machine addresses in the cluster (default: \"127.0.0.1:4001,127.0.0.1:2379\")"},
cli.StringFlag{Name: "cert-file", Value: "", Usage: "identify HTTPS client using this SSL certificate file"}, cli.StringFlag{Name: "cert-file", Value: "", Usage: "identify HTTPS client using this SSL certificate file"},
cli.StringFlag{Name: "key-file", Value: "", Usage: "identify HTTPS client using this SSL key file"}, cli.StringFlag{Name: "key-file", Value: "", Usage: "identify HTTPS client using this SSL key file"},
cli.StringFlag{Name: "ca-file", Value: "", Usage: "verify certificates of HTTPS-enabled servers using this CA bundle"}, cli.StringFlag{Name: "ca-file", Value: "", Usage: "verify certificates of HTTPS-enabled servers using this CA bundle"},

12
etcdmain/config_test.go
View File

@ -153,14 +153,14 @@ func TestConfigParsingOtherFlags(t *testing.T) {
func TestConfigParsingV1Flags(t *testing.T) { func TestConfigParsingV1Flags(t *testing.T) {
args := []string{ args := []string{
"-peer-addr=127.0.0.1:7001", "-peer-addr=127.0.0.1:2380",
"-addr=127.0.0.1:4001", "-addr=127.0.0.1:2379",
} }
wcfg := NewConfig() wcfg := NewConfig()
wcfg.lpurls = []url.URL{{Scheme: "http", Host: "[::]:7001"}} wcfg.lpurls = []url.URL{{Scheme: "http", Host: "[::]:2380"}}
wcfg.apurls = []url.URL{{Scheme: "http", Host: "127.0.0.1:7001"}} wcfg.apurls = []url.URL{{Scheme: "http", Host: "127.0.0.1:2380"}}
wcfg.lcurls = []url.URL{{Scheme: "http", Host: "[::]:4001"}} wcfg.lcurls = []url.URL{{Scheme: "http", Host: "[::]:2379"}}
wcfg.acurls = []url.URL{{Scheme: "http", Host: "127.0.0.1:4001"}} wcfg.acurls = []url.URL{{Scheme: "http", Host: "127.0.0.1:2379"}}
cfg := NewConfig() cfg := NewConfig()
if err := cfg.Parse(args); err != nil { if err := cfg.Parse(args); err != nil {

4
etcdmain/etcd_test.go
View File

@ -27,8 +27,8 @@ func TestGenClusterString(t *testing.T) {
wstr string wstr string
}{ }{
{ {
"default", []string{"http://127.0.0.1:4001"}, "default", []string{"http://127.0.0.1:2379"},
"default=http://127.0.0.1:4001", "default=http://127.0.0.1:2379",
}, },
{ {
"node1", []string{"http://0.0.0.0:2379", "http://1.1.1.1:2379"}, "node1", []string{"http://0.0.0.0:2379", "http://1.1.1.1:2379"},

4
etcdserver/cluster_test.go
View File

@ -594,7 +594,7 @@ func TestClusterString(t *testing.T) {
), ),
3: newTestMember( 3: newTestMember(
3, 3,
[]string{"http://3.3.3.3:1234", "http://127.0.0.1:7001"}, []string{"http://3.3.3.3:1234", "http://127.0.0.1:2380"},
"ghi", "ghi",
nil, nil,
), ),
@ -613,7 +613,7 @@ func TestClusterString(t *testing.T) {
), ),
}, },
} }
w := "abc=http://0.0.0.0:0000,abc=http://1.1.1.1:1111,def=http://2.2.2.2:2222,ghi=http://127.0.0.1:7001,ghi=http://3.3.3.3:1234" w := "abc=http://0.0.0.0:0000,abc=http://1.1.1.1:1111,def=http://2.2.2.2:2222,ghi=http://127.0.0.1:2380,ghi=http://3.3.3.3:1234"
if g := cls.String(); g != w { if g := cls.String(); g != w {
t.Fatalf("Cluster.String():\ngot %#v\nwant %#v", g, w) t.Fatalf("Cluster.String():\ngot %#v\nwant %#v", g, w)
} }

8
etcdserver/config_test.go
View File

@ -54,7 +54,7 @@ func TestConfigVerifyExistingWithDiscoveryURLFail(t *testing.T) {
} }
c := &ServerConfig{ c := &ServerConfig{
Name: "node1", Name: "node1",
DiscoveryURL: "http://127.0.0.1:4001/abcdefg", DiscoveryURL: "http://127.0.0.1:2379/abcdefg",
PeerURLs: mustNewURLs(t, []string{"http://127.0.0.1:2380"}), PeerURLs: mustNewURLs(t, []string{"http://127.0.0.1:2380"}),
Cluster: cluster, Cluster: cluster,
NewCluster: false, NewCluster: false,
@ -105,7 +105,7 @@ func TestConfigVerifyLocalMember(t *testing.T) {
}, },
{ {
// Advertised peer URLs must match those in cluster-state // Advertised peer URLs must match those in cluster-state
"node1=http://localhost:7001,node1=http://localhost:12345", "node1=http://localhost:2380,node1=http://localhost:12345",
[]string{"http://localhost:12345"}, []string{"http://localhost:12345"},
true, true,
@ -113,7 +113,7 @@ func TestConfigVerifyLocalMember(t *testing.T) {
}, },
{ {
// Advertised peer URLs must match those in cluster-state // Advertised peer URLs must match those in cluster-state
"node1=http://localhost:7001", "node1=http://localhost:2380",
[]string{}, []string{},
true, true,
@ -121,7 +121,7 @@ func TestConfigVerifyLocalMember(t *testing.T) {
}, },
{ {
// do not care about the urls if strict is not set // do not care about the urls if strict is not set
"node1=http://localhost:7001", "node1=http://localhost:2380",
[]string{}, []string{},
false, false,

16
etcdserver/etcdhttp/httptypes/member_test.go
View File

@ -37,23 +37,23 @@ func TestMemberUnmarshal(t *testing.T) {
// both client and peer URLs // both client and peer URLs
{ {
body: []byte(`{"peerURLs": ["http://127.0.0.1:4001"], "clientURLs": ["http://127.0.0.1:4001"]}`), body: []byte(`{"peerURLs": ["http://127.0.0.1:2379"], "clientURLs": ["http://127.0.0.1:2379"]}`),
wantMember: Member{ wantMember: Member{
PeerURLs: []string{ PeerURLs: []string{
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
}, },
ClientURLs: []string{ ClientURLs: []string{
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
}, },
}, },
}, },
// multiple peer URLs // multiple peer URLs
{ {
body: []byte(`{"peerURLs": ["http://127.0.0.1:4001", "https://example.com"]}`), body: []byte(`{"peerURLs": ["http://127.0.0.1:2379", "https://example.com"]}`),
wantMember: Member{ wantMember: Member{
PeerURLs: []string{ PeerURLs: []string{
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
"https://example.com", "https://example.com",
}, },
ClientURLs: nil, ClientURLs: nil,
@ -62,11 +62,11 @@ func TestMemberUnmarshal(t *testing.T) {
// multiple client URLs // multiple client URLs
{ {
body: []byte(`{"clientURLs": ["http://127.0.0.1:4001", "https://example.com"]}`), body: []byte(`{"clientURLs": ["http://127.0.0.1:2379", "https://example.com"]}`),
wantMember: Member{ wantMember: Member{
PeerURLs: nil, PeerURLs: nil,
ClientURLs: []string{ ClientURLs: []string{
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
"https://example.com", "https://example.com",
}, },
}, },
@ -122,7 +122,7 @@ func TestMemberCreateRequestUnmarshalFail(t *testing.T) {
[]byte(`{"peerURLs": "foo"}`), []byte(`{"peerURLs": "foo"}`),
[]byte(`{"peerURLs": ["."]}`), []byte(`{"peerURLs": ["."]}`),
[]byte(`{"peerURLs": []}`), []byte(`{"peerURLs": []}`),
[]byte(`{"peerURLs": ["http://127.0.0.1:4001/foo"]}`), []byte(`{"peerURLs": ["http://127.0.0.1:2379/foo"]}`),
[]byte(`{"peerURLs": ["http://127.0.0.1"]}`), []byte(`{"peerURLs": ["http://127.0.0.1"]}`),
} }

4
etcdserver/server_test.go
View File

@ -401,10 +401,10 @@ func TestApplyRequestOnAdminMemberAttributes(t *testing.T) {
Method: "PUT", Method: "PUT",
ID: 1, ID: 1,
Path: path.Join(storeMembersPrefix, strconv.FormatUint(1, 16), attributesSuffix), Path: path.Join(storeMembersPrefix, strconv.FormatUint(1, 16), attributesSuffix),
Val: `{"Name":"abc","ClientURLs":["http://127.0.0.1:4001"]}`, Val: `{"Name":"abc","ClientURLs":["http://127.0.0.1:2379"]}`,
} }
srv.applyRequest(req) srv.applyRequest(req)
w := Attributes{Name: "abc", ClientURLs: []string{"http://127.0.0.1:4001"}} w := Attributes{Name: "abc", ClientURLs: []string{"http://127.0.0.1:2379"}}
if g := cl.Member(1).Attributes; !reflect.DeepEqual(g, w) { if g := cl.Member(1).Attributes; !reflect.DeepEqual(g, w) {
t.Errorf("attributes = %v, want %v", g, w) t.Errorf("attributes = %v, want %v", g, w)
} }

16
pkg/flags/flag_test.go
View File

@ -93,23 +93,23 @@ func TestSetBindAddrFromAddr(t *testing.T) {
}, },
// addr flag set // addr flag set
{ {
args: []string{"-addr=192.0.3.17:4001"}, args: []string{"-addr=192.0.3.17:2379"},
waddr: &IPAddressPort{IP: "::", Port: 4001}, waddr: &IPAddressPort{IP: "::", Port: 2379},
}, },
// bindAddr flag set // bindAddr flag set
{ {
args: []string{"-bind-addr=127.0.0.1:4001"}, args: []string{"-bind-addr=127.0.0.1:2379"},
waddr: &IPAddressPort{IP: "127.0.0.1", Port: 4001}, waddr: &IPAddressPort{IP: "127.0.0.1", Port: 2379},
}, },
// both addr flags set // both addr flags set
{ {
args: []string{"-bind-addr=127.0.0.1:4001", "-addr=192.0.3.17:4001"}, args: []string{"-bind-addr=127.0.0.1:2379", "-addr=192.0.3.17:2379"},
waddr: &IPAddressPort{IP: "127.0.0.1", Port: 4001}, waddr: &IPAddressPort{IP: "127.0.0.1", Port: 2379},
}, },
// both addr flags set, IPv6 // both addr flags set, IPv6
{ {
args: []string{"-bind-addr=[2001:db8::4:9]:4001", "-addr=[2001:db8::4:f0]:4001"}, args: []string{"-bind-addr=[2001:db8::4:9]:2379", "-addr=[2001:db8::4:f0]:2379"},
waddr: &IPAddressPort{IP: "2001:db8::4:9", Port: 4001}, waddr: &IPAddressPort{IP: "2001:db8::4:9", Port: 2379},
}, },
} }
for i, tt := range tests { for i, tt := range tests {

6
pkg/flags/ipaddressport_test.go
View File

@ -27,7 +27,7 @@ func TestIPAddressPortSet(t *testing.T) {
fail := []string{ fail := []string{
// bad IP specification // bad IP specification
":4001", ":2379",
"127.0:8080", "127.0:8080",
"123:456", "123:456",
// bad port specification // bad port specification
@ -62,8 +62,8 @@ func TestIPAddressPortSet(t *testing.T) {
func TestIPAddressPortString(t *testing.T) { func TestIPAddressPortString(t *testing.T) {
addresses := []string{ addresses := []string{
"[2001:db8::1:1234]:4001", "[2001:db8::1:1234]:2379",
"127.0.0.1:4001", "127.0.0.1:2379",
} }
for i, tt := range addresses { for i, tt := range addresses {
f := &IPAddressPort{} f := &IPAddressPort{}

2
pkg/flags/urls.go
View File

@ -24,7 +24,7 @@ import (
type URLsValue types.URLs type URLsValue types.URLs
// Set parses a command line set of URLs formatted like: // Set parses a command line set of URLs formatted like:
// http://127.0.0.1:7001,http://10.1.1.2:80 // http://127.0.0.1:2380,http://10.1.1.2:80
func (us *URLsValue) Set(s string) error { func (us *URLsValue) Set(s string) error {
strs := strings.Split(s, ",") strs := strings.Split(s, ",")
nus, err := types.NewURLs(strs) nus, err := types.NewURLs(strs)

2
pkg/flags/urls_test.go
View File

@ -21,7 +21,7 @@ import (
func TestValidateURLsValueBad(t *testing.T) { func TestValidateURLsValueBad(t *testing.T) {
tests := []string{ tests := []string{
// bad IP specification // bad IP specification
":4001", ":2379",
"127.0:8080", "127.0:8080",
"123:456", "123:456",
// bad port specification // bad port specification

56
pkg/netutil/netutil_test.go
View File

@ -157,73 +157,73 @@ func TestURLsEqual(t *testing.T) {
expect bool expect bool
}{ }{
{ {
a: []url.URL{{Scheme: "http", Host: "127.0.0.1:4001"}}, a: []url.URL{{Scheme: "http", Host: "127.0.0.1:2379"}},
b: []url.URL{{Scheme: "http", Host: "127.0.0.1:4001"}}, b: []url.URL{{Scheme: "http", Host: "127.0.0.1:2379"}},
expect: true, expect: true,
}, },
{ {
a: []url.URL{{Scheme: "http", Host: "example.com:4001"}}, a: []url.URL{{Scheme: "http", Host: "example.com:2379"}},
b: []url.URL{{Scheme: "http", Host: "10.0.10.1:4001"}}, b: []url.URL{{Scheme: "http", Host: "10.0.10.1:2379"}},
expect: true, expect: true,
}, },
{ {
a: []url.URL{{Scheme: "http", Host: "127.0.0.1:4001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, a: []url.URL{{Scheme: "http", Host: "127.0.0.1:2379"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
b: []url.URL{{Scheme: "http", Host: "127.0.0.1:4001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, b: []url.URL{{Scheme: "http", Host: "127.0.0.1:2379"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
expect: true, expect: true,
}, },
{ {
a: []url.URL{{Scheme: "http", Host: "example.com:4001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, a: []url.URL{{Scheme: "http", Host: "example.com:2379"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
b: []url.URL{{Scheme: "http", Host: "example.com:4001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, b: []url.URL{{Scheme: "http", Host: "example.com:2379"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
expect: true, expect: true,
}, },
{ {
a: []url.URL{{Scheme: "http", Host: "10.0.10.1:4001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, a: []url.URL{{Scheme: "http", Host: "10.0.10.1:2379"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
b: []url.URL{{Scheme: "http", Host: "example.com:4001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, b: []url.URL{{Scheme: "http", Host: "example.com:2379"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
expect: true, expect: true,
}, },
{ {
a: []url.URL{{Scheme: "http", Host: "127.0.0.1:4001"}}, a: []url.URL{{Scheme: "http", Host: "127.0.0.1:2379"}},
b: []url.URL{{Scheme: "http", Host: "127.0.0.1:7001"}}, b: []url.URL{{Scheme: "http", Host: "127.0.0.1:2380"}},
expect: false, expect: false,
}, },
{ {
a: []url.URL{{Scheme: "http", Host: "example.com:7001"}}, a: []url.URL{{Scheme: "http", Host: "example.com:2380"}},
b: []url.URL{{Scheme: "http", Host: "10.0.10.1:4001"}}, b: []url.URL{{Scheme: "http", Host: "10.0.10.1:2379"}},
expect: false, expect: false,
}, },
{ {
a: []url.URL{{Scheme: "http", Host: "127.0.0.1:4001"}}, a: []url.URL{{Scheme: "http", Host: "127.0.0.1:2379"}},
b: []url.URL{{Scheme: "http", Host: "10.0.0.1:4001"}}, b: []url.URL{{Scheme: "http", Host: "10.0.0.1:2379"}},
expect: false, expect: false,
}, },
{ {
a: []url.URL{{Scheme: "http", Host: "example.com:4001"}}, a: []url.URL{{Scheme: "http", Host: "example.com:2379"}},
b: []url.URL{{Scheme: "http", Host: "10.0.0.1:4001"}}, b: []url.URL{{Scheme: "http", Host: "10.0.0.1:2379"}},
expect: false, expect: false,
}, },
{ {
a: []url.URL{{Scheme: "http", Host: "127.0.0.1:4001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, a: []url.URL{{Scheme: "http", Host: "127.0.0.1:2379"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
b: []url.URL{{Scheme: "http", Host: "127.0.0.1:7001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, b: []url.URL{{Scheme: "http", Host: "127.0.0.1:2380"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
expect: false, expect: false,
}, },
{ {
a: []url.URL{{Scheme: "http", Host: "example.com:4001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, a: []url.URL{{Scheme: "http", Host: "example.com:2379"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
b: []url.URL{{Scheme: "http", Host: "127.0.0.1:7001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, b: []url.URL{{Scheme: "http", Host: "127.0.0.1:2380"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
expect: false, expect: false,
}, },
{ {
a: []url.URL{{Scheme: "http", Host: "127.0.0.1:4001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, a: []url.URL{{Scheme: "http", Host: "127.0.0.1:2379"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
b: []url.URL{{Scheme: "http", Host: "10.0.0.1:4001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, b: []url.URL{{Scheme: "http", Host: "10.0.0.1:2379"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
expect: false, expect: false,
}, },
{ {
a: []url.URL{{Scheme: "http", Host: "example.com:4001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, a: []url.URL{{Scheme: "http", Host: "example.com:2379"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
b: []url.URL{{Scheme: "http", Host: "10.0.0.1:4001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, b: []url.URL{{Scheme: "http", Host: "10.0.0.1:2379"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
expect: false, expect: false,
}, },
{ {
a: []url.URL{{Scheme: "http", Host: "10.0.0.1:4001"}}, a: []url.URL{{Scheme: "http", Host: "10.0.0.1:2379"}},
b: []url.URL{{Scheme: "http", Host: "10.0.0.1:4001"}, {Scheme: "http", Host: "127.0.0.1:7001"}}, b: []url.URL{{Scheme: "http", Host: "10.0.0.1:2379"}, {Scheme: "http", Host: "127.0.0.1:2380"}},
expect: false, expect: false,
}, },
} }

70
pkg/types/urls_test.go
View File

@ -27,23 +27,23 @@ func TestNewURLs(t *testing.T) {
wurls URLs wurls URLs
}{ }{
{ {
[]string{"http://127.0.0.1:4001"}, []string{"http://127.0.0.1:2379"},
testutil.MustNewURLs(t, []string{"http://127.0.0.1:4001"}), testutil.MustNewURLs(t, []string{"http://127.0.0.1:2379"}),
}, },
// it can trim space // it can trim space
{ {
[]string{" http://127.0.0.1:4001 "}, []string{" http://127.0.0.1:2379 "},
testutil.MustNewURLs(t, []string{"http://127.0.0.1:4001"}), testutil.MustNewURLs(t, []string{"http://127.0.0.1:2379"}),
}, },
// it does sort // it does sort
{ {
[]string{ []string{
"http://127.0.0.2:4001", "http://127.0.0.2:2379",
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
}, },
testutil.MustNewURLs(t, []string{ testutil.MustNewURLs(t, []string{
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
"http://127.0.0.2:4001", "http://127.0.0.2:2379",
}), }),
}, },
} }
@ -65,22 +65,22 @@ func TestURLsString(t *testing.T) {
"", "",
}, },
{ {
testutil.MustNewURLs(t, []string{"http://127.0.0.1:4001"}), testutil.MustNewURLs(t, []string{"http://127.0.0.1:2379"}),
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
}, },
{ {
testutil.MustNewURLs(t, []string{ testutil.MustNewURLs(t, []string{
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
"http://127.0.0.2:4001", "http://127.0.0.2:2379",
}), }),
"http://127.0.0.1:4001,http://127.0.0.2:4001", "http://127.0.0.1:2379,http://127.0.0.2:2379",
}, },
{ {
testutil.MustNewURLs(t, []string{ testutil.MustNewURLs(t, []string{
"http://127.0.0.2:4001", "http://127.0.0.2:2379",
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
}), }),
"http://127.0.0.2:4001,http://127.0.0.1:4001", "http://127.0.0.2:2379,http://127.0.0.1:2379",
}, },
} }
for i, tt := range tests { for i, tt := range tests {
@ -93,16 +93,16 @@ func TestURLsString(t *testing.T) {
func TestURLsSort(t *testing.T) { func TestURLsSort(t *testing.T) {
g := testutil.MustNewURLs(t, []string{ g := testutil.MustNewURLs(t, []string{
"http://127.0.0.4:4001", "http://127.0.0.4:2379",
"http://127.0.0.2:4001", "http://127.0.0.2:2379",
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
"http://127.0.0.3:4001", "http://127.0.0.3:2379",
}) })
w := testutil.MustNewURLs(t, []string{ w := testutil.MustNewURLs(t, []string{
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
"http://127.0.0.2:4001", "http://127.0.0.2:2379",
"http://127.0.0.3:4001", "http://127.0.0.3:2379",
"http://127.0.0.4:4001", "http://127.0.0.4:2379",
}) })
gurls := URLs(g) gurls := URLs(g)
gurls.Sort() gurls.Sort()
@ -121,22 +121,22 @@ func TestURLsStringSlice(t *testing.T) {
[]string{}, []string{},
}, },
{ {
testutil.MustNewURLs(t, []string{"http://127.0.0.1:4001"}), testutil.MustNewURLs(t, []string{"http://127.0.0.1:2379"}),
[]string{"http://127.0.0.1:4001"}, []string{"http://127.0.0.1:2379"},
}, },
{ {
testutil.MustNewURLs(t, []string{ testutil.MustNewURLs(t, []string{
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
"http://127.0.0.2:4001", "http://127.0.0.2:2379",
}), }),
[]string{"http://127.0.0.1:4001", "http://127.0.0.2:4001"}, []string{"http://127.0.0.1:2379", "http://127.0.0.2:2379"},
}, },
{ {
testutil.MustNewURLs(t, []string{ testutil.MustNewURLs(t, []string{
"http://127.0.0.2:4001", "http://127.0.0.2:2379",
"http://127.0.0.1:4001", "http://127.0.0.1:2379",
}), }),
[]string{"http://127.0.0.2:4001", "http://127.0.0.1:4001"}, []string{"http://127.0.0.2:2379", "http://127.0.0.1:2379"},
}, },
} }
for i, tt := range tests { for i, tt := range tests {
@ -152,13 +152,13 @@ func TestNewURLsFail(t *testing.T) {
// no urls given // no urls given
{}, {},
// missing protocol scheme // missing protocol scheme
{"://127.0.0.1:4001"}, {"://127.0.0.1:2379"},
// unsupported scheme // unsupported scheme
{"mailto://127.0.0.1:4001"}, {"mailto://127.0.0.1:2379"},
// not conform to host:port // not conform to host:port
{"http://127.0.0.1"}, {"http://127.0.0.1"},
// contain a path // contain a path
{"http://127.0.0.1:4001/path"}, {"http://127.0.0.1:2379/path"},
} }
for i, tt := range tests { for i, tt := range tests {
_, err := NewURLs(tt) _, err := NewURLs(tt)

2
proxy/reverse_test.go
View File

@ -81,7 +81,7 @@ func TestReverseProxyServe(t *testing.T) {
transport: tt.rt, transport: tt.rt,
} }
req, _ := http.NewRequest("GET", "http://192.0.2.2:4001", nil) req, _ := http.NewRequest("GET", "http://192.0.2.2:2379", nil)
rr := httptest.NewRecorder() rr := httptest.NewRecorder()
rp.ServeHTTP(rr, req) rp.ServeHTTP(rr, req)

4
rafthttp/http_test.go
View File

@ -174,7 +174,7 @@ func TestServeRaftStreamPrefix(t *testing.T) {
}, },
} }
for i, tt := range tests { for i, tt := range tests {
req, err := http.NewRequest("GET", "http://localhost:7001"+tt.path, nil) req, err := http.NewRequest("GET", "http://localhost:2380"+tt.path, nil)
if err != nil { if err != nil {
t.Fatalf("#%d: could not create request: %#v", i, err) t.Fatalf("#%d: could not create request: %#v", i, err)
} }
@ -281,7 +281,7 @@ func TestServeRaftStreamPrefixBad(t *testing.T) {
}, },
} }
for i, tt := range tests { for i, tt := range tests {
req, err := http.NewRequest(tt.method, "http://localhost:7001"+tt.path, nil) req, err := http.NewRequest(tt.method, "http://localhost:2380"+tt.path, nil)
if err != nil { if err != nil {
t.Fatalf("#%d: could not create request: %#v", i, err) t.Fatalf("#%d: could not create request: %#v", i, err)
} }

22
rafthttp/pipeline_test.go
View File

@ -31,7 +31,7 @@ import (
// and increase success count in stats. // and increase success count in stats.
func TestPipelineSend(t *testing.T) { func TestPipelineSend(t *testing.T) {
tr := &roundTripperRecorder{} tr := &roundTripperRecorder{}
picker := mustNewURLPicker(t, []string{"http://localhost:7001"}) picker := mustNewURLPicker(t, []string{"http://localhost:2380"})
fs := &stats.FollowerStats{} fs := &stats.FollowerStats{}
p := newPipeline(tr, picker, types.ID(1), types.ID(1), fs, &fakeRaft{}, nil) p := newPipeline(tr, picker, types.ID(1), types.ID(1), fs, &fakeRaft{}, nil)
@ -50,7 +50,7 @@ func TestPipelineSend(t *testing.T) {
func TestPipelineExceedMaximalServing(t *testing.T) { func TestPipelineExceedMaximalServing(t *testing.T) {
tr := newRoundTripperBlocker() tr := newRoundTripperBlocker()
picker := mustNewURLPicker(t, []string{"http://localhost:7001"}) picker := mustNewURLPicker(t, []string{"http://localhost:2380"})
fs := &stats.FollowerStats{} fs := &stats.FollowerStats{}
p := newPipeline(tr, picker, types.ID(1), types.ID(1), fs, &fakeRaft{}, nil) p := newPipeline(tr, picker, types.ID(1), types.ID(1), fs, &fakeRaft{}, nil)
@ -90,7 +90,7 @@ func TestPipelineExceedMaximalServing(t *testing.T) {
// TestPipelineSendFailed tests that when send func meets the post error, // TestPipelineSendFailed tests that when send func meets the post error,
// it increases fail count in stats. // it increases fail count in stats.
func TestPipelineSendFailed(t *testing.T) { func TestPipelineSendFailed(t *testing.T) {
picker := mustNewURLPicker(t, []string{"http://localhost:7001"}) picker := mustNewURLPicker(t, []string{"http://localhost:2380"})
fs := &stats.FollowerStats{} fs := &stats.FollowerStats{}
p := newPipeline(newRespRoundTripper(0, errors.New("blah")), picker, types.ID(1), types.ID(1), fs, &fakeRaft{}, nil) p := newPipeline(newRespRoundTripper(0, errors.New("blah")), picker, types.ID(1), types.ID(1), fs, &fakeRaft{}, nil)
@ -106,7 +106,7 @@ func TestPipelineSendFailed(t *testing.T) {
func TestPipelinePost(t *testing.T) { func TestPipelinePost(t *testing.T) {
tr := &roundTripperRecorder{} tr := &roundTripperRecorder{}
picker := mustNewURLPicker(t, []string{"http://localhost:7001"}) picker := mustNewURLPicker(t, []string{"http://localhost:2380"})
p := newPipeline(tr, picker, types.ID(1), types.ID(1), nil, &fakeRaft{}, nil) p := newPipeline(tr, picker, types.ID(1), types.ID(1), nil, &fakeRaft{}, nil)
if err := p.post([]byte("some data")); err != nil { if err := p.post([]byte("some data")); err != nil {
t.Fatalf("unexpect post error: %v", err) t.Fatalf("unexpect post error: %v", err)
@ -116,8 +116,8 @@ func TestPipelinePost(t *testing.T) {
if g := tr.Request().Method; g != "POST" { if g := tr.Request().Method; g != "POST" {
t.Errorf("method = %s, want %s", g, "POST") t.Errorf("method = %s, want %s", g, "POST")
} }
if g := tr.Request().URL.String(); g != "http://localhost:7001/raft" { if g := tr.Request().URL.String(); g != "http://localhost:2380/raft" {
t.Errorf("url = %s, want %s", g, "http://localhost:7001/raft") t.Errorf("url = %s, want %s", g, "http://localhost:2380/raft")
} }
if g := tr.Request().Header.Get("Content-Type"); g != "application/protobuf" { if g := tr.Request().Header.Get("Content-Type"); g != "application/protobuf" {
t.Errorf("content type = %s, want %s", g, "application/protobuf") t.Errorf("content type = %s, want %s", g, "application/protobuf")
@ -141,10 +141,10 @@ func TestPipelinePostBad(t *testing.T) {
err error err error
}{ }{
// RoundTrip returns error // RoundTrip returns error
{"http://localhost:7001", 0, errors.New("blah")}, {"http://localhost:2380", 0, errors.New("blah")},
// unexpected response status code // unexpected response status code
{"http://localhost:7001", http.StatusOK, nil}, {"http://localhost:2380", http.StatusOK, nil},
{"http://localhost:7001", http.StatusCreated, nil}, {"http://localhost:2380", http.StatusCreated, nil},
} }
for i, tt := range tests { for i, tt := range tests {
picker := mustNewURLPicker(t, []string{tt.u}) picker := mustNewURLPicker(t, []string{tt.u})
@ -164,8 +164,8 @@ func TestPipelinePostErrorc(t *testing.T) {
code int code int
err error err error
}{ }{
{"http://localhost:7001", http.StatusForbidden, nil}, {"http://localhost:2380", http.StatusForbidden, nil},
{"http://localhost:7001", http.StatusPreconditionFailed, nil}, {"http://localhost:2380", http.StatusPreconditionFailed, nil},
} }
for i, tt := range tests { for i, tt := range tests {
picker := mustNewURLPicker(t, []string{tt.u}) picker := mustNewURLPicker(t, []string{tt.u})

6
rafthttp/stream_test.go
View File

@ -86,7 +86,7 @@ func TestStreamReaderDialRequest(t *testing.T) {
tr := &roundTripperRecorder{} tr := &roundTripperRecorder{}
sr := &streamReader{ sr := &streamReader{
tr: tr, tr: tr,
picker: mustNewURLPicker(t, []string{"http://localhost:7001"}), picker: mustNewURLPicker(t, []string{"http://localhost:2380"}),
t: tt, t: tt,
from: types.ID(1), from: types.ID(1),
to: types.ID(2), to: types.ID(2),
@ -96,7 +96,7 @@ func TestStreamReaderDialRequest(t *testing.T) {
sr.dial() sr.dial()
req := tr.Request() req := tr.Request()
wurl := fmt.Sprintf("http://localhost:7001" + tt.endpoint() + "/1") wurl := fmt.Sprintf("http://localhost:2380" + tt.endpoint() + "/1")
if req.URL.String() != wurl { if req.URL.String() != wurl {
t.Errorf("#%d: url = %s, want %s", i, req.URL.String(), wurl) t.Errorf("#%d: url = %s, want %s", i, req.URL.String(), wurl)
} }
@ -133,7 +133,7 @@ func TestStreamReaderDialResult(t *testing.T) {
tr := newRespRoundTripper(tt.code, tt.err) tr := newRespRoundTripper(tt.code, tt.err)
sr := &streamReader{ sr := &streamReader{
tr: tr, tr: tr,
picker: mustNewURLPicker(t, []string{"http://localhost:7001"}), picker: mustNewURLPicker(t, []string{"http://localhost:2380"}),
t: streamTypeMessage, t: streamTypeMessage,
from: types.ID(1), from: types.ID(1),
to: types.ID(2), to: types.ID(2),

12
rafthttp/transport_test.go
View File

@ -72,7 +72,7 @@ func TestTransportAdd(t *testing.T) {
leaderStats: ls, leaderStats: ls,
peers: make(map[types.ID]Peer), peers: make(map[types.ID]Peer),
} }
tr.AddPeer(1, []string{"http://localhost:7001"}) tr.AddPeer(1, []string{"http://localhost:2380"})
defer tr.Stop() defer tr.Stop()
if _, ok := ls.Followers["1"]; !ok { if _, ok := ls.Followers["1"]; !ok {
@ -84,7 +84,7 @@ func TestTransportAdd(t *testing.T) {
} }
// duplicate AddPeer is ignored // duplicate AddPeer is ignored
tr.AddPeer(1, []string{"http://localhost:7001"}) tr.AddPeer(1, []string{"http://localhost:2380"})
ns := tr.peers[types.ID(1)] ns := tr.peers[types.ID(1)]
if s != ns { if s != ns {
t.Errorf("sender = %v, want %v", ns, s) t.Errorf("sender = %v, want %v", ns, s)
@ -97,7 +97,7 @@ func TestTransportRemove(t *testing.T) {
leaderStats: stats.NewLeaderStats(""), leaderStats: stats.NewLeaderStats(""),
peers: make(map[types.ID]Peer), peers: make(map[types.ID]Peer),
} }
tr.AddPeer(1, []string{"http://localhost:7001"}) tr.AddPeer(1, []string{"http://localhost:2380"})
tr.RemovePeer(types.ID(1)) tr.RemovePeer(types.ID(1))
defer tr.Stop() defer tr.Stop()
@ -111,9 +111,9 @@ func TestTransportUpdate(t *testing.T) {
tr := &transport{ tr := &transport{
peers: map[types.ID]Peer{types.ID(1): peer}, peers: map[types.ID]Peer{types.ID(1): peer},
} }
u := "http://localhost:7001" u := "http://localhost:2380"
tr.UpdatePeer(types.ID(1), []string{u}) tr.UpdatePeer(types.ID(1), []string{u})
wurls := types.URLs(testutil.MustNewURLs(t, []string{"http://localhost:7001"})) wurls := types.URLs(testutil.MustNewURLs(t, []string{"http://localhost:2380"}))
if !reflect.DeepEqual(peer.urls, wurls) { if !reflect.DeepEqual(peer.urls, wurls) {
t.Errorf("urls = %+v, want %+v", peer.urls, wurls) t.Errorf("urls = %+v, want %+v", peer.urls, wurls)
} }
@ -127,7 +127,7 @@ func TestTransportErrorc(t *testing.T) {
peers: make(map[types.ID]Peer), peers: make(map[types.ID]Peer),
errorc: errorc, errorc: errorc,
} }
tr.AddPeer(1, []string{"http://localhost:7001"}) tr.AddPeer(1, []string{"http://localhost:2380"})
defer tr.Stop() defer tr.Stop()
select { select {