From b50f96e2e13d2b4962c58374209143cd0b6efb46 Mon Sep 17 00:00:00 2001
From: Yicheng Qin <qycqycqycqycqyc@gmail.com>
Date: Tue, 9 Sep 2014 16:33:09 -0700
Subject: [PATCH 01/11] raft: set none to be 0

---
 raft/node_test.go |   6 +-
 raft/raft.go      |   2 +-
 raft/raft_test.go | 205 +++++++++++++++++++++++-----------------------
 3 files changed, 107 insertions(+), 106 deletions(-)

diff --git a/raft/node_test.go b/raft/node_test.go
index 10e586e74..12e5d6f67 100644
--- a/raft/node_test.go
+++ b/raft/node_test.go
@@ -14,12 +14,12 @@ func TestNode(t *testing.T) {
 
 	wants := []Ready{
 		{
-			State:            raftpb.State{Term: 1, Vote: -1, Commit: 1, LastIndex: 1},
+			State:            raftpb.State{Term: 1, Vote: none, Commit: 1, LastIndex: 1},
 			Entries:          []raftpb.Entry{{Term: 1, Index: 1}},
 			CommittedEntries: []raftpb.Entry{{Term: 1, Index: 1}},
 		},
 		{
-			State:            raftpb.State{Term: 1, Vote: -1, Commit: 2, LastIndex: 2},
+			State:            raftpb.State{Term: 1, Vote: none, Commit: 2, LastIndex: 2},
 			Entries:          []raftpb.Entry{{Term: 1, Index: 2, Data: []byte("foo")}},
 			CommittedEntries: []raftpb.Entry{{Term: 1, Index: 2, Data: []byte("foo")}},
 		},
@@ -48,7 +48,7 @@ func TestNodeRestart(t *testing.T) {
 		{Term: 1, Index: 1},
 		{Term: 1, Index: 2, Data: []byte("foo")},
 	}
-	st := raftpb.State{Term: 1, Vote: -1, Commit: 1, LastIndex: 2}
+	st := raftpb.State{Term: 1, Vote: none, Commit: 1, LastIndex: 2}
 
 	want := Ready{
 		State: emptyState,
diff --git a/raft/raft.go b/raft/raft.go
index 2245749f0..2b6788363 100644
--- a/raft/raft.go
+++ b/raft/raft.go
@@ -8,7 +8,7 @@ import (
 	pb "github.com/coreos/etcd/raft/raftpb"
 )
 
-const none = -1
+const none = 0
 
 type messageType int64
 
diff --git a/raft/raft_test.go b/raft/raft_test.go
index ddf612aaf..7735d1510 100644
--- a/raft/raft_test.go
+++ b/raft/raft_test.go
@@ -41,8 +41,8 @@ func TestLeaderElection(t *testing.T) {
 	}
 
 	for i, tt := range tests {
-		tt.send(pb.Message{From: 0, To: 0, Type: msgHup})
-		sm := tt.network.peers[0].(*raft)
+		tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
+		sm := tt.network.peers[0x1000].(*raft)
 		if sm.state != tt.state {
 			t.Errorf("#%d: state = %s, want %s", i, sm.state, tt.state)
 		}
@@ -61,24 +61,23 @@ func TestLogReplication(t *testing.T) {
 		{
 			newNetwork(nil, nil, nil),
 			[]pb.Message{
-				{From: 0, To: 0, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
+				{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
 			},
 			2,
 		},
 		{
 			newNetwork(nil, nil, nil),
 			[]pb.Message{
-
-				{From: 0, To: 0, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
-				{From: 0, To: 1, Type: msgHup},
-				{From: 0, To: 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
+				{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
+				{From: none, To: 0x1001, Type: msgHup},
+				{From: none, To: 0x1001, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
 			},
 			4,
 		},
 	}
 
 	for i, tt := range tests {
-		tt.send(pb.Message{From: 0, To: 0, Type: msgHup})
+		tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
 
 		for _, m := range tt.msgs {
 			tt.send(m)
@@ -114,11 +113,11 @@ func TestLogReplication(t *testing.T) {
 
 func TestSingleNodeCommit(t *testing.T) {
 	tt := newNetwork(nil)
-	tt.send(pb.Message{From: 0, To: 0, Type: msgHup})
-	tt.send(pb.Message{From: 0, To: 0, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
-	tt.send(pb.Message{From: 0, To: 0, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
+	tt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
-	sm := tt.peers[0].(*raft)
+	sm := tt.peers[0x1000].(*raft)
 	if sm.raftLog.committed != 3 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 3)
 	}
@@ -129,17 +128,17 @@ func TestSingleNodeCommit(t *testing.T) {
 // filtered.
 func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 	tt := newNetwork(nil, nil, nil, nil, nil)
-	tt.send(pb.Message{From: 0, To: 0, Type: msgHup})
+	tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
 
 	// 0 cannot reach 2,3,4
-	tt.cut(0, 2)
-	tt.cut(0, 3)
-	tt.cut(0, 4)
+	tt.cut(0x1000, 0x1002)
+	tt.cut(0x1000, 0x1003)
+	tt.cut(0x1000, 0x1004)
 
-	tt.send(pb.Message{From: 0, To: 0, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
-	tt.send(pb.Message{From: 0, To: 0, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
-	sm := tt.peers[0].(*raft)
+	sm := tt.peers[0x1000].(*raft)
 	if sm.raftLog.committed != 1 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 1)
 	}
@@ -150,10 +149,10 @@ func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 	tt.ignore(msgApp)
 
 	// elect 1 as the new leader with term 2
-	tt.send(pb.Message{From: 1, To: 1, Type: msgHup})
+	tt.send(pb.Message{From: none, To: 0x1001, Type: msgHup})
 
 	// no log entries from previous term should be committed
-	sm = tt.peers[1].(*raft)
+	sm = tt.peers[0x1001].(*raft)
 	if sm.raftLog.committed != 1 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 1)
 	}
@@ -163,14 +162,14 @@ func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 	// send out a heartbeat
 	// after append a ChangeTerm entry from the current term, all entries
 	// should be committed
-	tt.send(pb.Message{From: 1, To: 1, Type: msgBeat})
+	tt.send(pb.Message{From: none, To: 0x1001, Type: msgBeat})
 
 	if sm.raftLog.committed != 4 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 4)
 	}
 
 	// still be able to append a entry
-	tt.send(pb.Message{From: 1, To: 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: none, To: 0x1001, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
 	if sm.raftLog.committed != 5 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 5)
@@ -181,17 +180,17 @@ func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 // when leader changes, no new proposal comes in.
 func TestCommitWithoutNewTermEntry(t *testing.T) {
 	tt := newNetwork(nil, nil, nil, nil, nil)
-	tt.send(pb.Message{From: 0, To: 0, Type: msgHup})
+	tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
 
 	// 0 cannot reach 2,3,4
-	tt.cut(0, 2)
-	tt.cut(0, 3)
-	tt.cut(0, 4)
+	tt.cut(0x1000, 0x1002)
+	tt.cut(0x1000, 0x1003)
+	tt.cut(0x1000, 0x1004)
 
-	tt.send(pb.Message{From: 0, To: 0, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
-	tt.send(pb.Message{From: 0, To: 0, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
-	sm := tt.peers[0].(*raft)
+	sm := tt.peers[0x1000].(*raft)
 	if sm.raftLog.committed != 1 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 1)
 	}
@@ -202,7 +201,7 @@ func TestCommitWithoutNewTermEntry(t *testing.T) {
 	// elect 1 as the new leader with term 2
 	// after append a ChangeTerm entry from the current term, all entries
 	// should be committed
-	tt.send(pb.Message{From: 1, To: 1, Type: msgHup})
+	tt.send(pb.Message{From: none, To: 0x1001, Type: msgHup})
 
 	if sm.raftLog.committed != 4 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 4)
@@ -210,18 +209,18 @@ func TestCommitWithoutNewTermEntry(t *testing.T) {
 }
 
 func TestDuelingCandidates(t *testing.T) {
-	a := newRaft(0, nil, 0, 0) // k, id are set later
-	b := newRaft(0, nil, 0, 0)
-	c := newRaft(0, nil, 0, 0)
+	a := newRaft(-1, nil, 0, 0) // k, id are set later
+	b := newRaft(-1, nil, 0, 0)
+	c := newRaft(-1, nil, 0, 0)
 
 	nt := newNetwork(a, b, c)
-	nt.cut(0, 2)
+	nt.cut(0x1000, 0x1002)
 
-	nt.send(pb.Message{From: 0, To: 0, Type: msgHup})
-	nt.send(pb.Message{From: 2, To: 2, Type: msgHup})
+	nt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
+	nt.send(pb.Message{From: none, To: 0x1002, Type: msgHup})
 
 	nt.recover()
-	nt.send(pb.Message{From: 2, To: 2, Type: msgHup})
+	nt.send(pb.Message{From: none, To: 0x1002, Type: msgHup})
 
 	wlog := &raftLog{ents: []pb.Entry{{}, pb.Entry{Data: nil, Term: 1, Index: 1}}, committed: 1}
 	tests := []struct {
@@ -243,7 +242,7 @@ func TestDuelingCandidates(t *testing.T) {
 			t.Errorf("#%d: term = %d, want %d", i, g, tt.term)
 		}
 		base := ltoa(tt.raftLog)
-		if sm, ok := nt.peers[int64(i)].(*raft); ok {
+		if sm, ok := nt.peers[int64(0x1000+i)].(*raft); ok {
 			l := ltoa(sm.raftLog)
 			if g := diffu(base, l); g != "" {
 				t.Errorf("#%d: diff:\n%s", i, g)
@@ -256,19 +255,19 @@ func TestDuelingCandidates(t *testing.T) {
 
 func TestCandidateConcede(t *testing.T) {
 	tt := newNetwork(nil, nil, nil)
-	tt.isolate(0)
+	tt.isolate(0x1000)
 
-	tt.send(pb.Message{From: 0, To: 0, Type: msgHup})
-	tt.send(pb.Message{From: 2, To: 2, Type: msgHup})
+	tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
+	tt.send(pb.Message{From: none, To: 0x1002, Type: msgHup})
 
 	// heal the partition
 	tt.recover()
 
 	data := []byte("force follower")
 	// send a proposal to 2 to flush out a msgApp to 0
-	tt.send(pb.Message{From: 2, To: 2, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
+	tt.send(pb.Message{From: none, To: 0x1002, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
 
-	a := tt.peers[0].(*raft)
+	a := tt.peers[0x1000].(*raft)
 	if g := a.state; g != stateFollower {
 		t.Errorf("state = %s, want %s", g, stateFollower)
 	}
@@ -290,9 +289,9 @@ func TestCandidateConcede(t *testing.T) {
 
 func TestSingleNodeCandidate(t *testing.T) {
 	tt := newNetwork(nil)
-	tt.send(pb.Message{From: 0, To: 0, Type: msgHup})
+	tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
 
-	sm := tt.peers[0].(*raft)
+	sm := tt.peers[0x1000].(*raft)
 	if sm.state != stateLeader {
 		t.Errorf("state = %d, want %d", sm.state, stateLeader)
 	}
@@ -301,11 +300,11 @@ func TestSingleNodeCandidate(t *testing.T) {
 func TestOldMessages(t *testing.T) {
 	tt := newNetwork(nil, nil, nil)
 	// make 0 leader @ term 3
-	tt.send(pb.Message{From: 0, To: 0, Type: msgHup})
-	tt.send(pb.Message{From: 1, To: 1, Type: msgHup})
-	tt.send(pb.Message{From: 0, To: 0, Type: msgHup})
+	tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
+	tt.send(pb.Message{From: none, To: 0x1001, Type: msgHup})
+	tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
 	// pretend we're an old leader trying to make progress
-	tt.send(pb.Message{From: 0, To: 0, Type: msgApp, Term: 1, Entries: []pb.Entry{{Term: 1}}})
+	tt.send(pb.Message{From: none, To: 0x1000, Type: msgApp, Term: 1, Entries: []pb.Entry{{Term: 1}}})
 
 	l := &raftLog{
 		ents: []pb.Entry{
@@ -359,8 +358,8 @@ func TestProposal(t *testing.T) {
 		data := []byte("somedata")
 
 		// promote 0 the leader
-		send(pb.Message{From: 0, To: 0, Type: msgHup})
-		send(pb.Message{From: 0, To: 0, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
+		send(pb.Message{From: none, To: 0x1000, Type: msgHup})
+		send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
 
 		wantLog := newLog()
 		if tt.success {
@@ -377,7 +376,7 @@ func TestProposal(t *testing.T) {
 				t.Logf("#%d: empty log", i)
 			}
 		}
-		sm := tt.network.peers[0].(*raft)
+		sm := tt.network.peers[0x1000].(*raft)
 		if g := sm.Term; g != 1 {
 			t.Errorf("#%d: term = %d, want %d", i, g, 1)
 		}
@@ -393,10 +392,10 @@ func TestProposalByProxy(t *testing.T) {
 
 	for i, tt := range tests {
 		// promote 0 the leader
-		tt.send(pb.Message{From: 0, To: 0, Type: msgHup})
+		tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
 
 		// propose via follower
-		tt.send(pb.Message{From: 1, To: 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}})
+		tt.send(pb.Message{From: none, To: 0x1001, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}})
 
 		wantLog := &raftLog{ents: []pb.Entry{{}, {Data: nil, Term: 1, Index: 1}, {Term: 1, Data: data, Index: 2}}, committed: 2}
 		base := ltoa(wantLog)
@@ -410,7 +409,7 @@ func TestProposalByProxy(t *testing.T) {
 				t.Logf("#%d: empty log", i)
 			}
 		}
-		sm := tt.peers[0].(*raft)
+		sm := tt.peers[0x1000].(*raft)
 		if g := sm.Term; g != 1 {
 			t.Errorf("#%d: term = %d, want %d", i, g, 1)
 		}
@@ -465,7 +464,7 @@ func TestStepIgnoreOldTermMsg(t *testing.T) {
 	fakeStep := func(r *raft, m pb.Message) {
 		called = true
 	}
-	sm := newRaft(0, []int64{0}, 0, 0)
+	sm := newRaft(0x1000, []int64{0x1000}, 0, 0)
 	sm.step = fakeStep
 	sm.Term = 2
 	sm.Step(pb.Message{Type: msgApp, Term: sm.Term - 1})
@@ -557,15 +556,15 @@ func TestRecvMsgVote(t *testing.T) {
 		{stateFollower, 3, 2, none, 2},
 		{stateFollower, 3, 3, none, 2},
 
-		{stateFollower, 3, 2, 1, 2},
-		{stateFollower, 3, 2, 0, -1},
+		{stateFollower, 3, 2, 0x1001, 2},
+		{stateFollower, 3, 2, 0x1000, -1},
 
-		{stateLeader, 3, 3, 0, -1},
-		{stateCandidate, 3, 3, 0, -1},
+		{stateLeader, 3, 3, 0x1000, -1},
+		{stateCandidate, 3, 3, 0x1000, -1},
 	}
 
 	for i, tt := range tests {
-		sm := newRaft(0, []int64{0}, 0, 0)
+		sm := newRaft(0x1000, []int64{0x1000}, 0, 0)
 		sm.state = tt.state
 		switch tt.state {
 		case stateFollower:
@@ -578,7 +577,7 @@ func TestRecvMsgVote(t *testing.T) {
 		sm.State = pb.State{Vote: tt.voteFor}
 		sm.raftLog = &raftLog{ents: []pb.Entry{{}, {Term: 2}, {Term: 2}}}
 
-		sm.Step(pb.Message{Type: msgVote, From: 1, Index: tt.i, LogTerm: tt.term})
+		sm.Step(pb.Message{Type: msgVote, From: 0x1001, Index: tt.i, LogTerm: tt.term})
 
 		msgs := sm.ReadMessages()
 		if g := len(msgs); g != 1 {
@@ -605,11 +604,11 @@ func TestStateTransition(t *testing.T) {
 
 		{stateCandidate, stateFollower, true, 0, none},
 		{stateCandidate, stateCandidate, true, 1, none},
-		{stateCandidate, stateLeader, true, 0, 0},
+		{stateCandidate, stateLeader, true, 0, 0x1000},
 
 		{stateLeader, stateFollower, true, 1, none},
 		{stateLeader, stateCandidate, false, 1, none},
-		{stateLeader, stateLeader, true, 0, 0},
+		{stateLeader, stateLeader, true, 0, 0x1000},
 	}
 
 	for i, tt := range tests {
@@ -622,7 +621,7 @@ func TestStateTransition(t *testing.T) {
 				}
 			}()
 
-			sm := newRaft(0, []int64{0}, 0, 0)
+			sm := newRaft(0x1000, []int64{0x1000}, 0, 0)
 			sm.state = tt.from
 
 			switch tt.to {
@@ -661,10 +660,10 @@ func TestAllServerStepdown(t *testing.T) {
 	tterm := int64(3)
 
 	for i, tt := range tests {
-		sm := newRaft(0, []int64{0, 1, 2}, 0, 0)
+		sm := newRaft(0x1000, []int64{0x1000, 0x1001, 0x1002}, 0, 0)
 		switch tt.state {
 		case stateFollower:
-			sm.becomeFollower(1, 0)
+			sm.becomeFollower(1, none)
 		case stateCandidate:
 			sm.becomeCandidate()
 		case stateLeader:
@@ -673,7 +672,7 @@ func TestAllServerStepdown(t *testing.T) {
 		}
 
 		for j, msgType := range tmsgTypes {
-			sm.Step(pb.Message{From: 1, Type: msgType, Term: tterm, LogTerm: tterm})
+			sm.Step(pb.Message{From: 0x1001, Type: msgType, Term: tterm, LogTerm: tterm})
 
 			if sm.state != tt.wstate {
 				t.Errorf("#%d.%d state = %v , want %v", i, j, sm.state, tt.wstate)
@@ -684,7 +683,7 @@ func TestAllServerStepdown(t *testing.T) {
 			if int64(len(sm.raftLog.ents)) != tt.windex {
 				t.Errorf("#%d.%d index = %v , want %v", i, j, len(sm.raftLog.ents), tt.windex)
 			}
-			wlead := int64(1)
+			wlead := int64(0x1001)
 			if msgType == msgVote {
 				wlead = none
 			}
@@ -709,12 +708,12 @@ func TestLeaderAppResp(t *testing.T) {
 	for i, tt := range tests {
 		// sm term is 1 after it becomes the leader.
 		// thus the last log term must be 1 to be committed.
-		sm := newRaft(0, []int64{0, 1, 2}, 0, 0)
+		sm := newRaft(0x1000, []int64{0x1000, 0x1001, 0x1002}, 0, 0)
 		sm.raftLog = &raftLog{ents: []pb.Entry{{}, {Term: 0}, {Term: 1}}}
 		sm.becomeCandidate()
 		sm.becomeLeader()
 		sm.ReadMessages()
-		sm.Step(pb.Message{From: 1, Type: msgAppResp, Index: tt.index, Term: sm.Term})
+		sm.Step(pb.Message{From: 0x1001, Type: msgAppResp, Index: tt.index, Term: sm.Term})
 		msgs := sm.ReadMessages()
 
 		if len(msgs) != tt.wmsgNum {
@@ -744,7 +743,7 @@ func TestRecvMsgBeat(t *testing.T) {
 	}
 
 	for i, tt := range tests {
-		sm := newRaft(0, []int64{0, 1, 2}, 0, 0)
+		sm := newRaft(0x1000, []int64{0x1000, 0x1001, 0x1002}, 0, 0)
 		sm.raftLog = &raftLog{ents: []pb.Entry{{}, {Term: 0}, {Term: 1}}}
 		sm.Term = 1
 		sm.state = tt.state
@@ -756,7 +755,7 @@ func TestRecvMsgBeat(t *testing.T) {
 		case stateLeader:
 			sm.step = stepLeader
 		}
-		sm.Step(pb.Message{From: 0, To: 0, Type: msgBeat})
+		sm.Step(pb.Message{From: none, To: 0x1000, Type: msgBeat})
 
 		msgs := sm.ReadMessages()
 		if len(msgs) != tt.wMsg {
@@ -774,10 +773,10 @@ func TestRestore(t *testing.T) {
 	s := pb.Snapshot{
 		Index: defaultCompactThreshold + 1,
 		Term:  defaultCompactThreshold + 1,
-		Nodes: []int64{0, 1, 2},
+		Nodes: []int64{0x1000, 0x1001, 0x1002},
 	}
 
-	sm := newRaft(0, []int64{0, 1}, 0, 0)
+	sm := newRaft(0x1000, []int64{0x1000, 0x1001}, 0, 0)
 	if ok := sm.restore(s); !ok {
 		t.Fatal("restore fail, want succeed")
 	}
@@ -808,9 +807,9 @@ func TestProvideSnap(t *testing.T) {
 	s := pb.Snapshot{
 		Index: defaultCompactThreshold + 1,
 		Term:  defaultCompactThreshold + 1,
-		Nodes: []int64{0, 1},
+		Nodes: []int64{0x1000, 0x1001},
 	}
-	sm := newRaft(0, []int64{0}, 0, 0)
+	sm := newRaft(0x1000, []int64{0x1000}, 0, 0)
 	// restore the statemachin from a snapshot
 	// so it has a compacted log and a snapshot
 	sm.restore(s)
@@ -818,7 +817,7 @@ func TestProvideSnap(t *testing.T) {
 	sm.becomeCandidate()
 	sm.becomeLeader()
 
-	sm.Step(pb.Message{From: 0, To: 0, Type: msgBeat})
+	sm.Step(pb.Message{From: none, To: 0x1000, Type: msgBeat})
 	msgs := sm.ReadMessages()
 	if len(msgs) != 1 {
 		t.Errorf("len(msgs) = %d, want 1", len(msgs))
@@ -830,9 +829,9 @@ func TestProvideSnap(t *testing.T) {
 
 	// force set the next of node 1, so that
 	// node 1 needs a snapshot
-	sm.prs[1].next = sm.raftLog.offset
+	sm.prs[0x1001].next = sm.raftLog.offset
 
-	sm.Step(pb.Message{From: 1, To: 0, Type: msgAppResp, Index: -1})
+	sm.Step(pb.Message{From: 0x1001, To: 0x1000, Type: msgAppResp, Index: -1})
 	msgs = sm.ReadMessages()
 	if len(msgs) != 1 {
 		t.Errorf("len(msgs) = %d, want 1", len(msgs))
@@ -847,11 +846,11 @@ func TestRestoreFromSnapMsg(t *testing.T) {
 	s := pb.Snapshot{
 		Index: defaultCompactThreshold + 1,
 		Term:  defaultCompactThreshold + 1,
-		Nodes: []int64{0, 1},
+		Nodes: []int64{0x1000, 0x1001},
 	}
-	m := pb.Message{Type: msgSnap, From: 0, Term: 1, Snapshot: s}
+	m := pb.Message{Type: msgSnap, From: 0x1000, Term: 0x1001, Snapshot: s}
 
-	sm := newRaft(1, []int64{0, 1}, 0, 0)
+	sm := newRaft(0x1001, []int64{0x1000, 0x1001}, 0, 0)
 	sm.Step(m)
 
 	if !reflect.DeepEqual(sm.raftLog.snapshot, s) {
@@ -861,26 +860,26 @@ func TestRestoreFromSnapMsg(t *testing.T) {
 
 func TestSlowNodeRestore(t *testing.T) {
 	nt := newNetwork(nil, nil, nil)
-	nt.send(pb.Message{From: 0, To: 0, Type: msgHup})
+	nt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
 
-	nt.isolate(2)
+	nt.isolate(0x1002)
 	for j := 0; j < defaultCompactThreshold+1; j++ {
-		nt.send(pb.Message{From: 0, To: 0, Type: msgProp, Entries: []pb.Entry{{}}})
+		nt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{}}})
 	}
-	lead := nt.peers[0].(*raft)
+	lead := nt.peers[0x1000].(*raft)
 	lead.nextEnts()
 	lead.compact(nil)
 
 	nt.recover()
-	nt.send(pb.Message{From: 0, To: 0, Type: msgBeat})
+	nt.send(pb.Message{From: none, To: 0x1000, Type: msgBeat})
 
-	follower := nt.peers[2].(*raft)
+	follower := nt.peers[0x1002].(*raft)
 	if !reflect.DeepEqual(follower.raftLog.snapshot, lead.raftLog.snapshot) {
 		t.Errorf("follower.snap = %+v, want %+v", follower.raftLog.snapshot, lead.raftLog.snapshot)
 	}
 
 	committed := follower.raftLog.lastIndex()
-	nt.send(pb.Message{From: 0, To: 0, Type: msgProp, Entries: []pb.Entry{{}}})
+	nt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{}}})
 	if follower.raftLog.committed != committed+1 {
 		t.Errorf("follower.comitted = %d, want %d", follower.raftLog.committed, committed+1)
 	}
@@ -909,29 +908,31 @@ type network struct {
 // When using stateMachine, the address list is always [0, n).
 func newNetwork(peers ...Interface) *network {
 	size := len(peers)
-	defaultPeerAddrs := make([]int64, size)
+	peerAddrs := make([]int64, size)
 	for i := 0; i < size; i++ {
-		defaultPeerAddrs[i] = int64(i)
+		peerAddrs[i] = int64(0x1000 + i)
 	}
 
 	npeers := make(map[int64]Interface, size)
 
-	for id, p := range peers {
-		nid := int64(id)
+	for i, p := range peers {
+		id := peerAddrs[i]
 		switch v := p.(type) {
 		case nil:
-			sm := newRaft(nid, defaultPeerAddrs, 0, 0)
-			npeers[nid] = sm
+			sm := newRaft(id, peerAddrs, 0, 0)
+			npeers[id] = sm
 		case *raft:
-			v.id = nid
+			v.id = id
 			v.prs = make(map[int64]*progress)
 			for i := 0; i < size; i++ {
-				v.prs[int64(i)] = &progress{}
+				v.prs[peerAddrs[i]] = &progress{}
 			}
 			v.reset(0)
-			npeers[nid] = v
+			npeers[id] = v
+		case *blackHole:
+			npeers[id] = v
 		default:
-			npeers[nid] = v
+			panic("unimplemented")
 		}
 	}
 	return &network{
@@ -961,7 +962,7 @@ func (nw *network) cut(one, other int64) {
 
 func (nw *network) isolate(id int64) {
 	for i := 0; i < len(nw.peers); i++ {
-		nid := int64(i)
+		nid := int64(0x1000 + i)
 		if nid != id {
 			nw.drop(id, nid, 1.0)
 			nw.drop(nid, id, 1.0)

From 8c58684fb7110bdf86a7935ceba72a98d87b8f6d Mon Sep 17 00:00:00 2001
From: Yicheng Qin <qycqycqycqycqyc@gmail.com>
Date: Tue, 9 Sep 2014 16:59:42 -0700
Subject: [PATCH 02/11] etcdserver: fix testServer

---
 etcdserver/server_test.go | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/etcdserver/server_test.go b/etcdserver/server_test.go
index 4fc275e0e..0455a928f 100644
--- a/etcdserver/server_test.go
+++ b/etcdserver/server_test.go
@@ -25,17 +25,18 @@ func testServer(t *testing.T, ns int64) {
 	send := func(msgs []raftpb.Message) {
 		for _, m := range msgs {
 			t.Logf("m = %+v\n", m)
-			ss[m.To].Node.Step(ctx, m)
+			ss[m.To-0x1000].Node.Step(ctx, m)
 		}
 	}
 
 	peers := make([]int64, ns)
 	for i := int64(0); i < ns; i++ {
-		peers[i] = i
+		peers[i] = 0x1000 + i
 	}
 
 	for i := int64(0); i < ns; i++ {
-		n := raft.Start(i, peers, 10, 1)
+		id := 0x1000 + i
+		n := raft.Start(id, peers, 10, 1)
 		tk := time.NewTicker(10 * time.Millisecond)
 		defer tk.Stop()
 		srv := &Server{
@@ -52,6 +53,11 @@ func testServer(t *testing.T, ns int64) {
 		ss[i] = srv
 	}
 
+	// TODO: find fast way to trigger leader election
+	// TODO: introduce the way to know that the leader has been elected
+	// then remove this sleep.
+	time.Sleep(110 * time.Millisecond)
+
 	for i := 1; i <= 10; i++ {
 		r := pb.Request{
 			Method: "PUT",

From 4e31bb308db710465c15448da42505db314c40b6 Mon Sep 17 00:00:00 2001
From: Yicheng Qin <qycqycqycqycqyc@gmail.com>
Date: Tue, 9 Sep 2014 19:06:49 -0700
Subject: [PATCH 03/11] raft: use const firstId to track ids

---
 etcdserver/server_test.go |  11 ++-
 raft/raft_test.go         | 183 ++++++++++++++++++++------------------
 2 files changed, 103 insertions(+), 91 deletions(-)

diff --git a/etcdserver/server_test.go b/etcdserver/server_test.go
index 0455a928f..f850c2b85 100644
--- a/etcdserver/server_test.go
+++ b/etcdserver/server_test.go
@@ -16,6 +16,11 @@ import (
 func TestClusterOf1(t *testing.T) { testServer(t, 1) }
 func TestClusterOf3(t *testing.T) { testServer(t, 3) }
 
+// firstId is the id of the first raft machine in the array.
+// It implies the way to set id for raft machines:
+// The id of n-th machine is firstId+n, and machine with machineId is at machineId-firstId place in the array.
+const firstId int64 = 0x1000
+
 func testServer(t *testing.T, ns int64) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
@@ -25,17 +30,17 @@ func testServer(t *testing.T, ns int64) {
 	send := func(msgs []raftpb.Message) {
 		for _, m := range msgs {
 			t.Logf("m = %+v\n", m)
-			ss[m.To-0x1000].Node.Step(ctx, m)
+			ss[m.To-firstId].Node.Step(ctx, m)
 		}
 	}
 
 	peers := make([]int64, ns)
 	for i := int64(0); i < ns; i++ {
-		peers[i] = 0x1000 + i
+		peers[i] = firstId + i
 	}
 
 	for i := int64(0); i < ns; i++ {
-		id := 0x1000 + i
+		id := firstId + i
 		n := raft.Start(id, peers, 10, 1)
 		tk := time.NewTicker(10 * time.Millisecond)
 		defer tk.Stop()
diff --git a/raft/raft_test.go b/raft/raft_test.go
index 7735d1510..1f4de8fad 100644
--- a/raft/raft_test.go
+++ b/raft/raft_test.go
@@ -10,6 +10,13 @@ import (
 	pb "github.com/coreos/etcd/raft/raftpb"
 )
 
+// firstId is the id of the first raft machine in the array.
+// It implies the way to set id for raft machines:
+// The id of n-th machine is firstId+n, and machine with machineId is at machineId-firstId place in the array.
+// This is how newNetwork sets ids for raft machines.
+// TODO: use more flexible ways to set it
+const firstId int64 = 0x1000
+
 // nextEnts returns the appliable entries and updates the applied index
 func (r *raft) nextEnts() (ents []pb.Entry) {
 	ents = r.raftLog.nextEnts()
@@ -41,8 +48,8 @@ func TestLeaderElection(t *testing.T) {
 	}
 
 	for i, tt := range tests {
-		tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
-		sm := tt.network.peers[0x1000].(*raft)
+		tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
+		sm := tt.network.peers[firstId].(*raft)
 		if sm.state != tt.state {
 			t.Errorf("#%d: state = %s, want %s", i, sm.state, tt.state)
 		}
@@ -61,23 +68,23 @@ func TestLogReplication(t *testing.T) {
 		{
 			newNetwork(nil, nil, nil),
 			[]pb.Message{
-				{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
+				{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
 			},
 			2,
 		},
 		{
 			newNetwork(nil, nil, nil),
 			[]pb.Message{
-				{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
-				{From: none, To: 0x1001, Type: msgHup},
-				{From: none, To: 0x1001, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
+				{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
+				{From: none, To: firstId + 1, Type: msgHup},
+				{From: none, To: firstId + 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
 			},
 			4,
 		},
 	}
 
 	for i, tt := range tests {
-		tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
+		tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
 
 		for _, m := range tt.msgs {
 			tt.send(m)
@@ -113,11 +120,11 @@ func TestLogReplication(t *testing.T) {
 
 func TestSingleNodeCommit(t *testing.T) {
 	tt := newNetwork(nil)
-	tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
-	tt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
-	tt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
+	tt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
-	sm := tt.peers[0x1000].(*raft)
+	sm := tt.peers[firstId].(*raft)
 	if sm.raftLog.committed != 3 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 3)
 	}
@@ -128,17 +135,17 @@ func TestSingleNodeCommit(t *testing.T) {
 // filtered.
 func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 	tt := newNetwork(nil, nil, nil, nil, nil)
-	tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
+	tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
 
 	// 0 cannot reach 2,3,4
-	tt.cut(0x1000, 0x1002)
-	tt.cut(0x1000, 0x1003)
-	tt.cut(0x1000, 0x1004)
+	tt.cut(firstId, firstId+2)
+	tt.cut(firstId, firstId+3)
+	tt.cut(firstId, firstId+4)
 
-	tt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
-	tt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
-	sm := tt.peers[0x1000].(*raft)
+	sm := tt.peers[firstId].(*raft)
 	if sm.raftLog.committed != 1 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 1)
 	}
@@ -149,10 +156,10 @@ func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 	tt.ignore(msgApp)
 
 	// elect 1 as the new leader with term 2
-	tt.send(pb.Message{From: none, To: 0x1001, Type: msgHup})
+	tt.send(pb.Message{From: none, To: firstId + 1, Type: msgHup})
 
 	// no log entries from previous term should be committed
-	sm = tt.peers[0x1001].(*raft)
+	sm = tt.peers[firstId+1].(*raft)
 	if sm.raftLog.committed != 1 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 1)
 	}
@@ -162,14 +169,14 @@ func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 	// send out a heartbeat
 	// after append a ChangeTerm entry from the current term, all entries
 	// should be committed
-	tt.send(pb.Message{From: none, To: 0x1001, Type: msgBeat})
+	tt.send(pb.Message{From: none, To: firstId + 1, Type: msgBeat})
 
 	if sm.raftLog.committed != 4 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 4)
 	}
 
 	// still be able to append a entry
-	tt.send(pb.Message{From: none, To: 0x1001, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: none, To: firstId + 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
 	if sm.raftLog.committed != 5 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 5)
@@ -180,17 +187,17 @@ func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 // when leader changes, no new proposal comes in.
 func TestCommitWithoutNewTermEntry(t *testing.T) {
 	tt := newNetwork(nil, nil, nil, nil, nil)
-	tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
+	tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
 
 	// 0 cannot reach 2,3,4
-	tt.cut(0x1000, 0x1002)
-	tt.cut(0x1000, 0x1003)
-	tt.cut(0x1000, 0x1004)
+	tt.cut(firstId, firstId+2)
+	tt.cut(firstId, firstId+3)
+	tt.cut(firstId, firstId+4)
 
-	tt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
-	tt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
-	sm := tt.peers[0x1000].(*raft)
+	sm := tt.peers[firstId].(*raft)
 	if sm.raftLog.committed != 1 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 1)
 	}
@@ -201,7 +208,7 @@ func TestCommitWithoutNewTermEntry(t *testing.T) {
 	// elect 1 as the new leader with term 2
 	// after append a ChangeTerm entry from the current term, all entries
 	// should be committed
-	tt.send(pb.Message{From: none, To: 0x1001, Type: msgHup})
+	tt.send(pb.Message{From: none, To: firstId + 1, Type: msgHup})
 
 	if sm.raftLog.committed != 4 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 4)
@@ -214,13 +221,13 @@ func TestDuelingCandidates(t *testing.T) {
 	c := newRaft(-1, nil, 0, 0)
 
 	nt := newNetwork(a, b, c)
-	nt.cut(0x1000, 0x1002)
+	nt.cut(firstId, firstId+2)
 
-	nt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
-	nt.send(pb.Message{From: none, To: 0x1002, Type: msgHup})
+	nt.send(pb.Message{From: none, To: firstId, Type: msgHup})
+	nt.send(pb.Message{From: none, To: firstId + 2, Type: msgHup})
 
 	nt.recover()
-	nt.send(pb.Message{From: none, To: 0x1002, Type: msgHup})
+	nt.send(pb.Message{From: none, To: firstId + 2, Type: msgHup})
 
 	wlog := &raftLog{ents: []pb.Entry{{}, pb.Entry{Data: nil, Term: 1, Index: 1}}, committed: 1}
 	tests := []struct {
@@ -242,7 +249,7 @@ func TestDuelingCandidates(t *testing.T) {
 			t.Errorf("#%d: term = %d, want %d", i, g, tt.term)
 		}
 		base := ltoa(tt.raftLog)
-		if sm, ok := nt.peers[int64(0x1000+i)].(*raft); ok {
+		if sm, ok := nt.peers[firstId+int64(i)].(*raft); ok {
 			l := ltoa(sm.raftLog)
 			if g := diffu(base, l); g != "" {
 				t.Errorf("#%d: diff:\n%s", i, g)
@@ -255,19 +262,19 @@ func TestDuelingCandidates(t *testing.T) {
 
 func TestCandidateConcede(t *testing.T) {
 	tt := newNetwork(nil, nil, nil)
-	tt.isolate(0x1000)
+	tt.isolate(firstId)
 
-	tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
-	tt.send(pb.Message{From: none, To: 0x1002, Type: msgHup})
+	tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
+	tt.send(pb.Message{From: none, To: firstId + 2, Type: msgHup})
 
 	// heal the partition
 	tt.recover()
 
 	data := []byte("force follower")
 	// send a proposal to 2 to flush out a msgApp to 0
-	tt.send(pb.Message{From: none, To: 0x1002, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
+	tt.send(pb.Message{From: none, To: firstId + 2, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
 
-	a := tt.peers[0x1000].(*raft)
+	a := tt.peers[firstId].(*raft)
 	if g := a.state; g != stateFollower {
 		t.Errorf("state = %s, want %s", g, stateFollower)
 	}
@@ -289,9 +296,9 @@ func TestCandidateConcede(t *testing.T) {
 
 func TestSingleNodeCandidate(t *testing.T) {
 	tt := newNetwork(nil)
-	tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
+	tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
 
-	sm := tt.peers[0x1000].(*raft)
+	sm := tt.peers[firstId].(*raft)
 	if sm.state != stateLeader {
 		t.Errorf("state = %d, want %d", sm.state, stateLeader)
 	}
@@ -300,11 +307,11 @@ func TestSingleNodeCandidate(t *testing.T) {
 func TestOldMessages(t *testing.T) {
 	tt := newNetwork(nil, nil, nil)
 	// make 0 leader @ term 3
-	tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
-	tt.send(pb.Message{From: none, To: 0x1001, Type: msgHup})
-	tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
+	tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
+	tt.send(pb.Message{From: none, To: firstId + 1, Type: msgHup})
+	tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
 	// pretend we're an old leader trying to make progress
-	tt.send(pb.Message{From: none, To: 0x1000, Type: msgApp, Term: 1, Entries: []pb.Entry{{Term: 1}}})
+	tt.send(pb.Message{From: none, To: firstId, Type: msgApp, Term: 1, Entries: []pb.Entry{{Term: 1}}})
 
 	l := &raftLog{
 		ents: []pb.Entry{
@@ -358,8 +365,8 @@ func TestProposal(t *testing.T) {
 		data := []byte("somedata")
 
 		// promote 0 the leader
-		send(pb.Message{From: none, To: 0x1000, Type: msgHup})
-		send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
+		send(pb.Message{From: none, To: firstId, Type: msgHup})
+		send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
 
 		wantLog := newLog()
 		if tt.success {
@@ -376,7 +383,7 @@ func TestProposal(t *testing.T) {
 				t.Logf("#%d: empty log", i)
 			}
 		}
-		sm := tt.network.peers[0x1000].(*raft)
+		sm := tt.network.peers[firstId].(*raft)
 		if g := sm.Term; g != 1 {
 			t.Errorf("#%d: term = %d, want %d", i, g, 1)
 		}
@@ -392,10 +399,10 @@ func TestProposalByProxy(t *testing.T) {
 
 	for i, tt := range tests {
 		// promote 0 the leader
-		tt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
+		tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
 
 		// propose via follower
-		tt.send(pb.Message{From: none, To: 0x1001, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}})
+		tt.send(pb.Message{From: none, To: firstId + 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}})
 
 		wantLog := &raftLog{ents: []pb.Entry{{}, {Data: nil, Term: 1, Index: 1}, {Term: 1, Data: data, Index: 2}}, committed: 2}
 		base := ltoa(wantLog)
@@ -409,7 +416,7 @@ func TestProposalByProxy(t *testing.T) {
 				t.Logf("#%d: empty log", i)
 			}
 		}
-		sm := tt.peers[0x1000].(*raft)
+		sm := tt.peers[firstId].(*raft)
 		if g := sm.Term; g != 1 {
 			t.Errorf("#%d: term = %d, want %d", i, g, 1)
 		}
@@ -464,7 +471,7 @@ func TestStepIgnoreOldTermMsg(t *testing.T) {
 	fakeStep := func(r *raft, m pb.Message) {
 		called = true
 	}
-	sm := newRaft(0x1000, []int64{0x1000}, 0, 0)
+	sm := newRaft(firstId, []int64{firstId}, 0, 0)
 	sm.step = fakeStep
 	sm.Term = 2
 	sm.Step(pb.Message{Type: msgApp, Term: sm.Term - 1})
@@ -556,15 +563,15 @@ func TestRecvMsgVote(t *testing.T) {
 		{stateFollower, 3, 2, none, 2},
 		{stateFollower, 3, 3, none, 2},
 
-		{stateFollower, 3, 2, 0x1001, 2},
-		{stateFollower, 3, 2, 0x1000, -1},
+		{stateFollower, 3, 2, firstId + 1, 2},
+		{stateFollower, 3, 2, firstId, -1},
 
-		{stateLeader, 3, 3, 0x1000, -1},
-		{stateCandidate, 3, 3, 0x1000, -1},
+		{stateLeader, 3, 3, firstId, -1},
+		{stateCandidate, 3, 3, firstId, -1},
 	}
 
 	for i, tt := range tests {
-		sm := newRaft(0x1000, []int64{0x1000}, 0, 0)
+		sm := newRaft(firstId, []int64{firstId}, 0, 0)
 		sm.state = tt.state
 		switch tt.state {
 		case stateFollower:
@@ -577,7 +584,7 @@ func TestRecvMsgVote(t *testing.T) {
 		sm.State = pb.State{Vote: tt.voteFor}
 		sm.raftLog = &raftLog{ents: []pb.Entry{{}, {Term: 2}, {Term: 2}}}
 
-		sm.Step(pb.Message{Type: msgVote, From: 0x1001, Index: tt.i, LogTerm: tt.term})
+		sm.Step(pb.Message{Type: msgVote, From: firstId + 1, Index: tt.i, LogTerm: tt.term})
 
 		msgs := sm.ReadMessages()
 		if g := len(msgs); g != 1 {
@@ -604,11 +611,11 @@ func TestStateTransition(t *testing.T) {
 
 		{stateCandidate, stateFollower, true, 0, none},
 		{stateCandidate, stateCandidate, true, 1, none},
-		{stateCandidate, stateLeader, true, 0, 0x1000},
+		{stateCandidate, stateLeader, true, 0, firstId},
 
 		{stateLeader, stateFollower, true, 1, none},
 		{stateLeader, stateCandidate, false, 1, none},
-		{stateLeader, stateLeader, true, 0, 0x1000},
+		{stateLeader, stateLeader, true, 0, firstId},
 	}
 
 	for i, tt := range tests {
@@ -621,7 +628,7 @@ func TestStateTransition(t *testing.T) {
 				}
 			}()
 
-			sm := newRaft(0x1000, []int64{0x1000}, 0, 0)
+			sm := newRaft(firstId, []int64{firstId}, 0, 0)
 			sm.state = tt.from
 
 			switch tt.to {
@@ -660,7 +667,7 @@ func TestAllServerStepdown(t *testing.T) {
 	tterm := int64(3)
 
 	for i, tt := range tests {
-		sm := newRaft(0x1000, []int64{0x1000, 0x1001, 0x1002}, 0, 0)
+		sm := newRaft(firstId, []int64{firstId, firstId + 1, firstId + 2}, 0, 0)
 		switch tt.state {
 		case stateFollower:
 			sm.becomeFollower(1, none)
@@ -672,7 +679,7 @@ func TestAllServerStepdown(t *testing.T) {
 		}
 
 		for j, msgType := range tmsgTypes {
-			sm.Step(pb.Message{From: 0x1001, Type: msgType, Term: tterm, LogTerm: tterm})
+			sm.Step(pb.Message{From: firstId + 1, Type: msgType, Term: tterm, LogTerm: tterm})
 
 			if sm.state != tt.wstate {
 				t.Errorf("#%d.%d state = %v , want %v", i, j, sm.state, tt.wstate)
@@ -683,7 +690,7 @@ func TestAllServerStepdown(t *testing.T) {
 			if int64(len(sm.raftLog.ents)) != tt.windex {
 				t.Errorf("#%d.%d index = %v , want %v", i, j, len(sm.raftLog.ents), tt.windex)
 			}
-			wlead := int64(0x1001)
+			wlead := int64(firstId + 1)
 			if msgType == msgVote {
 				wlead = none
 			}
@@ -708,12 +715,12 @@ func TestLeaderAppResp(t *testing.T) {
 	for i, tt := range tests {
 		// sm term is 1 after it becomes the leader.
 		// thus the last log term must be 1 to be committed.
-		sm := newRaft(0x1000, []int64{0x1000, 0x1001, 0x1002}, 0, 0)
+		sm := newRaft(firstId, []int64{firstId, firstId + 1, firstId + 2}, 0, 0)
 		sm.raftLog = &raftLog{ents: []pb.Entry{{}, {Term: 0}, {Term: 1}}}
 		sm.becomeCandidate()
 		sm.becomeLeader()
 		sm.ReadMessages()
-		sm.Step(pb.Message{From: 0x1001, Type: msgAppResp, Index: tt.index, Term: sm.Term})
+		sm.Step(pb.Message{From: firstId + 1, Type: msgAppResp, Index: tt.index, Term: sm.Term})
 		msgs := sm.ReadMessages()
 
 		if len(msgs) != tt.wmsgNum {
@@ -743,7 +750,7 @@ func TestRecvMsgBeat(t *testing.T) {
 	}
 
 	for i, tt := range tests {
-		sm := newRaft(0x1000, []int64{0x1000, 0x1001, 0x1002}, 0, 0)
+		sm := newRaft(firstId, []int64{firstId, firstId + 1, firstId + 2}, 0, 0)
 		sm.raftLog = &raftLog{ents: []pb.Entry{{}, {Term: 0}, {Term: 1}}}
 		sm.Term = 1
 		sm.state = tt.state
@@ -755,7 +762,7 @@ func TestRecvMsgBeat(t *testing.T) {
 		case stateLeader:
 			sm.step = stepLeader
 		}
-		sm.Step(pb.Message{From: none, To: 0x1000, Type: msgBeat})
+		sm.Step(pb.Message{From: none, To: firstId, Type: msgBeat})
 
 		msgs := sm.ReadMessages()
 		if len(msgs) != tt.wMsg {
@@ -773,10 +780,10 @@ func TestRestore(t *testing.T) {
 	s := pb.Snapshot{
 		Index: defaultCompactThreshold + 1,
 		Term:  defaultCompactThreshold + 1,
-		Nodes: []int64{0x1000, 0x1001, 0x1002},
+		Nodes: []int64{firstId, firstId + 1, firstId + 2},
 	}
 
-	sm := newRaft(0x1000, []int64{0x1000, 0x1001}, 0, 0)
+	sm := newRaft(firstId, []int64{firstId, firstId + 1}, 0, 0)
 	if ok := sm.restore(s); !ok {
 		t.Fatal("restore fail, want succeed")
 	}
@@ -807,9 +814,9 @@ func TestProvideSnap(t *testing.T) {
 	s := pb.Snapshot{
 		Index: defaultCompactThreshold + 1,
 		Term:  defaultCompactThreshold + 1,
-		Nodes: []int64{0x1000, 0x1001},
+		Nodes: []int64{firstId, firstId + 1},
 	}
-	sm := newRaft(0x1000, []int64{0x1000}, 0, 0)
+	sm := newRaft(firstId, []int64{firstId}, 0, 0)
 	// restore the statemachin from a snapshot
 	// so it has a compacted log and a snapshot
 	sm.restore(s)
@@ -817,7 +824,7 @@ func TestProvideSnap(t *testing.T) {
 	sm.becomeCandidate()
 	sm.becomeLeader()
 
-	sm.Step(pb.Message{From: none, To: 0x1000, Type: msgBeat})
+	sm.Step(pb.Message{From: none, To: firstId, Type: msgBeat})
 	msgs := sm.ReadMessages()
 	if len(msgs) != 1 {
 		t.Errorf("len(msgs) = %d, want 1", len(msgs))
@@ -829,9 +836,9 @@ func TestProvideSnap(t *testing.T) {
 
 	// force set the next of node 1, so that
 	// node 1 needs a snapshot
-	sm.prs[0x1001].next = sm.raftLog.offset
+	sm.prs[firstId+1].next = sm.raftLog.offset
 
-	sm.Step(pb.Message{From: 0x1001, To: 0x1000, Type: msgAppResp, Index: -1})
+	sm.Step(pb.Message{From: firstId + 1, To: firstId, Type: msgAppResp, Index: -1})
 	msgs = sm.ReadMessages()
 	if len(msgs) != 1 {
 		t.Errorf("len(msgs) = %d, want 1", len(msgs))
@@ -846,11 +853,11 @@ func TestRestoreFromSnapMsg(t *testing.T) {
 	s := pb.Snapshot{
 		Index: defaultCompactThreshold + 1,
 		Term:  defaultCompactThreshold + 1,
-		Nodes: []int64{0x1000, 0x1001},
+		Nodes: []int64{firstId, firstId + 1},
 	}
-	m := pb.Message{Type: msgSnap, From: 0x1000, Term: 0x1001, Snapshot: s}
+	m := pb.Message{Type: msgSnap, From: firstId, Term: firstId + 1, Snapshot: s}
 
-	sm := newRaft(0x1001, []int64{0x1000, 0x1001}, 0, 0)
+	sm := newRaft(firstId+1, []int64{firstId, firstId + 1}, 0, 0)
 	sm.Step(m)
 
 	if !reflect.DeepEqual(sm.raftLog.snapshot, s) {
@@ -860,26 +867,26 @@ func TestRestoreFromSnapMsg(t *testing.T) {
 
 func TestSlowNodeRestore(t *testing.T) {
 	nt := newNetwork(nil, nil, nil)
-	nt.send(pb.Message{From: none, To: 0x1000, Type: msgHup})
+	nt.send(pb.Message{From: none, To: firstId, Type: msgHup})
 
-	nt.isolate(0x1002)
+	nt.isolate(firstId + 2)
 	for j := 0; j < defaultCompactThreshold+1; j++ {
-		nt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{}}})
+		nt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{}}})
 	}
-	lead := nt.peers[0x1000].(*raft)
+	lead := nt.peers[firstId].(*raft)
 	lead.nextEnts()
 	lead.compact(nil)
 
 	nt.recover()
-	nt.send(pb.Message{From: none, To: 0x1000, Type: msgBeat})
+	nt.send(pb.Message{From: none, To: firstId, Type: msgBeat})
 
-	follower := nt.peers[0x1002].(*raft)
+	follower := nt.peers[firstId+2].(*raft)
 	if !reflect.DeepEqual(follower.raftLog.snapshot, lead.raftLog.snapshot) {
 		t.Errorf("follower.snap = %+v, want %+v", follower.raftLog.snapshot, lead.raftLog.snapshot)
 	}
 
 	committed := follower.raftLog.lastIndex()
-	nt.send(pb.Message{From: none, To: 0x1000, Type: msgProp, Entries: []pb.Entry{{}}})
+	nt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{}}})
 	if follower.raftLog.committed != committed+1 {
 		t.Errorf("follower.comitted = %d, want %d", follower.raftLog.committed, committed+1)
 	}
@@ -910,7 +917,7 @@ func newNetwork(peers ...Interface) *network {
 	size := len(peers)
 	peerAddrs := make([]int64, size)
 	for i := 0; i < size; i++ {
-		peerAddrs[i] = int64(0x1000 + i)
+		peerAddrs[i] = firstId + int64(i)
 	}
 
 	npeers := make(map[int64]Interface, size)
@@ -962,7 +969,7 @@ func (nw *network) cut(one, other int64) {
 
 func (nw *network) isolate(id int64) {
 	for i := 0; i < len(nw.peers); i++ {
-		nid := int64(0x1000 + i)
+		nid := firstId + int64(i)
 		if nid != id {
 			nw.drop(id, nid, 1.0)
 			nw.drop(nid, id, 1.0)

From 84c2bd0b7d45ebfda9549e566d03474b984977a0 Mon Sep 17 00:00:00 2001
From: Yicheng Qin <qycqycqycqycqyc@gmail.com>
Date: Thu, 11 Sep 2014 19:18:47 -0700
Subject: [PATCH 04/11] raft: set From of local message to be local id

---
 raft/raft_test.go | 80 +++++++++++++++++++++++------------------------
 1 file changed, 40 insertions(+), 40 deletions(-)

diff --git a/raft/raft_test.go b/raft/raft_test.go
index 1f4de8fad..b4b17636d 100644
--- a/raft/raft_test.go
+++ b/raft/raft_test.go
@@ -48,7 +48,7 @@ func TestLeaderElection(t *testing.T) {
 	}
 
 	for i, tt := range tests {
-		tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
+		tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
 		sm := tt.network.peers[firstId].(*raft)
 		if sm.state != tt.state {
 			t.Errorf("#%d: state = %s, want %s", i, sm.state, tt.state)
@@ -68,23 +68,23 @@ func TestLogReplication(t *testing.T) {
 		{
 			newNetwork(nil, nil, nil),
 			[]pb.Message{
-				{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
+				{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
 			},
 			2,
 		},
 		{
 			newNetwork(nil, nil, nil),
 			[]pb.Message{
-				{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
-				{From: none, To: firstId + 1, Type: msgHup},
-				{From: none, To: firstId + 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
+				{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
+				{From: firstId, To: firstId + 1, Type: msgHup},
+				{From: firstId, To: firstId + 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
 			},
 			4,
 		},
 	}
 
 	for i, tt := range tests {
-		tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
+		tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
 
 		for _, m := range tt.msgs {
 			tt.send(m)
@@ -120,9 +120,9 @@ func TestLogReplication(t *testing.T) {
 
 func TestSingleNodeCommit(t *testing.T) {
 	tt := newNetwork(nil)
-	tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
-	tt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
-	tt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
+	tt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
 	sm := tt.peers[firstId].(*raft)
 	if sm.raftLog.committed != 3 {
@@ -135,15 +135,15 @@ func TestSingleNodeCommit(t *testing.T) {
 // filtered.
 func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 	tt := newNetwork(nil, nil, nil, nil, nil)
-	tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
+	tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
 
 	// 0 cannot reach 2,3,4
 	tt.cut(firstId, firstId+2)
 	tt.cut(firstId, firstId+3)
 	tt.cut(firstId, firstId+4)
 
-	tt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
-	tt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
 	sm := tt.peers[firstId].(*raft)
 	if sm.raftLog.committed != 1 {
@@ -156,7 +156,7 @@ func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 	tt.ignore(msgApp)
 
 	// elect 1 as the new leader with term 2
-	tt.send(pb.Message{From: none, To: firstId + 1, Type: msgHup})
+	tt.send(pb.Message{From: firstId + 1, To: firstId + 1, Type: msgHup})
 
 	// no log entries from previous term should be committed
 	sm = tt.peers[firstId+1].(*raft)
@@ -169,14 +169,14 @@ func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 	// send out a heartbeat
 	// after append a ChangeTerm entry from the current term, all entries
 	// should be committed
-	tt.send(pb.Message{From: none, To: firstId + 1, Type: msgBeat})
+	tt.send(pb.Message{From: firstId + 1, To: firstId + 1, Type: msgBeat})
 
 	if sm.raftLog.committed != 4 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 4)
 	}
 
 	// still be able to append a entry
-	tt.send(pb.Message{From: none, To: firstId + 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: firstId + 1, To: firstId + 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
 	if sm.raftLog.committed != 5 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 5)
@@ -187,15 +187,15 @@ func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 // when leader changes, no new proposal comes in.
 func TestCommitWithoutNewTermEntry(t *testing.T) {
 	tt := newNetwork(nil, nil, nil, nil, nil)
-	tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
+	tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
 
 	// 0 cannot reach 2,3,4
 	tt.cut(firstId, firstId+2)
 	tt.cut(firstId, firstId+3)
 	tt.cut(firstId, firstId+4)
 
-	tt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
-	tt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
 	sm := tt.peers[firstId].(*raft)
 	if sm.raftLog.committed != 1 {
@@ -208,7 +208,7 @@ func TestCommitWithoutNewTermEntry(t *testing.T) {
 	// elect 1 as the new leader with term 2
 	// after append a ChangeTerm entry from the current term, all entries
 	// should be committed
-	tt.send(pb.Message{From: none, To: firstId + 1, Type: msgHup})
+	tt.send(pb.Message{From: firstId + 1, To: firstId + 1, Type: msgHup})
 
 	if sm.raftLog.committed != 4 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 4)
@@ -223,11 +223,11 @@ func TestDuelingCandidates(t *testing.T) {
 	nt := newNetwork(a, b, c)
 	nt.cut(firstId, firstId+2)
 
-	nt.send(pb.Message{From: none, To: firstId, Type: msgHup})
-	nt.send(pb.Message{From: none, To: firstId + 2, Type: msgHup})
+	nt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
+	nt.send(pb.Message{From: firstId + 2, To: firstId + 2, Type: msgHup})
 
 	nt.recover()
-	nt.send(pb.Message{From: none, To: firstId + 2, Type: msgHup})
+	nt.send(pb.Message{From: firstId + 2, To: firstId + 2, Type: msgHup})
 
 	wlog := &raftLog{ents: []pb.Entry{{}, pb.Entry{Data: nil, Term: 1, Index: 1}}, committed: 1}
 	tests := []struct {
@@ -264,15 +264,15 @@ func TestCandidateConcede(t *testing.T) {
 	tt := newNetwork(nil, nil, nil)
 	tt.isolate(firstId)
 
-	tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
-	tt.send(pb.Message{From: none, To: firstId + 2, Type: msgHup})
+	tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
+	tt.send(pb.Message{From: firstId + 2, To: firstId + 2, Type: msgHup})
 
 	// heal the partition
 	tt.recover()
 
 	data := []byte("force follower")
 	// send a proposal to 2 to flush out a msgApp to 0
-	tt.send(pb.Message{From: none, To: firstId + 2, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
+	tt.send(pb.Message{From: firstId + 2, To: firstId + 2, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
 
 	a := tt.peers[firstId].(*raft)
 	if g := a.state; g != stateFollower {
@@ -296,7 +296,7 @@ func TestCandidateConcede(t *testing.T) {
 
 func TestSingleNodeCandidate(t *testing.T) {
 	tt := newNetwork(nil)
-	tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
+	tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
 
 	sm := tt.peers[firstId].(*raft)
 	if sm.state != stateLeader {
@@ -307,11 +307,11 @@ func TestSingleNodeCandidate(t *testing.T) {
 func TestOldMessages(t *testing.T) {
 	tt := newNetwork(nil, nil, nil)
 	// make 0 leader @ term 3
-	tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
-	tt.send(pb.Message{From: none, To: firstId + 1, Type: msgHup})
-	tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
+	tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
+	tt.send(pb.Message{From: firstId + 1, To: firstId + 1, Type: msgHup})
+	tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
 	// pretend we're an old leader trying to make progress
-	tt.send(pb.Message{From: none, To: firstId, Type: msgApp, Term: 1, Entries: []pb.Entry{{Term: 1}}})
+	tt.send(pb.Message{From: firstId, To: firstId, Type: msgApp, Term: 1, Entries: []pb.Entry{{Term: 1}}})
 
 	l := &raftLog{
 		ents: []pb.Entry{
@@ -365,8 +365,8 @@ func TestProposal(t *testing.T) {
 		data := []byte("somedata")
 
 		// promote 0 the leader
-		send(pb.Message{From: none, To: firstId, Type: msgHup})
-		send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
+		send(pb.Message{From: firstId, To: firstId, Type: msgHup})
+		send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
 
 		wantLog := newLog()
 		if tt.success {
@@ -399,10 +399,10 @@ func TestProposalByProxy(t *testing.T) {
 
 	for i, tt := range tests {
 		// promote 0 the leader
-		tt.send(pb.Message{From: none, To: firstId, Type: msgHup})
+		tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
 
 		// propose via follower
-		tt.send(pb.Message{From: none, To: firstId + 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}})
+		tt.send(pb.Message{From: firstId + 1, To: firstId + 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}})
 
 		wantLog := &raftLog{ents: []pb.Entry{{}, {Data: nil, Term: 1, Index: 1}, {Term: 1, Data: data, Index: 2}}, committed: 2}
 		base := ltoa(wantLog)
@@ -762,7 +762,7 @@ func TestRecvMsgBeat(t *testing.T) {
 		case stateLeader:
 			sm.step = stepLeader
 		}
-		sm.Step(pb.Message{From: none, To: firstId, Type: msgBeat})
+		sm.Step(pb.Message{From: firstId, To: firstId, Type: msgBeat})
 
 		msgs := sm.ReadMessages()
 		if len(msgs) != tt.wMsg {
@@ -824,7 +824,7 @@ func TestProvideSnap(t *testing.T) {
 	sm.becomeCandidate()
 	sm.becomeLeader()
 
-	sm.Step(pb.Message{From: none, To: firstId, Type: msgBeat})
+	sm.Step(pb.Message{From: firstId, To: firstId, Type: msgBeat})
 	msgs := sm.ReadMessages()
 	if len(msgs) != 1 {
 		t.Errorf("len(msgs) = %d, want 1", len(msgs))
@@ -867,18 +867,18 @@ func TestRestoreFromSnapMsg(t *testing.T) {
 
 func TestSlowNodeRestore(t *testing.T) {
 	nt := newNetwork(nil, nil, nil)
-	nt.send(pb.Message{From: none, To: firstId, Type: msgHup})
+	nt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
 
 	nt.isolate(firstId + 2)
 	for j := 0; j < defaultCompactThreshold+1; j++ {
-		nt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{}}})
+		nt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{}}})
 	}
 	lead := nt.peers[firstId].(*raft)
 	lead.nextEnts()
 	lead.compact(nil)
 
 	nt.recover()
-	nt.send(pb.Message{From: none, To: firstId, Type: msgBeat})
+	nt.send(pb.Message{From: firstId, To: firstId, Type: msgBeat})
 
 	follower := nt.peers[firstId+2].(*raft)
 	if !reflect.DeepEqual(follower.raftLog.snapshot, lead.raftLog.snapshot) {
@@ -886,7 +886,7 @@ func TestSlowNodeRestore(t *testing.T) {
 	}
 
 	committed := follower.raftLog.lastIndex()
-	nt.send(pb.Message{From: none, To: firstId, Type: msgProp, Entries: []pb.Entry{{}}})
+	nt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{}}})
 	if follower.raftLog.committed != committed+1 {
 		t.Errorf("follower.comitted = %d, want %d", follower.raftLog.committed, committed+1)
 	}

From 0e0fc2bd24ecee1d8a19f59bbb8f38390214c4fb Mon Sep 17 00:00:00 2001
From: Yicheng Qin <qycqycqycqycqyc@gmail.com>
Date: Thu, 11 Sep 2014 19:23:05 -0700
Subject: [PATCH 05/11] raft: use [1,n] as address list for raft state machines

---
 etcdserver/server_test.go |  11 +--
 raft/raft_test.go         | 183 ++++++++++++++++++--------------------
 2 files changed, 91 insertions(+), 103 deletions(-)

diff --git a/etcdserver/server_test.go b/etcdserver/server_test.go
index f850c2b85..a6bf44c23 100644
--- a/etcdserver/server_test.go
+++ b/etcdserver/server_test.go
@@ -16,11 +16,6 @@ import (
 func TestClusterOf1(t *testing.T) { testServer(t, 1) }
 func TestClusterOf3(t *testing.T) { testServer(t, 3) }
 
-// firstId is the id of the first raft machine in the array.
-// It implies the way to set id for raft machines:
-// The id of n-th machine is firstId+n, and machine with machineId is at machineId-firstId place in the array.
-const firstId int64 = 0x1000
-
 func testServer(t *testing.T, ns int64) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
@@ -30,17 +25,17 @@ func testServer(t *testing.T, ns int64) {
 	send := func(msgs []raftpb.Message) {
 		for _, m := range msgs {
 			t.Logf("m = %+v\n", m)
-			ss[m.To-firstId].Node.Step(ctx, m)
+			ss[m.To-1].Node.Step(ctx, m)
 		}
 	}
 
 	peers := make([]int64, ns)
 	for i := int64(0); i < ns; i++ {
-		peers[i] = firstId + i
+		peers[i] = i + 1
 	}
 
 	for i := int64(0); i < ns; i++ {
-		id := firstId + i
+		id := i + 1
 		n := raft.Start(id, peers, 10, 1)
 		tk := time.NewTicker(10 * time.Millisecond)
 		defer tk.Stop()
diff --git a/raft/raft_test.go b/raft/raft_test.go
index b4b17636d..16457faed 100644
--- a/raft/raft_test.go
+++ b/raft/raft_test.go
@@ -10,13 +10,6 @@ import (
 	pb "github.com/coreos/etcd/raft/raftpb"
 )
 
-// firstId is the id of the first raft machine in the array.
-// It implies the way to set id for raft machines:
-// The id of n-th machine is firstId+n, and machine with machineId is at machineId-firstId place in the array.
-// This is how newNetwork sets ids for raft machines.
-// TODO: use more flexible ways to set it
-const firstId int64 = 0x1000
-
 // nextEnts returns the appliable entries and updates the applied index
 func (r *raft) nextEnts() (ents []pb.Entry) {
 	ents = r.raftLog.nextEnts()
@@ -48,8 +41,8 @@ func TestLeaderElection(t *testing.T) {
 	}
 
 	for i, tt := range tests {
-		tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
-		sm := tt.network.peers[firstId].(*raft)
+		tt.send(pb.Message{From: 1, To: 1, Type: msgHup})
+		sm := tt.network.peers[1].(*raft)
 		if sm.state != tt.state {
 			t.Errorf("#%d: state = %s, want %s", i, sm.state, tt.state)
 		}
@@ -68,23 +61,23 @@ func TestLogReplication(t *testing.T) {
 		{
 			newNetwork(nil, nil, nil),
 			[]pb.Message{
-				{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
+				{From: 1, To: 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
 			},
 			2,
 		},
 		{
 			newNetwork(nil, nil, nil),
 			[]pb.Message{
-				{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
-				{From: firstId, To: firstId + 1, Type: msgHup},
-				{From: firstId, To: firstId + 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
+				{From: 1, To: 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
+				{From: 1, To: 2, Type: msgHup},
+				{From: 1, To: 2, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}},
 			},
 			4,
 		},
 	}
 
 	for i, tt := range tests {
-		tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
+		tt.send(pb.Message{From: 1, To: 1, Type: msgHup})
 
 		for _, m := range tt.msgs {
 			tt.send(m)
@@ -120,11 +113,11 @@ func TestLogReplication(t *testing.T) {
 
 func TestSingleNodeCommit(t *testing.T) {
 	tt := newNetwork(nil)
-	tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
-	tt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
-	tt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: 1, To: 1, Type: msgHup})
+	tt.send(pb.Message{From: 1, To: 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: 1, To: 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
-	sm := tt.peers[firstId].(*raft)
+	sm := tt.peers[1].(*raft)
 	if sm.raftLog.committed != 3 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 3)
 	}
@@ -135,17 +128,17 @@ func TestSingleNodeCommit(t *testing.T) {
 // filtered.
 func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 	tt := newNetwork(nil, nil, nil, nil, nil)
-	tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
+	tt.send(pb.Message{From: 1, To: 1, Type: msgHup})
 
 	// 0 cannot reach 2,3,4
-	tt.cut(firstId, firstId+2)
-	tt.cut(firstId, firstId+3)
-	tt.cut(firstId, firstId+4)
+	tt.cut(1, 3)
+	tt.cut(1, 4)
+	tt.cut(1, 5)
 
-	tt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
-	tt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: 1, To: 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: 1, To: 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
-	sm := tt.peers[firstId].(*raft)
+	sm := tt.peers[1].(*raft)
 	if sm.raftLog.committed != 1 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 1)
 	}
@@ -156,10 +149,10 @@ func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 	tt.ignore(msgApp)
 
 	// elect 1 as the new leader with term 2
-	tt.send(pb.Message{From: firstId + 1, To: firstId + 1, Type: msgHup})
+	tt.send(pb.Message{From: 2, To: 2, Type: msgHup})
 
 	// no log entries from previous term should be committed
-	sm = tt.peers[firstId+1].(*raft)
+	sm = tt.peers[2].(*raft)
 	if sm.raftLog.committed != 1 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 1)
 	}
@@ -169,14 +162,14 @@ func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 	// send out a heartbeat
 	// after append a ChangeTerm entry from the current term, all entries
 	// should be committed
-	tt.send(pb.Message{From: firstId + 1, To: firstId + 1, Type: msgBeat})
+	tt.send(pb.Message{From: 2, To: 2, Type: msgBeat})
 
 	if sm.raftLog.committed != 4 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 4)
 	}
 
 	// still be able to append a entry
-	tt.send(pb.Message{From: firstId + 1, To: firstId + 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: 2, To: 2, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
 	if sm.raftLog.committed != 5 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 5)
@@ -187,17 +180,17 @@ func TestCannotCommitWithoutNewTermEntry(t *testing.T) {
 // when leader changes, no new proposal comes in.
 func TestCommitWithoutNewTermEntry(t *testing.T) {
 	tt := newNetwork(nil, nil, nil, nil, nil)
-	tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
+	tt.send(pb.Message{From: 1, To: 1, Type: msgHup})
 
 	// 0 cannot reach 2,3,4
-	tt.cut(firstId, firstId+2)
-	tt.cut(firstId, firstId+3)
-	tt.cut(firstId, firstId+4)
+	tt.cut(1, 3)
+	tt.cut(1, 4)
+	tt.cut(1, 5)
 
-	tt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
-	tt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: 1, To: 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
+	tt.send(pb.Message{From: 1, To: 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("some data")}}})
 
-	sm := tt.peers[firstId].(*raft)
+	sm := tt.peers[1].(*raft)
 	if sm.raftLog.committed != 1 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 1)
 	}
@@ -208,7 +201,7 @@ func TestCommitWithoutNewTermEntry(t *testing.T) {
 	// elect 1 as the new leader with term 2
 	// after append a ChangeTerm entry from the current term, all entries
 	// should be committed
-	tt.send(pb.Message{From: firstId + 1, To: firstId + 1, Type: msgHup})
+	tt.send(pb.Message{From: 2, To: 2, Type: msgHup})
 
 	if sm.raftLog.committed != 4 {
 		t.Errorf("committed = %d, want %d", sm.raftLog.committed, 4)
@@ -221,13 +214,13 @@ func TestDuelingCandidates(t *testing.T) {
 	c := newRaft(-1, nil, 0, 0)
 
 	nt := newNetwork(a, b, c)
-	nt.cut(firstId, firstId+2)
+	nt.cut(1, 3)
 
-	nt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
-	nt.send(pb.Message{From: firstId + 2, To: firstId + 2, Type: msgHup})
+	nt.send(pb.Message{From: 1, To: 1, Type: msgHup})
+	nt.send(pb.Message{From: 3, To: 3, Type: msgHup})
 
 	nt.recover()
-	nt.send(pb.Message{From: firstId + 2, To: firstId + 2, Type: msgHup})
+	nt.send(pb.Message{From: 3, To: 3, Type: msgHup})
 
 	wlog := &raftLog{ents: []pb.Entry{{}, pb.Entry{Data: nil, Term: 1, Index: 1}}, committed: 1}
 	tests := []struct {
@@ -249,7 +242,7 @@ func TestDuelingCandidates(t *testing.T) {
 			t.Errorf("#%d: term = %d, want %d", i, g, tt.term)
 		}
 		base := ltoa(tt.raftLog)
-		if sm, ok := nt.peers[firstId+int64(i)].(*raft); ok {
+		if sm, ok := nt.peers[1+int64(i)].(*raft); ok {
 			l := ltoa(sm.raftLog)
 			if g := diffu(base, l); g != "" {
 				t.Errorf("#%d: diff:\n%s", i, g)
@@ -262,19 +255,19 @@ func TestDuelingCandidates(t *testing.T) {
 
 func TestCandidateConcede(t *testing.T) {
 	tt := newNetwork(nil, nil, nil)
-	tt.isolate(firstId)
+	tt.isolate(1)
 
-	tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
-	tt.send(pb.Message{From: firstId + 2, To: firstId + 2, Type: msgHup})
+	tt.send(pb.Message{From: 1, To: 1, Type: msgHup})
+	tt.send(pb.Message{From: 3, To: 3, Type: msgHup})
 
 	// heal the partition
 	tt.recover()
 
 	data := []byte("force follower")
 	// send a proposal to 2 to flush out a msgApp to 0
-	tt.send(pb.Message{From: firstId + 2, To: firstId + 2, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
+	tt.send(pb.Message{From: 3, To: 3, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
 
-	a := tt.peers[firstId].(*raft)
+	a := tt.peers[1].(*raft)
 	if g := a.state; g != stateFollower {
 		t.Errorf("state = %s, want %s", g, stateFollower)
 	}
@@ -296,9 +289,9 @@ func TestCandidateConcede(t *testing.T) {
 
 func TestSingleNodeCandidate(t *testing.T) {
 	tt := newNetwork(nil)
-	tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
+	tt.send(pb.Message{From: 1, To: 1, Type: msgHup})
 
-	sm := tt.peers[firstId].(*raft)
+	sm := tt.peers[1].(*raft)
 	if sm.state != stateLeader {
 		t.Errorf("state = %d, want %d", sm.state, stateLeader)
 	}
@@ -307,11 +300,11 @@ func TestSingleNodeCandidate(t *testing.T) {
 func TestOldMessages(t *testing.T) {
 	tt := newNetwork(nil, nil, nil)
 	// make 0 leader @ term 3
-	tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
-	tt.send(pb.Message{From: firstId + 1, To: firstId + 1, Type: msgHup})
-	tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
+	tt.send(pb.Message{From: 1, To: 1, Type: msgHup})
+	tt.send(pb.Message{From: 2, To: 2, Type: msgHup})
+	tt.send(pb.Message{From: 1, To: 1, Type: msgHup})
 	// pretend we're an old leader trying to make progress
-	tt.send(pb.Message{From: firstId, To: firstId, Type: msgApp, Term: 1, Entries: []pb.Entry{{Term: 1}}})
+	tt.send(pb.Message{From: 1, To: 1, Type: msgApp, Term: 1, Entries: []pb.Entry{{Term: 1}}})
 
 	l := &raftLog{
 		ents: []pb.Entry{
@@ -365,8 +358,8 @@ func TestProposal(t *testing.T) {
 		data := []byte("somedata")
 
 		// promote 0 the leader
-		send(pb.Message{From: firstId, To: firstId, Type: msgHup})
-		send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
+		send(pb.Message{From: 1, To: 1, Type: msgHup})
+		send(pb.Message{From: 1, To: 1, Type: msgProp, Entries: []pb.Entry{{Data: data}}})
 
 		wantLog := newLog()
 		if tt.success {
@@ -383,7 +376,7 @@ func TestProposal(t *testing.T) {
 				t.Logf("#%d: empty log", i)
 			}
 		}
-		sm := tt.network.peers[firstId].(*raft)
+		sm := tt.network.peers[1].(*raft)
 		if g := sm.Term; g != 1 {
 			t.Errorf("#%d: term = %d, want %d", i, g, 1)
 		}
@@ -399,10 +392,10 @@ func TestProposalByProxy(t *testing.T) {
 
 	for i, tt := range tests {
 		// promote 0 the leader
-		tt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
+		tt.send(pb.Message{From: 1, To: 1, Type: msgHup})
 
 		// propose via follower
-		tt.send(pb.Message{From: firstId + 1, To: firstId + 1, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}})
+		tt.send(pb.Message{From: 2, To: 2, Type: msgProp, Entries: []pb.Entry{{Data: []byte("somedata")}}})
 
 		wantLog := &raftLog{ents: []pb.Entry{{}, {Data: nil, Term: 1, Index: 1}, {Term: 1, Data: data, Index: 2}}, committed: 2}
 		base := ltoa(wantLog)
@@ -416,7 +409,7 @@ func TestProposalByProxy(t *testing.T) {
 				t.Logf("#%d: empty log", i)
 			}
 		}
-		sm := tt.peers[firstId].(*raft)
+		sm := tt.peers[1].(*raft)
 		if g := sm.Term; g != 1 {
 			t.Errorf("#%d: term = %d, want %d", i, g, 1)
 		}
@@ -471,7 +464,7 @@ func TestStepIgnoreOldTermMsg(t *testing.T) {
 	fakeStep := func(r *raft, m pb.Message) {
 		called = true
 	}
-	sm := newRaft(firstId, []int64{firstId}, 0, 0)
+	sm := newRaft(1, []int64{1}, 0, 0)
 	sm.step = fakeStep
 	sm.Term = 2
 	sm.Step(pb.Message{Type: msgApp, Term: sm.Term - 1})
@@ -563,15 +556,15 @@ func TestRecvMsgVote(t *testing.T) {
 		{stateFollower, 3, 2, none, 2},
 		{stateFollower, 3, 3, none, 2},
 
-		{stateFollower, 3, 2, firstId + 1, 2},
-		{stateFollower, 3, 2, firstId, -1},
+		{stateFollower, 3, 2, 2, 2},
+		{stateFollower, 3, 2, 1, -1},
 
-		{stateLeader, 3, 3, firstId, -1},
-		{stateCandidate, 3, 3, firstId, -1},
+		{stateLeader, 3, 3, 1, -1},
+		{stateCandidate, 3, 3, 1, -1},
 	}
 
 	for i, tt := range tests {
-		sm := newRaft(firstId, []int64{firstId}, 0, 0)
+		sm := newRaft(1, []int64{1}, 0, 0)
 		sm.state = tt.state
 		switch tt.state {
 		case stateFollower:
@@ -584,7 +577,7 @@ func TestRecvMsgVote(t *testing.T) {
 		sm.State = pb.State{Vote: tt.voteFor}
 		sm.raftLog = &raftLog{ents: []pb.Entry{{}, {Term: 2}, {Term: 2}}}
 
-		sm.Step(pb.Message{Type: msgVote, From: firstId + 1, Index: tt.i, LogTerm: tt.term})
+		sm.Step(pb.Message{Type: msgVote, From: 2, Index: tt.i, LogTerm: tt.term})
 
 		msgs := sm.ReadMessages()
 		if g := len(msgs); g != 1 {
@@ -611,11 +604,11 @@ func TestStateTransition(t *testing.T) {
 
 		{stateCandidate, stateFollower, true, 0, none},
 		{stateCandidate, stateCandidate, true, 1, none},
-		{stateCandidate, stateLeader, true, 0, firstId},
+		{stateCandidate, stateLeader, true, 0, 1},
 
 		{stateLeader, stateFollower, true, 1, none},
 		{stateLeader, stateCandidate, false, 1, none},
-		{stateLeader, stateLeader, true, 0, firstId},
+		{stateLeader, stateLeader, true, 0, 1},
 	}
 
 	for i, tt := range tests {
@@ -628,7 +621,7 @@ func TestStateTransition(t *testing.T) {
 				}
 			}()
 
-			sm := newRaft(firstId, []int64{firstId}, 0, 0)
+			sm := newRaft(1, []int64{1}, 0, 0)
 			sm.state = tt.from
 
 			switch tt.to {
@@ -667,7 +660,7 @@ func TestAllServerStepdown(t *testing.T) {
 	tterm := int64(3)
 
 	for i, tt := range tests {
-		sm := newRaft(firstId, []int64{firstId, firstId + 1, firstId + 2}, 0, 0)
+		sm := newRaft(1, []int64{1, 2, 3}, 0, 0)
 		switch tt.state {
 		case stateFollower:
 			sm.becomeFollower(1, none)
@@ -679,7 +672,7 @@ func TestAllServerStepdown(t *testing.T) {
 		}
 
 		for j, msgType := range tmsgTypes {
-			sm.Step(pb.Message{From: firstId + 1, Type: msgType, Term: tterm, LogTerm: tterm})
+			sm.Step(pb.Message{From: 2, Type: msgType, Term: tterm, LogTerm: tterm})
 
 			if sm.state != tt.wstate {
 				t.Errorf("#%d.%d state = %v , want %v", i, j, sm.state, tt.wstate)
@@ -690,7 +683,7 @@ func TestAllServerStepdown(t *testing.T) {
 			if int64(len(sm.raftLog.ents)) != tt.windex {
 				t.Errorf("#%d.%d index = %v , want %v", i, j, len(sm.raftLog.ents), tt.windex)
 			}
-			wlead := int64(firstId + 1)
+			wlead := int64(2)
 			if msgType == msgVote {
 				wlead = none
 			}
@@ -715,12 +708,12 @@ func TestLeaderAppResp(t *testing.T) {
 	for i, tt := range tests {
 		// sm term is 1 after it becomes the leader.
 		// thus the last log term must be 1 to be committed.
-		sm := newRaft(firstId, []int64{firstId, firstId + 1, firstId + 2}, 0, 0)
+		sm := newRaft(1, []int64{1, 2, 3}, 0, 0)
 		sm.raftLog = &raftLog{ents: []pb.Entry{{}, {Term: 0}, {Term: 1}}}
 		sm.becomeCandidate()
 		sm.becomeLeader()
 		sm.ReadMessages()
-		sm.Step(pb.Message{From: firstId + 1, Type: msgAppResp, Index: tt.index, Term: sm.Term})
+		sm.Step(pb.Message{From: 2, Type: msgAppResp, Index: tt.index, Term: sm.Term})
 		msgs := sm.ReadMessages()
 
 		if len(msgs) != tt.wmsgNum {
@@ -750,7 +743,7 @@ func TestRecvMsgBeat(t *testing.T) {
 	}
 
 	for i, tt := range tests {
-		sm := newRaft(firstId, []int64{firstId, firstId + 1, firstId + 2}, 0, 0)
+		sm := newRaft(1, []int64{1, 2, 3}, 0, 0)
 		sm.raftLog = &raftLog{ents: []pb.Entry{{}, {Term: 0}, {Term: 1}}}
 		sm.Term = 1
 		sm.state = tt.state
@@ -762,7 +755,7 @@ func TestRecvMsgBeat(t *testing.T) {
 		case stateLeader:
 			sm.step = stepLeader
 		}
-		sm.Step(pb.Message{From: firstId, To: firstId, Type: msgBeat})
+		sm.Step(pb.Message{From: 1, To: 1, Type: msgBeat})
 
 		msgs := sm.ReadMessages()
 		if len(msgs) != tt.wMsg {
@@ -780,10 +773,10 @@ func TestRestore(t *testing.T) {
 	s := pb.Snapshot{
 		Index: defaultCompactThreshold + 1,
 		Term:  defaultCompactThreshold + 1,
-		Nodes: []int64{firstId, firstId + 1, firstId + 2},
+		Nodes: []int64{1, 2, 3},
 	}
 
-	sm := newRaft(firstId, []int64{firstId, firstId + 1}, 0, 0)
+	sm := newRaft(1, []int64{1, 2}, 0, 0)
 	if ok := sm.restore(s); !ok {
 		t.Fatal("restore fail, want succeed")
 	}
@@ -814,9 +807,9 @@ func TestProvideSnap(t *testing.T) {
 	s := pb.Snapshot{
 		Index: defaultCompactThreshold + 1,
 		Term:  defaultCompactThreshold + 1,
-		Nodes: []int64{firstId, firstId + 1},
+		Nodes: []int64{1, 2},
 	}
-	sm := newRaft(firstId, []int64{firstId}, 0, 0)
+	sm := newRaft(1, []int64{1}, 0, 0)
 	// restore the statemachin from a snapshot
 	// so it has a compacted log and a snapshot
 	sm.restore(s)
@@ -824,7 +817,7 @@ func TestProvideSnap(t *testing.T) {
 	sm.becomeCandidate()
 	sm.becomeLeader()
 
-	sm.Step(pb.Message{From: firstId, To: firstId, Type: msgBeat})
+	sm.Step(pb.Message{From: 1, To: 1, Type: msgBeat})
 	msgs := sm.ReadMessages()
 	if len(msgs) != 1 {
 		t.Errorf("len(msgs) = %d, want 1", len(msgs))
@@ -836,9 +829,9 @@ func TestProvideSnap(t *testing.T) {
 
 	// force set the next of node 1, so that
 	// node 1 needs a snapshot
-	sm.prs[firstId+1].next = sm.raftLog.offset
+	sm.prs[2].next = sm.raftLog.offset
 
-	sm.Step(pb.Message{From: firstId + 1, To: firstId, Type: msgAppResp, Index: -1})
+	sm.Step(pb.Message{From: 2, To: 1, Type: msgAppResp, Index: -1})
 	msgs = sm.ReadMessages()
 	if len(msgs) != 1 {
 		t.Errorf("len(msgs) = %d, want 1", len(msgs))
@@ -853,11 +846,11 @@ func TestRestoreFromSnapMsg(t *testing.T) {
 	s := pb.Snapshot{
 		Index: defaultCompactThreshold + 1,
 		Term:  defaultCompactThreshold + 1,
-		Nodes: []int64{firstId, firstId + 1},
+		Nodes: []int64{1, 2},
 	}
-	m := pb.Message{Type: msgSnap, From: firstId, Term: firstId + 1, Snapshot: s}
+	m := pb.Message{Type: msgSnap, From: 1, Term: 2, Snapshot: s}
 
-	sm := newRaft(firstId+1, []int64{firstId, firstId + 1}, 0, 0)
+	sm := newRaft(2, []int64{1, 2}, 0, 0)
 	sm.Step(m)
 
 	if !reflect.DeepEqual(sm.raftLog.snapshot, s) {
@@ -867,26 +860,26 @@ func TestRestoreFromSnapMsg(t *testing.T) {
 
 func TestSlowNodeRestore(t *testing.T) {
 	nt := newNetwork(nil, nil, nil)
-	nt.send(pb.Message{From: firstId, To: firstId, Type: msgHup})
+	nt.send(pb.Message{From: 1, To: 1, Type: msgHup})
 
-	nt.isolate(firstId + 2)
+	nt.isolate(3)
 	for j := 0; j < defaultCompactThreshold+1; j++ {
-		nt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{}}})
+		nt.send(pb.Message{From: 1, To: 1, Type: msgProp, Entries: []pb.Entry{{}}})
 	}
-	lead := nt.peers[firstId].(*raft)
+	lead := nt.peers[1].(*raft)
 	lead.nextEnts()
 	lead.compact(nil)
 
 	nt.recover()
-	nt.send(pb.Message{From: firstId, To: firstId, Type: msgBeat})
+	nt.send(pb.Message{From: 1, To: 1, Type: msgBeat})
 
-	follower := nt.peers[firstId+2].(*raft)
+	follower := nt.peers[3].(*raft)
 	if !reflect.DeepEqual(follower.raftLog.snapshot, lead.raftLog.snapshot) {
 		t.Errorf("follower.snap = %+v, want %+v", follower.raftLog.snapshot, lead.raftLog.snapshot)
 	}
 
 	committed := follower.raftLog.lastIndex()
-	nt.send(pb.Message{From: firstId, To: firstId, Type: msgProp, Entries: []pb.Entry{{}}})
+	nt.send(pb.Message{From: 1, To: 1, Type: msgProp, Entries: []pb.Entry{{}}})
 	if follower.raftLog.committed != committed+1 {
 		t.Errorf("follower.comitted = %d, want %d", follower.raftLog.committed, committed+1)
 	}
@@ -917,7 +910,7 @@ func newNetwork(peers ...Interface) *network {
 	size := len(peers)
 	peerAddrs := make([]int64, size)
 	for i := 0; i < size; i++ {
-		peerAddrs[i] = firstId + int64(i)
+		peerAddrs[i] = 1 + int64(i)
 	}
 
 	npeers := make(map[int64]Interface, size)
@@ -969,7 +962,7 @@ func (nw *network) cut(one, other int64) {
 
 func (nw *network) isolate(id int64) {
 	for i := 0; i < len(nw.peers); i++ {
-		nid := firstId + int64(i)
+		nid := 1 + int64(i)
 		if nid != id {
 			nw.drop(id, nid, 1.0)
 			nw.drop(nid, id, 1.0)

From dc1357afa9bea43710e1671657a37d5236608780 Mon Sep 17 00:00:00 2001
From: Yicheng Qin <qycqycqycqycqyc@gmail.com>
Date: Thu, 11 Sep 2014 19:25:08 -0700
Subject: [PATCH 06/11] raft: use raft helper function in testing

---
 raft/raft_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/raft/raft_test.go b/raft/raft_test.go
index 16457faed..b276b5988 100644
--- a/raft/raft_test.go
+++ b/raft/raft_test.go
@@ -11,7 +11,7 @@ import (
 )
 
 // nextEnts returns the appliable entries and updates the applied index
-func (r *raft) nextEnts() (ents []pb.Entry) {
+func nextEnts(r *raft) (ents []pb.Entry) {
 	ents = r.raftLog.nextEnts()
 	r.raftLog.resetNextEnts()
 	return ents
@@ -91,7 +91,7 @@ func TestLogReplication(t *testing.T) {
 			}
 
 			ents := make([]pb.Entry, 0)
-			for _, e := range sm.nextEnts() {
+			for _, e := range nextEnts(sm) {
 				if e.Data != nil {
 					ents = append(ents, e)
 				}
@@ -867,7 +867,7 @@ func TestSlowNodeRestore(t *testing.T) {
 		nt.send(pb.Message{From: 1, To: 1, Type: msgProp, Entries: []pb.Entry{{}}})
 	}
 	lead := nt.peers[1].(*raft)
-	lead.nextEnts()
+	nextEnts(lead)
 	lead.compact(nil)
 
 	nt.recover()

From 073411f23fa39fefc65b54773d7b74ec11c837ed Mon Sep 17 00:00:00 2001
From: Yicheng Qin <qycqycqycqycqyc@gmail.com>
Date: Thu, 11 Sep 2014 23:17:13 -0700
Subject: [PATCH 07/11] raft: remove vote with default value

---
 raft/node_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/raft/node_test.go b/raft/node_test.go
index 12e5d6f67..210f5c6b1 100644
--- a/raft/node_test.go
+++ b/raft/node_test.go
@@ -14,12 +14,12 @@ func TestNode(t *testing.T) {
 
 	wants := []Ready{
 		{
-			State:            raftpb.State{Term: 1, Vote: none, Commit: 1, LastIndex: 1},
+			State:            raftpb.State{Term: 1, Commit: 1, LastIndex: 1},
 			Entries:          []raftpb.Entry{{Term: 1, Index: 1}},
 			CommittedEntries: []raftpb.Entry{{Term: 1, Index: 1}},
 		},
 		{
-			State:            raftpb.State{Term: 1, Vote: none, Commit: 2, LastIndex: 2},
+			State:            raftpb.State{Term: 1, Commit: 2, LastIndex: 2},
 			Entries:          []raftpb.Entry{{Term: 1, Index: 2, Data: []byte("foo")}},
 			CommittedEntries: []raftpb.Entry{{Term: 1, Index: 2, Data: []byte("foo")}},
 		},
@@ -48,7 +48,7 @@ func TestNodeRestart(t *testing.T) {
 		{Term: 1, Index: 1},
 		{Term: 1, Index: 2, Data: []byte("foo")},
 	}
-	st := raftpb.State{Term: 1, Vote: none, Commit: 1, LastIndex: 2}
+	st := raftpb.State{Term: 1, Commit: 1, LastIndex: 2}
 
 	want := Ready{
 		State: emptyState,

From 30289dad5cc57ffcba108482fc68bddcc31887cd Mon Sep 17 00:00:00 2001
From: Yicheng Qin <qycqycqycqycqyc@gmail.com>
Date: Thu, 11 Sep 2014 23:18:51 -0700
Subject: [PATCH 08/11] raft: more descriptive panic info

---
 raft/raft_test.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/raft/raft_test.go b/raft/raft_test.go
index b276b5988..edb3e321b 100644
--- a/raft/raft_test.go
+++ b/raft/raft_test.go
@@ -2,6 +2,7 @@ package raft
 
 import (
 	"bytes"
+	"fmt"
 	"math/rand"
 	"reflect"
 	"sort"
@@ -932,7 +933,7 @@ func newNetwork(peers ...Interface) *network {
 		case *blackHole:
 			npeers[id] = v
 		default:
-			panic("unimplemented")
+			panic(fmt.Sprintf("unexpected state machine type: %T", p))
 		}
 	}
 	return &network{

From 34db45a94892e1e1f07ba8af89d956dc22772214 Mon Sep 17 00:00:00 2001
From: Yicheng Qin <qycqycqycqycqyc@gmail.com>
Date: Fri, 12 Sep 2014 12:57:50 -0700
Subject: [PATCH 09/11] raft: set propc, readyc to be nil before run loop

---
 raft/node.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/raft/node.go b/raft/node.go
index 275324306..c0cfb4297 100644
--- a/raft/node.go
+++ b/raft/node.go
@@ -86,8 +86,8 @@ func (n *Node) Stop() {
 }
 
 func (n *Node) run(r *raft) {
-	propc := n.propc
-	readyc := n.readyc
+	var propc chan pb.Message
+	var readyc chan Ready
 
 	var lead int64
 	prevSt := r.State

From 54b9c55af39529065cfba757bf78695ea1b28261 Mon Sep 17 00:00:00 2001
From: Yicheng Qin <qycqycqycqycqyc@gmail.com>
Date: Fri, 12 Sep 2014 13:01:33 -0700
Subject: [PATCH 10/11] etcdserver: remove useless sleep

etcdserver.Do will block until there exists leader
---
 etcdserver/server_test.go | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/etcdserver/server_test.go b/etcdserver/server_test.go
index a6bf44c23..c1d093d3a 100644
--- a/etcdserver/server_test.go
+++ b/etcdserver/server_test.go
@@ -53,11 +53,6 @@ func testServer(t *testing.T, ns int64) {
 		ss[i] = srv
 	}
 
-	// TODO: find fast way to trigger leader election
-	// TODO: introduce the way to know that the leader has been elected
-	// then remove this sleep.
-	time.Sleep(110 * time.Millisecond)
-
 	for i := 1; i <= 10; i++ {
 		r := pb.Request{
 			Method: "PUT",

From 2927cc6e3bdbae7b0d4c2782c62ceb30dfc8bea8 Mon Sep 17 00:00:00 2001
From: Yicheng Qin <qycqycqycqycqyc@gmail.com>
Date: Sun, 14 Sep 2014 22:07:32 -0700
Subject: [PATCH 11/11] raft: refine plus assignment

---
 raft/raft_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/raft/raft_test.go b/raft/raft_test.go
index edb3e321b..f435bd384 100644
--- a/raft/raft_test.go
+++ b/raft/raft_test.go
@@ -963,7 +963,7 @@ func (nw *network) cut(one, other int64) {
 
 func (nw *network) isolate(id int64) {
 	for i := 0; i < len(nw.peers); i++ {
-		nid := 1 + int64(i)
+		nid := int64(i) + 1
 		if nid != id {
 			nw.drop(id, nid, 1.0)
 			nw.drop(nid, id, 1.0)