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)