mirror of
https://github.com/etcd-io/etcd.git
synced 2024-09-27 06:25:44 +00:00
415 lines
10 KiB
Go
415 lines
10 KiB
Go
package functional
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"os"
|
|
"os/exec"
|
|
"path"
|
|
"path/filepath"
|
|
"testing"
|
|
)
|
|
|
|
var (
|
|
v1BinPath = path.Join(binDir, "1")
|
|
v2BinPath = path.Join(binDir, "2")
|
|
etcdctlBinPath string
|
|
)
|
|
|
|
func init() {
|
|
os.RemoveAll(binDir)
|
|
if err := os.Mkdir(binDir, 0700); err != nil {
|
|
fmt.Printf("unexpected Mkdir error: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
if err := os.Symlink(absPathFromEnv("ETCD_V1_BIN"), v1BinPath); err != nil {
|
|
fmt.Printf("unexpected Symlink error: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
if err := os.Symlink(absPathFromEnv("ETCD_V2_BIN"), v2BinPath); err != nil {
|
|
fmt.Printf("unexpected Symlink error: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
etcdctlBinPath = os.Getenv("ETCDCTL_BIN")
|
|
|
|
mustExist(v1BinPath)
|
|
mustExist(v2BinPath)
|
|
mustExist(etcdctlBinPath)
|
|
}
|
|
|
|
func TestStartNewMember(t *testing.T) {
|
|
tests := []*Proc{
|
|
NewProcWithDefaultFlags(v2BinPath),
|
|
NewProcWithV1Flags(v2BinPath),
|
|
NewProcWithV2Flags(v2BinPath),
|
|
}
|
|
for i, tt := range tests {
|
|
if err := tt.Start(); err != nil {
|
|
t.Fatalf("#%d: Start error: %v", i, err)
|
|
}
|
|
defer tt.Terminate()
|
|
|
|
ver, err := checkInternalVersion(tt.URL)
|
|
if err != nil {
|
|
t.Fatalf("#%d: checkVersion error: %v", i, err)
|
|
}
|
|
if ver != "2" {
|
|
t.Errorf("#%d: internal version = %s, want %s", i, ver, "2")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStartV2Member(t *testing.T) {
|
|
tests := []*Proc{
|
|
NewProcWithDefaultFlags(v2BinPath),
|
|
NewProcWithV1Flags(v2BinPath),
|
|
NewProcWithV2Flags(v2BinPath),
|
|
}
|
|
for i, tt := range tests {
|
|
// get v2 data dir
|
|
p := NewProcWithDefaultFlags(v2BinPath)
|
|
if err := p.Start(); err != nil {
|
|
t.Fatalf("#%d: Start error: %v", i, err)
|
|
}
|
|
p.Stop()
|
|
tt.SetDataDir(p.DataDir)
|
|
if err := tt.Start(); err != nil {
|
|
t.Fatalf("#%d: Start error: %v", i, err)
|
|
}
|
|
defer tt.Terminate()
|
|
|
|
ver, err := checkInternalVersion(tt.URL)
|
|
if err != nil {
|
|
t.Fatalf("#%d: checkVersion error: %v", i, err)
|
|
}
|
|
if ver != "2" {
|
|
t.Errorf("#%d: internal version = %s, want %s", i, ver, "2")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestStartV1Member(t *testing.T) {
|
|
tests := []*Proc{
|
|
NewProcWithDefaultFlags(v2BinPath),
|
|
NewProcWithV1Flags(v2BinPath),
|
|
NewProcWithV2Flags(v2BinPath),
|
|
}
|
|
for i, tt := range tests {
|
|
// get v1 data dir
|
|
p := NewProcWithDefaultFlags(v1BinPath)
|
|
if err := p.Start(); err != nil {
|
|
t.Fatalf("#%d: Start error: %v", i, err)
|
|
}
|
|
p.Stop()
|
|
tt.SetDataDir(p.DataDir)
|
|
if err := tt.Start(); err != nil {
|
|
t.Fatalf("#%d: Start error: %v", i, err)
|
|
}
|
|
defer tt.Terminate()
|
|
|
|
ver, err := checkInternalVersion(tt.URL)
|
|
if err != nil {
|
|
t.Fatalf("#%d: checkVersion error: %v", i, err)
|
|
}
|
|
if ver != "1" {
|
|
t.Errorf("#%d: internal version = %s, want %s", i, ver, "1")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestUpgradeV1Cluster(t *testing.T) {
|
|
// get v2-desired v1 data dir
|
|
pg := NewProcGroupWithV1Flags(v1BinPath, 3)
|
|
if err := pg.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
cmd := exec.Command(etcdctlBinPath, "upgrade", "--peer-url", pg[1].PeerURL)
|
|
if err := cmd.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
if err := cmd.Wait(); err != nil {
|
|
t.Fatalf("Wait error: %v", err)
|
|
}
|
|
t.Logf("wait until etcd exits...")
|
|
if err := pg.Wait(); err != nil {
|
|
t.Fatalf("Wait error: %v", err)
|
|
}
|
|
|
|
npg := NewProcGroupWithV1Flags(v2BinPath, 3)
|
|
npg.InheritDataDir(pg)
|
|
npg.CleanUnsuppportedV1Flags()
|
|
if err := npg.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
defer npg.Terminate()
|
|
|
|
for _, p := range npg {
|
|
ver, err := checkInternalVersion(p.URL)
|
|
if err != nil {
|
|
t.Fatalf("checkVersion error: %v", err)
|
|
}
|
|
if ver != "2" {
|
|
t.Errorf("internal version = %s, want %s", ver, "2")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestUpgradeV1SnapshotedCluster(t *testing.T) {
|
|
// get v2-desired v1 data dir
|
|
pg := NewProcGroupWithV1Flags(v1BinPath, 3)
|
|
pg.SetSnapCount(10)
|
|
if err := pg.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
cmd := exec.Command(etcdctlBinPath, "upgrade", "--peer-url", pg[1].PeerURL)
|
|
if err := cmd.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
if err := cmd.Wait(); err != nil {
|
|
t.Fatalf("Wait error: %v", err)
|
|
}
|
|
t.Logf("wait until etcd exits...")
|
|
if err := pg.Wait(); err != nil {
|
|
t.Fatalf("Wait error: %v", err)
|
|
}
|
|
for _, p := range pg {
|
|
// check it has taken snapshot
|
|
fis, err := ioutil.ReadDir(path.Join(p.DataDir, "snapshot"))
|
|
if err != nil {
|
|
t.Fatalf("unexpected ReadDir error: %v", err)
|
|
}
|
|
if len(fis) == 0 {
|
|
t.Fatalf("unexpected no-snapshot data dir")
|
|
}
|
|
}
|
|
|
|
npg := NewProcGroupWithV1Flags(v2BinPath, 3)
|
|
npg.InheritDataDir(pg)
|
|
npg.CleanUnsuppportedV1Flags()
|
|
if err := npg.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
defer npg.Terminate()
|
|
|
|
for _, p := range npg {
|
|
ver, err := checkInternalVersion(p.URL)
|
|
if err != nil {
|
|
t.Fatalf("checkVersion error: %v", err)
|
|
}
|
|
if ver != "2" {
|
|
t.Errorf("internal version = %s, want %s", ver, "2")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestJoinV1Cluster(t *testing.T) {
|
|
pg := NewProcGroupWithV1Flags(v1BinPath, 1)
|
|
if err := pg.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
pg.Stop()
|
|
npg := NewProcGroupWithV1Flags(v2BinPath, 3)
|
|
npg[0].SetDataDir(pg[0].DataDir)
|
|
if err := npg.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
defer npg.Terminate()
|
|
|
|
for _, p := range npg {
|
|
ver, err := checkInternalVersion(p.URL)
|
|
if err != nil {
|
|
t.Fatalf("checkVersion error: %v", err)
|
|
}
|
|
if ver != "1" {
|
|
t.Errorf("internal version = %s, want %s", ver, "1")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestJoinV1ClusterViaDiscovery(t *testing.T) {
|
|
dp := NewProcWithDefaultFlags(v1BinPath)
|
|
dp.SetV1Addr("127.0.0.1:5001")
|
|
dp.SetV1PeerAddr("127.0.0.1:8001")
|
|
if err := dp.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
defer dp.Terminate()
|
|
|
|
durl := "http://127.0.0.1:5001/v2/keys/cluster/"
|
|
pg := NewProcGroupViaDiscoveryWithV1Flags(v1BinPath, 1, durl)
|
|
if err := pg.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
pg.Stop()
|
|
npg := NewProcGroupViaDiscoveryWithV1Flags(v2BinPath, 3, durl)
|
|
npg[0].SetDataDir(pg[0].DataDir)
|
|
if err := npg.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
defer npg.Terminate()
|
|
|
|
for _, p := range npg {
|
|
ver, err := checkInternalVersion(p.URL)
|
|
if err != nil {
|
|
t.Fatalf("checkVersion error: %v", err)
|
|
}
|
|
if ver != "1" {
|
|
t.Errorf("internal version = %s, want %s", ver, "1")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestUpgradeV1Standby(t *testing.T) {
|
|
// get v1 standby data dir
|
|
pg := NewProcGroupWithV1Flags(v1BinPath, 3)
|
|
if err := pg.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
req, err := http.NewRequest("PUT", pg[0].PeerURL+"/v2/admin/config", bytes.NewBufferString(`{"activeSize":3,"removeDelay":1800,"syncInterval":5}`))
|
|
if err != nil {
|
|
t.Fatalf("NewRequest error: %v", err)
|
|
}
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
t.Fatalf("http Do error: %v", err)
|
|
}
|
|
if resp.StatusCode != http.StatusOK {
|
|
t.Fatalf("status = %d, want %d", resp.StatusCode, http.StatusOK)
|
|
}
|
|
|
|
p := NewProcInProcGroupWithV1Flags(v2BinPath, 4, 3)
|
|
if err := p.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
fmt.Println("checking new member is in standby mode...")
|
|
mustExist(path.Join(p.DataDir, "standby_info"))
|
|
ver, err := checkInternalVersion(p.URL)
|
|
if err != nil {
|
|
t.Fatalf("checkVersion error: %v", err)
|
|
}
|
|
if ver != "1" {
|
|
t.Errorf("internal version = %s, want %s", ver, "1")
|
|
}
|
|
|
|
fmt.Println("upgrading the whole cluster...")
|
|
cmd := exec.Command(etcdctlBinPath, "upgrade", "--peer-url", pg[0].PeerURL)
|
|
if err := cmd.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
if err := cmd.Wait(); err != nil {
|
|
t.Fatalf("Wait error: %v", err)
|
|
}
|
|
fmt.Println("waiting until peer-mode etcd exits...")
|
|
if err := pg.Wait(); err != nil {
|
|
t.Fatalf("Wait error: %v", err)
|
|
}
|
|
fmt.Println("restarting the peer-mode etcd...")
|
|
npg := NewProcGroupWithV1Flags(v2BinPath, 3)
|
|
npg.InheritDataDir(pg)
|
|
npg.CleanUnsuppportedV1Flags()
|
|
if err := npg.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
defer npg.Terminate()
|
|
fmt.Println("waiting until standby-mode etcd exits...")
|
|
if err := p.Wait(); err != nil {
|
|
t.Fatalf("Wait error: %v", err)
|
|
}
|
|
fmt.Println("restarting the standby-mode etcd...")
|
|
np := NewProcInProcGroupWithV1Flags(v2BinPath, 4, 3)
|
|
np.SetDataDir(p.DataDir)
|
|
np.CleanUnsuppportedV1Flags()
|
|
if err := np.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
defer np.Terminate()
|
|
|
|
fmt.Println("checking the new member is in v2 proxy mode...")
|
|
ver, err = checkInternalVersion(np.URL)
|
|
if err != nil {
|
|
t.Fatalf("checkVersion error: %v", err)
|
|
}
|
|
if ver != "2" {
|
|
t.Errorf("internal version = %s, want %s", ver, "1")
|
|
}
|
|
if _, err := os.Stat(path.Join(np.DataDir, "proxy")); err != nil {
|
|
t.Errorf("stat proxy dir error = %v, want nil", err)
|
|
}
|
|
}
|
|
|
|
func TestUpgradeV1TLSCluster(t *testing.T) {
|
|
// get v2-desired v1 data dir
|
|
pg := NewProcGroupWithV1Flags(v1BinPath, 3)
|
|
pg.SetPeerTLS("./fixtures/server.crt", "./fixtures/server.key.insecure", "./fixtures/ca.crt")
|
|
if err := pg.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
cmd := exec.Command(etcdctlBinPath,
|
|
"upgrade", "--peer-url", pg[1].PeerURL,
|
|
"--peer-cert-file", "./fixtures/server.crt",
|
|
"--peer-key-file", "./fixtures/server.key.insecure",
|
|
"--peer-ca-file", "./fixtures/ca.crt",
|
|
)
|
|
if err := cmd.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
if err := cmd.Wait(); err != nil {
|
|
t.Fatalf("Wait error: %v", err)
|
|
}
|
|
t.Logf("wait until etcd exits...")
|
|
if err := pg.Wait(); err != nil {
|
|
t.Fatalf("Wait error: %v", err)
|
|
}
|
|
|
|
npg := NewProcGroupWithV1Flags(v2BinPath, 3)
|
|
npg.SetPeerTLS("./fixtures/server.crt", "./fixtures/server.key.insecure", "./fixtures/ca.crt")
|
|
npg.InheritDataDir(pg)
|
|
npg.CleanUnsuppportedV1Flags()
|
|
if err := npg.Start(); err != nil {
|
|
t.Fatalf("Start error: %v", err)
|
|
}
|
|
defer npg.Terminate()
|
|
|
|
for _, p := range npg {
|
|
ver, err := checkInternalVersion(p.URL)
|
|
if err != nil {
|
|
t.Fatalf("checkVersion error: %v", err)
|
|
}
|
|
if ver != "2" {
|
|
t.Errorf("internal version = %s, want %s", ver, "2")
|
|
}
|
|
}
|
|
}
|
|
|
|
func absPathFromEnv(name string) string {
|
|
path, err := filepath.Abs(os.Getenv(name))
|
|
if err != nil {
|
|
fmt.Printf("unexpected Abs error: %v\n", err)
|
|
}
|
|
return path
|
|
}
|
|
|
|
func mustExist(path string) {
|
|
if _, err := os.Stat(path); err != nil {
|
|
fmt.Printf("%v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func checkInternalVersion(url string) (string, error) {
|
|
resp, err := http.Get(url + "/version")
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
b, err := ioutil.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
var m map[string]string
|
|
err = json.Unmarshal(b, &m)
|
|
return m["internalVersion"], err
|
|
}
|