Mirroristas/etcd
2
0
Fork 0
mirror of https://github.com/etcd-io/etcd.git synced 2024-09-27 06:25:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #3981 from gyuho/govet

Browse Source 
*: fix shadowed variables
This commit is contained in:
Xiang Li 2015-12-13 00:00:12 -08:00
commit 0225644d04
19 changed files with 123 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
client/auth_role.go
View File

@ -115,14 +115,13 @@ func (r *httpAuthRoleAPI) ListRoles(ctx context.Context) ([]string, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} }
if err := assertStatusCode(resp.StatusCode, http.StatusOK); err != nil { if err = assertStatusCode(resp.StatusCode, http.StatusOK); err != nil {
return nil, err return nil, err
} }
var userList struct { var userList struct {
Roles []string `json:"roles"` Roles []string `json:"roles"`
} }
err = json.Unmarshal(body, &userList) if err = json.Unmarshal(body, &userList); err != nil {
if err != nil {
return nil, err return nil, err
} }
return userList.Roles, nil return userList.Roles, nil
@ -218,17 +217,16 @@ func (r *httpAuthRoleAPI) modRole(ctx context.Context, req *authRoleAPIAction) (
if err != nil { if err != nil {
return nil, err return nil, err
} }
if err := assertStatusCode(resp.StatusCode, http.StatusOK); err != nil { if err = assertStatusCode(resp.StatusCode, http.StatusOK); err != nil {
var sec authError var sec authError
err := json.Unmarshal(body, &sec) err = json.Unmarshal(body, &sec)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return nil, sec return nil, sec
} }
var role Role var role Role
err = json.Unmarshal(body, &role) if err = json.Unmarshal(body, &role); err != nil {
if err != nil {
return nil, err return nil, err
} }
return &role, nil return &role, nil

22
client/auth_user.go
View File

@ -78,9 +78,9 @@ func (s *httpAuthAPI) enableDisable(ctx context.Context, req httpAction) error {
if err != nil { if err != nil {
return err return err
} }
if err := assertStatusCode(resp.StatusCode, http.StatusOK, http.StatusCreated); err != nil { if err = assertStatusCode(resp.StatusCode, http.StatusOK, http.StatusCreated); err != nil {
var sec authError var sec authError
err := json.Unmarshal(body, &sec) err = json.Unmarshal(body, &sec)
if err != nil { if err != nil {
return err return err
} }
@ -179,9 +179,9 @@ func (u *httpAuthUserAPI) ListUsers(ctx context.Context) ([]string, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} }
if err := assertStatusCode(resp.StatusCode, http.StatusOK); err != nil { if err = assertStatusCode(resp.StatusCode, http.StatusOK); err != nil {
var sec authError var sec authError
err := json.Unmarshal(body, &sec) err = json.Unmarshal(body, &sec)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -190,8 +190,7 @@ func (u *httpAuthUserAPI) ListUsers(ctx context.Context) ([]string, error) {
var userList struct { var userList struct {
Users []string `json:"users"` Users []string `json:"users"`
} }
err = json.Unmarshal(body, &userList) if err = json.Unmarshal(body, &userList); err != nil {
if err != nil {
return nil, err return nil, err
} }
return userList.Users, nil return userList.Users, nil
@ -221,9 +220,9 @@ func (u *httpAuthUserAPI) addRemoveUser(ctx context.Context, req *authUserAPIAct
if err != nil { if err != nil {
return err return err
} }
if err := assertStatusCode(resp.StatusCode, http.StatusOK, http.StatusCreated); err != nil { if err = assertStatusCode(resp.StatusCode, http.StatusOK, http.StatusCreated); err != nil {
var sec authError var sec authError
err := json.Unmarshal(body, &sec) err = json.Unmarshal(body, &sec)
if err != nil { if err != nil {
return err return err
} }
@ -280,17 +279,16 @@ func (u *httpAuthUserAPI) modUser(ctx context.Context, req *authUserAPIAction) (
if err != nil { if err != nil {
return nil, err return nil, err
} }
if err := assertStatusCode(resp.StatusCode, http.StatusOK); err != nil { if err = assertStatusCode(resp.StatusCode, http.StatusOK); err != nil {
var sec authError var sec authError
err := json.Unmarshal(body, &sec) err = json.Unmarshal(body, &sec)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return nil, sec return nil, sec
} }
var user User var user User
err = json.Unmarshal(body, &user) if err = json.Unmarshal(body, &user); err != nil {
if err != nil {
return nil, err return nil, err
} }
return &user, nil return &user, nil

2
etcdctl/command/backup_command.go
View File

@ -61,7 +61,7 @@ func handleBackup(c *cli.Context) {
if snapshot != nil { if snapshot != nil {
walsnap.Index, walsnap.Term = snapshot.Metadata.Index, snapshot.Metadata.Term walsnap.Index, walsnap.Term = snapshot.Metadata.Index, snapshot.Metadata.Term
newss := snap.New(destSnap) newss := snap.New(destSnap)
if err := newss.SaveSnap(*snapshot); err != nil { if err = newss.SaveSnap(*snapshot); err != nil {
log.Fatal(err) log.Fatal(err)
} }
} }

2
etcdmain/etcd.go
View File

@ -363,7 +363,7 @@ func startProxy(cfg *config) error {
plog.Warningf("discovery token ignored since the proxy has already been initialized. Valid cluster file found at %q", clusterfile) plog.Warningf("discovery token ignored since the proxy has already been initialized. Valid cluster file found at %q", clusterfile)
} }
urls := struct{ PeerURLs []string }{} urls := struct{ PeerURLs []string }{}
err := json.Unmarshal(b, &urls) err = json.Unmarshal(b, &urls)
if err != nil { if err != nil {
return err return err
} }

24
etcdserver/auth/auth.go
View File

@ -424,28 +424,26 @@ func (s *store) EnableAuth() error {
s.mu.Lock() s.mu.Lock()
defer s.mu.Unlock() defer s.mu.Unlock()
_, err := s.GetUser("root") if _, err := s.GetUser("root"); err != nil {
if err != nil {
return authErr(http.StatusConflict, "No root user available, please create one") return authErr(http.StatusConflict, "No root user available, please create one")
} }
_, err = s.GetRole(GuestRoleName) if _, err := s.GetRole(GuestRoleName); err != nil {
if err != nil {
plog.Printf("no guest role access found, creating default") plog.Printf("no guest role access found, creating default")
err := s.CreateRole(guestRole) if err := s.CreateRole(guestRole); err != nil {
if err != nil {
plog.Errorf("error creating guest role. aborting auth enable.") plog.Errorf("error creating guest role. aborting auth enable.")
return err return err
} }
} }
err = s.enableAuth()
if err == nil { if err := s.enableAuth(); err != nil {
b := true
s.enabled = &b
plog.Noticef("auth: enabled auth")
} else {
plog.Errorf("error enabling auth (%v)", err) plog.Errorf("error enabling auth (%v)", err)
return err
} }
return err
b := true
s.enabled = &b
plog.Noticef("auth: enabled auth")
return nil
} }
func (s *store) DisableAuth() error { func (s *store) DisableAuth() error {

4
etcdserver/cluster_util.go
View File

@ -78,7 +78,7 @@ func getClusterFromRemotePeers(urls []string, timeout time.Duration, logerr bool
continue continue
} }
var membs []*Member var membs []*Member
if err := json.Unmarshal(b, &membs); err != nil { if err = json.Unmarshal(b, &membs); err != nil {
if logerr { if logerr {
plog.Warningf("could not unmarshal cluster response: %v", err) plog.Warningf("could not unmarshal cluster response: %v", err)
} }
@ -246,7 +246,7 @@ func getVersion(m *Member, rt http.RoundTripper) (*version.Versions, error) {
continue continue
} }
var vers version.Versions var vers version.Versions
if err := json.Unmarshal(b, &vers); err != nil { if err = json.Unmarshal(b, &vers); err != nil {
plog.Warningf("failed to unmarshal the response body got from the peerURL(%s) of member %s (%v)", u, m.ID, err) plog.Warningf("failed to unmarshal the response body got from the peerURL(%s) of member %s (%v)", u, m.ID, err)
continue continue
} }

8
etcdserver/raft.go
View File

@ -158,14 +158,14 @@ func (r *raftNode) start(s *EtcdServer) {
} }
} }
apply := apply{ ap := apply{
entries: rd.CommittedEntries, entries: rd.CommittedEntries,
snapshot: rd.Snapshot, snapshot: rd.Snapshot,
done: make(chan struct{}), done: make(chan struct{}),
} }
select { select {
case r.applyc <- apply: case r.applyc <- ap:
case <-r.stopped: case <-r.stopped:
return return
} }
@ -185,7 +185,7 @@ func (r *raftNode) start(s *EtcdServer) {
r.s.send(rd.Messages) r.s.send(rd.Messages)
select { select {
case <-apply.done: case <-ap.done:
case <-r.stopped: case <-r.stopped:
return return
} }
@ -253,7 +253,7 @@ func startNode(cfg *ServerConfig, cl *cluster, ids []types.ID) (id types.ID, n r
ClusterID: uint64(cl.ID()), ClusterID: uint64(cl.ID()),
}, },
) )
if err := os.MkdirAll(cfg.SnapDir(), privateDirMode); err != nil { if err = os.MkdirAll(cfg.SnapDir(), privateDirMode); err != nil {
plog.Fatalf("create snapshot directory error: %v", err) plog.Fatalf("create snapshot directory error: %v", err)
} }
if w, err = wal.Create(cfg.WALDir(), metadata); err != nil { if w, err = wal.Create(cfg.WALDir(), metadata); err != nil {

2
etcdserver/server.go
View File

@ -1037,7 +1037,7 @@ func (s *EtcdServer) snapshot(snapi uint64, confState raftpb.ConfState) {
} }
// SaveSnap saves the snapshot and releases the locked wal files // SaveSnap saves the snapshot and releases the locked wal files
// to the snapshot index. // to the snapshot index.
if err := s.r.storage.SaveSnap(snap); err != nil { if err = s.r.storage.SaveSnap(snap); err != nil {
plog.Fatalf("save snapshot error: %v", err) plog.Fatalf("save snapshot error: %v", err)
} }
plog.Infof("saved snapshot at index %d", snap.Metadata.Index) plog.Infof("saved snapshot at index %d", snap.Metadata.Index)

2
pkg/fileutil/fileutil_test.go
View File

@ -52,7 +52,7 @@ func TestReadDir(t *testing.T) {
if err != nil { if err != nil {
t.Fatalf("error creating file: %v", err) t.Fatalf("error creating file: %v", err)
} }
if err := fh.Close(); err != nil { if err = fh.Close(); err != nil {
t.Fatalf("error closing file: %v", err) t.Fatalf("error closing file: %v", err)
} }
} }

2
pkg/fileutil/lock_test.go
View File

@ -28,7 +28,7 @@ func TestLockAndUnlock(t *testing.T) {
} }
f.Close() f.Close()
defer func() { defer func() {
err := os.Remove(f.Name()) err = os.Remove(f.Name())
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

2
pkg/fileutil/purge_test.go
View File

@ -121,7 +121,7 @@ func TestPurgeFileHoldingLock(t *testing.T) {
} }
select { select {
case err := <-errch: case err = <-errch:
t.Errorf("unexpected purge error %v", err) t.Errorf("unexpected purge error %v", err)
case <-time.After(time.Millisecond): case <-time.After(time.Millisecond):
} }

8
raft/rafttest/network.go
View File

@ -85,7 +85,7 @@ func (rn *raftNetwork) send(m raftpb.Message) {
to = nil to = nil
} }
drop := rn.dropmap[conn{m.From, m.To}] drop := rn.dropmap[conn{m.From, m.To}]
delay := rn.delaymap[conn{m.From, m.To}] dl := rn.delaymap[conn{m.From, m.To}]
rn.mu.Unlock() rn.mu.Unlock()
if to == nil { if to == nil {
@ -94,9 +94,9 @@ func (rn *raftNetwork) send(m raftpb.Message) {
if drop != 0 && rand.Float64() < drop { if drop != 0 && rand.Float64() < drop {
return return
} }
// TODO: shall we delay without blocking the send call? // TODO: shall we dl without blocking the send call?
if delay.d != 0 && rand.Float64() < delay.rate { if dl.d != 0 && rand.Float64() < dl.rate {
rd := rand.Int63n(int64(delay.d)) rd := rand.Int63n(int64(dl.d))
time.Sleep(time.Duration(rd)) time.Sleep(time.Duration(rd))
} }

80
storage/index_test.go
View File

@ -20,10 +20,10 @@ import (
) )
func TestIndexGet(t *testing.T) { func TestIndexGet(t *testing.T) {
index := newTreeIndex() ti := newTreeIndex()
index.Put([]byte("foo"), revision{main: 2}) ti.Put([]byte("foo"), revision{main: 2})
index.Put([]byte("foo"), revision{main: 4}) ti.Put([]byte("foo"), revision{main: 4})
index.Tombstone([]byte("foo"), revision{main: 6}) ti.Tombstone([]byte("foo"), revision{main: 6})
tests := []struct { tests := []struct {
rev int64 rev int64
@ -42,7 +42,7 @@ func TestIndexGet(t *testing.T) {
{6, revision{}, revision{}, 0, ErrRevisionNotFound}, {6, revision{}, revision{}, 0, ErrRevisionNotFound},
} }
for i, tt := range tests { for i, tt := range tests {
rev, created, ver, err := index.Get([]byte("foo"), tt.rev) rev, created, ver, err := ti.Get([]byte("foo"), tt.rev)
if err != tt.werr { if err != tt.werr {
t.Errorf("#%d: err = %v, want %v", i, err, tt.werr) t.Errorf("#%d: err = %v, want %v", i, err, tt.werr)
} }
@ -62,9 +62,9 @@ func TestIndexRange(t *testing.T) {
allKeys := [][]byte{[]byte("foo"), []byte("foo1"), []byte("foo2")} allKeys := [][]byte{[]byte("foo"), []byte("foo1"), []byte("foo2")}
allRevs := []revision{{main: 1}, {main: 2}, {main: 3}} allRevs := []revision{{main: 1}, {main: 2}, {main: 3}}
index := newTreeIndex() ti := newTreeIndex()
for i := range allKeys { for i := range allKeys {
index.Put(allKeys[i], allRevs[i]) ti.Put(allKeys[i], allRevs[i])
} }
atRev := int64(3) atRev := int64(3)
@ -107,7 +107,7 @@ func TestIndexRange(t *testing.T) {
}, },
} }
for i, tt := range tests { for i, tt := range tests {
keys, revs := index.Range(tt.key, tt.end, atRev) keys, revs := ti.Range(tt.key, tt.end, atRev)
if !reflect.DeepEqual(keys, tt.wkeys) { if !reflect.DeepEqual(keys, tt.wkeys) {
t.Errorf("#%d: keys = %+v, want %+v", i, keys, tt.wkeys) t.Errorf("#%d: keys = %+v, want %+v", i, keys, tt.wkeys)
} }
@ -118,19 +118,19 @@ func TestIndexRange(t *testing.T) {
} }
func TestIndexTombstone(t *testing.T) { func TestIndexTombstone(t *testing.T) {
index := newTreeIndex() ti := newTreeIndex()
index.Put([]byte("foo"), revision{main: 1}) ti.Put([]byte("foo"), revision{main: 1})
err := index.Tombstone([]byte("foo"), revision{main: 2}) err := ti.Tombstone([]byte("foo"), revision{main: 2})
if err != nil { if err != nil {
t.Errorf("tombstone error = %v, want nil", err) t.Errorf("tombstone error = %v, want nil", err)
} }
_, _, _, err = index.Get([]byte("foo"), 2) _, _, _, err = ti.Get([]byte("foo"), 2)
if err != ErrRevisionNotFound { if err != ErrRevisionNotFound {
t.Errorf("get error = %v, want nil", err) t.Errorf("get error = %v, want nil", err)
} }
err = index.Tombstone([]byte("foo"), revision{main: 3}) err = ti.Tombstone([]byte("foo"), revision{main: 3})
if err != ErrRevisionNotFound { if err != ErrRevisionNotFound {
t.Errorf("tombstone error = %v, want %v", err, ErrRevisionNotFound) t.Errorf("tombstone error = %v, want %v", err, ErrRevisionNotFound)
} }
@ -140,9 +140,9 @@ func TestIndexRangeSince(t *testing.T) {
allKeys := [][]byte{[]byte("foo"), []byte("foo1"), []byte("foo2"), []byte("foo2"), []byte("foo1"), []byte("foo")} allKeys := [][]byte{[]byte("foo"), []byte("foo1"), []byte("foo2"), []byte("foo2"), []byte("foo1"), []byte("foo")}
allRevs := []revision{{main: 1}, {main: 2}, {main: 3}, {main: 4}, {main: 5}, {main: 6}} allRevs := []revision{{main: 1}, {main: 2}, {main: 3}, {main: 4}, {main: 5}, {main: 6}}
index := newTreeIndex() ti := newTreeIndex()
for i := range allKeys { for i := range allKeys {
index.Put(allKeys[i], allRevs[i]) ti.Put(allKeys[i], allRevs[i])
} }
atRev := int64(1) atRev := int64(1)
@ -184,7 +184,7 @@ func TestIndexRangeSince(t *testing.T) {
}, },
} }
for i, tt := range tests { for i, tt := range tests {
revs := index.RangeSince(tt.key, tt.end, atRev) revs := ti.RangeSince(tt.key, tt.end, atRev)
if !reflect.DeepEqual(revs, tt.wrevs) { if !reflect.DeepEqual(revs, tt.wrevs) {
t.Errorf("#%d: revs = %+v, want %+v", i, revs, tt.wrevs) t.Errorf("#%d: revs = %+v, want %+v", i, revs, tt.wrevs)
} }
@ -214,56 +214,56 @@ func TestIndexCompact(t *testing.T) {
} }
// Continuous Compact // Continuous Compact
index := newTreeIndex() ti := newTreeIndex()
for _, tt := range tests { for _, tt := range tests {
if tt.remove { if tt.remove {
index.Tombstone(tt.key, tt.rev) ti.Tombstone(tt.key, tt.rev)
} else { } else {
index.Put(tt.key, tt.rev) ti.Put(tt.key, tt.rev)
} }
} }
for i := int64(1); i < maxRev; i++ { for i := int64(1); i < maxRev; i++ {
am := index.Compact(i) am := ti.Compact(i)
windex := newTreeIndex() wti := newTreeIndex()
for _, tt := range tests { for _, tt := range tests {
if _, ok := am[tt.rev]; ok || tt.rev.GreaterThan(revision{main: i}) { if _, ok := am[tt.rev]; ok || tt.rev.GreaterThan(revision{main: i}) {
if tt.remove { if tt.remove {
windex.Tombstone(tt.key, tt.rev) wti.Tombstone(tt.key, tt.rev)
} else { } else {
windex.Restore(tt.key, tt.created, tt.rev, tt.ver) wti.Restore(tt.key, tt.created, tt.rev, tt.ver)
} }
} }
} }
if !index.Equal(windex) { if !ti.Equal(wti) {
t.Errorf("#%d: not equal index", i) t.Errorf("#%d: not equal ti", i)
} }
} }
// Once Compact // Once Compact
for i := int64(1); i < maxRev; i++ { for i := int64(1); i < maxRev; i++ {
index := newTreeIndex() ti := newTreeIndex()
for _, tt := range tests { for _, tt := range tests {
if tt.remove { if tt.remove {
index.Tombstone(tt.key, tt.rev) ti.Tombstone(tt.key, tt.rev)
} else { } else {
index.Put(tt.key, tt.rev) ti.Put(tt.key, tt.rev)
} }
} }
am := index.Compact(i) am := ti.Compact(i)
windex := newTreeIndex() wti := newTreeIndex()
for _, tt := range tests { for _, tt := range tests {
if _, ok := am[tt.rev]; ok || tt.rev.GreaterThan(revision{main: i}) { if _, ok := am[tt.rev]; ok || tt.rev.GreaterThan(revision{main: i}) {
if tt.remove { if tt.remove {
windex.Tombstone(tt.key, tt.rev) wti.Tombstone(tt.key, tt.rev)
} else { } else {
windex.Restore(tt.key, tt.created, tt.rev, tt.ver) wti.Restore(tt.key, tt.created, tt.rev, tt.ver)
} }
} }
} }
if !index.Equal(windex) { if !ti.Equal(wti) {
t.Errorf("#%d: not equal index", i) t.Errorf("#%d: not equal ti", i)
} }
} }
} }
@ -282,11 +282,11 @@ func TestIndexRestore(t *testing.T) {
} }
// Continuous Restore // Continuous Restore
index := newTreeIndex() ti := newTreeIndex()
for i, tt := range tests { for i, tt := range tests {
index.Restore(key, tt.created, tt.modified, tt.ver) ti.Restore(key, tt.created, tt.modified, tt.ver)
modified, created, ver, err := index.Get(key, tt.modified.main) modified, created, ver, err := ti.Get(key, tt.modified.main)
if modified != tt.modified { if modified != tt.modified {
t.Errorf("#%d: modified = %v, want %v", i, modified, tt.modified) t.Errorf("#%d: modified = %v, want %v", i, modified, tt.modified)
} }
@ -303,10 +303,10 @@ func TestIndexRestore(t *testing.T) {
// Once Restore // Once Restore
for i, tt := range tests { for i, tt := range tests {
index := newTreeIndex() ti := newTreeIndex()
index.Restore(key, tt.created, tt.modified, tt.ver) ti.Restore(key, tt.created, tt.modified, tt.ver)
modified, created, ver, err := index.Get(key, tt.modified.main) modified, created, ver, err := ti.Get(key, tt.modified.main)
if modified != tt.modified { if modified != tt.modified {
t.Errorf("#%d: modified = %v, want %v", i, modified, tt.modified) t.Errorf("#%d: modified = %v, want %v", i, modified, tt.modified)
} }

40
storage/kvstore_test.go
View File

@ -94,10 +94,10 @@ func TestStorePut(t *testing.T) {
}, },
} }
for i, tt := range tests { for i, tt := range tests {
s, b, index := newFakeStore() s, b, fi := newFakeStore()
s.currentRev = tt.rev s.currentRev = tt.rev
s.tx = b.BatchTx() s.tx = b.BatchTx()
index.indexGetRespc <- tt.r fi.indexGetRespc <- tt.r
s.put([]byte("foo"), []byte("bar")) s.put([]byte("foo"), []byte("bar"))
@ -115,7 +115,7 @@ func TestStorePut(t *testing.T) {
{"get", []interface{}{[]byte("foo"), tt.wputrev.main}}, {"get", []interface{}{[]byte("foo"), tt.wputrev.main}},
{"put", []interface{}{[]byte("foo"), tt.wputrev}}, {"put", []interface{}{[]byte("foo"), tt.wputrev}},
} }
if g := index.Action(); !reflect.DeepEqual(g, wact) { if g := fi.Action(); !reflect.DeepEqual(g, wact) {
t.Errorf("#%d: index action = %+v, want %+v", i, g, wact) t.Errorf("#%d: index action = %+v, want %+v", i, g, wact)
} }
if s.currentRev != tt.wrev { if s.currentRev != tt.wrev {
@ -154,11 +154,11 @@ func TestStoreRange(t *testing.T) {
}, },
} }
for i, tt := range tests { for i, tt := range tests {
s, b, index := newFakeStore() s, b, fi := newFakeStore()
s.currentRev = currev s.currentRev = currev
s.tx = b.BatchTx() s.tx = b.BatchTx()
b.tx.rangeRespc <- tt.r b.tx.rangeRespc <- tt.r
index.indexRangeRespc <- tt.idxr fi.indexRangeRespc <- tt.idxr
kvs, rev, err := s.rangeKeys([]byte("foo"), []byte("goo"), 1, 0) kvs, rev, err := s.rangeKeys([]byte("foo"), []byte("goo"), 1, 0)
if err != nil { if err != nil {
@ -181,7 +181,7 @@ func TestStoreRange(t *testing.T) {
wact = []testutil.Action{ wact = []testutil.Action{
{"range", []interface{}{[]byte("foo"), []byte("goo"), wrev}}, {"range", []interface{}{[]byte("foo"), []byte("goo"), wrev}},
} }
if g := index.Action(); !reflect.DeepEqual(g, wact) { if g := fi.Action(); !reflect.DeepEqual(g, wact) {
t.Errorf("#%d: index action = %+v, want %+v", i, g, wact) t.Errorf("#%d: index action = %+v, want %+v", i, g, wact)
} }
if s.currentRev != currev { if s.currentRev != currev {
@ -218,10 +218,10 @@ func TestStoreDeleteRange(t *testing.T) {
}, },
} }
for i, tt := range tests { for i, tt := range tests {
s, b, index := newFakeStore() s, b, fi := newFakeStore()
s.currentRev = tt.rev s.currentRev = tt.rev
s.tx = b.BatchTx() s.tx = b.BatchTx()
index.indexRangeRespc <- tt.r fi.indexRangeRespc <- tt.r
n := s.deleteRange([]byte("foo"), []byte("goo")) n := s.deleteRange([]byte("foo"), []byte("goo"))
if n != 1 { if n != 1 {
@ -244,7 +244,7 @@ func TestStoreDeleteRange(t *testing.T) {
{"range", []interface{}{[]byte("foo"), []byte("goo"), tt.wrrev}}, {"range", []interface{}{[]byte("foo"), []byte("goo"), tt.wrrev}},
{"tombstone", []interface{}{[]byte("foo"), tt.wdelrev}}, {"tombstone", []interface{}{[]byte("foo"), tt.wdelrev}},
} }
if g := index.Action(); !reflect.DeepEqual(g, wact) { if g := fi.Action(); !reflect.DeepEqual(g, wact) {
t.Errorf("#%d: index action = %+v, want %+v", i, g, wact) t.Errorf("#%d: index action = %+v, want %+v", i, g, wact)
} }
if s.currentRev != tt.wrev { if s.currentRev != tt.wrev {
@ -282,9 +282,9 @@ func TestStoreRangeHistory(t *testing.T) {
}, },
} }
for i, tt := range tests { for i, tt := range tests {
s, b, index := newFakeStore() s, b, fi := newFakeStore()
s.currentRev = currev s.currentRev = currev
index.indexRangeEventsRespc <- tt.idxr fi.indexRangeEventsRespc <- tt.idxr
b.tx.rangeRespc <- tt.r b.tx.rangeRespc <- tt.r
keys, kvs, _, err := s.RangeHistory([]byte("foo"), []byte("goo"), 1, 1) keys, kvs, _, err := s.RangeHistory([]byte("foo"), []byte("goo"), 1, 1)
@ -301,7 +301,7 @@ func TestStoreRangeHistory(t *testing.T) {
wact := []testutil.Action{ wact := []testutil.Action{
{"rangeEvents", []interface{}{[]byte("foo"), []byte("goo"), int64(1)}}, {"rangeEvents", []interface{}{[]byte("foo"), []byte("goo"), int64(1)}},
} }
if g := index.Action(); !reflect.DeepEqual(g, wact) { if g := fi.Action(); !reflect.DeepEqual(g, wact) {
t.Errorf("#%d: index action = %+v, want %+v", i, g, wact) t.Errorf("#%d: index action = %+v, want %+v", i, g, wact)
} }
wstart, wend := revBytesRange(tt.idxr.revs[0]) wstart, wend := revBytesRange(tt.idxr.revs[0])
@ -318,9 +318,9 @@ func TestStoreRangeHistory(t *testing.T) {
} }
func TestStoreCompact(t *testing.T) { func TestStoreCompact(t *testing.T) {
s, b, index := newFakeStore() s, b, fi := newFakeStore()
s.currentRev = revision{3, 0} s.currentRev = revision{3, 0}
index.indexCompactRespc <- map[revision]struct{}{revision{1, 0}: {}} fi.indexCompactRespc <- map[revision]struct{}{revision{1, 0}: {}}
key1 := newTestKeyBytes(revision{1, 0}, false) key1 := newTestKeyBytes(revision{1, 0}, false)
key2 := newTestKeyBytes(revision{2, 0}, false) key2 := newTestKeyBytes(revision{2, 0}, false)
b.tx.rangeRespc <- rangeResp{[][]byte{key1, key2}, nil} b.tx.rangeRespc <- rangeResp{[][]byte{key1, key2}, nil}
@ -345,13 +345,13 @@ func TestStoreCompact(t *testing.T) {
wact = []testutil.Action{ wact = []testutil.Action{
{"compact", []interface{}{int64(3)}}, {"compact", []interface{}{int64(3)}},
} }
if g := index.Action(); !reflect.DeepEqual(g, wact) { if g := fi.Action(); !reflect.DeepEqual(g, wact) {
t.Errorf("index action = %+v, want %+v", g, wact) t.Errorf("index action = %+v, want %+v", g, wact)
} }
} }
func TestStoreRestore(t *testing.T) { func TestStoreRestore(t *testing.T) {
s, b, index := newFakeStore() s, b, fi := newFakeStore()
putkey := newTestKeyBytes(revision{3, 0}, false) putkey := newTestKeyBytes(revision{3, 0}, false)
putkv := storagepb.KeyValue{ putkv := storagepb.KeyValue{
@ -398,7 +398,7 @@ func TestStoreRestore(t *testing.T) {
{"restore", []interface{}{[]byte("foo"), revision{3, 0}, revision{3, 0}, int64(1)}}, {"restore", []interface{}{[]byte("foo"), revision{3, 0}, revision{3, 0}, int64(1)}},
{"tombstone", []interface{}{[]byte("foo"), revision{4, 0}}}, {"tombstone", []interface{}{[]byte("foo"), revision{4, 0}}},
} }
if g := index.Action(); !reflect.DeepEqual(g, wact) { if g := fi.Action(); !reflect.DeepEqual(g, wact) {
t.Errorf("index action = %+v, want %+v", g, wact) t.Errorf("index action = %+v, want %+v", g, wact)
} }
} }
@ -708,7 +708,7 @@ func newTestKeyBytes(rev revision, tombstone bool) []byte {
func newFakeStore() (*store, *fakeBackend, *fakeIndex) { func newFakeStore() (*store, *fakeBackend, *fakeIndex) {
b := &fakeBackend{&fakeBatchTx{rangeRespc: make(chan rangeResp, 5)}} b := &fakeBackend{&fakeBatchTx{rangeRespc: make(chan rangeResp, 5)}}
index := &fakeIndex{ fi := &fakeIndex{
indexGetRespc: make(chan indexGetResp, 1), indexGetRespc: make(chan indexGetResp, 1),
indexRangeRespc: make(chan indexRangeResp, 1), indexRangeRespc: make(chan indexRangeResp, 1),
indexRangeEventsRespc: make(chan indexRangeEventsResp, 1), indexRangeEventsRespc: make(chan indexRangeEventsResp, 1),
@ -716,10 +716,10 @@ func newFakeStore() (*store, *fakeBackend, *fakeIndex) {
} }
return &store{ return &store{
b: b, b: b,
kvindex: index, kvindex: fi,
currentRev: revision{}, currentRev: revision{},
compactMainRev: -1, compactMainRev: -1,
}, b, index }, b, fi
} }
type rangeResp struct { type rangeResp struct {

2
store/event_history.go
View File

@ -82,7 +82,7 @@ func (eh *EventHistory) scan(key string, recursive bool, index uint64) (*Event,
if recursive { if recursive {
// add tailing slash // add tailing slash
key := path.Clean(key) key = path.Clean(key)
if key[len(key)-1] != '/' { if key[len(key)-1] != '/' {
key = key + "/" key = key + "/"
} }

3
tools/functional-tester/etcd-agent/agent.go
View File

@ -106,8 +106,7 @@ func (a *Agent) restart() error {
} }
func (a *Agent) cleanup() error { func (a *Agent) cleanup() error {
err := a.stop() if err := a.stop(); err != nil {
if err != nil {
return err return err
} }
a.state = stateUninitialized a.state = stateUninitialized

2
wal/encoder.go
View File

@ -68,7 +68,7 @@ func (e *encoder) encode(rec *walpb.Record) error {
} }
data = e.buf[:n] data = e.buf[:n]
} }
if err := writeInt64(e.bw, int64(len(data)), e.uint64buf); err != nil { if err = writeInt64(e.bw, int64(len(data)), e.uint64buf); err != nil {
return err return err
} }
_, err = e.bw.Write(data) _, err = e.bw.Write(data)

23
wal/wal.go
View File

@ -102,8 +102,7 @@ func Create(dirpath string, metadata []byte) (*WAL, error) {
if err != nil { if err != nil {
return nil, err return nil, err
} }
err = l.Lock() if err = l.Lock(); err != nil {
if err != nil {
return nil, err return nil, err
} }
@ -121,7 +120,7 @@ func Create(dirpath string, metadata []byte) (*WAL, error) {
if err := w.encoder.encode(&walpb.Record{Type: metadataType, Data: metadata}); err != nil { if err := w.encoder.encode(&walpb.Record{Type: metadataType, Data: metadata}); err != nil {
return nil, err return nil, err
} }
if err = w.SaveSnapshot(walpb.Snapshot{}); err != nil { if err := w.SaveSnapshot(walpb.Snapshot{}); err != nil {
return nil, err return nil, err
} }
return w, nil return w, nil
@ -339,25 +338,25 @@ func (w *WAL) cut() error {
w.f = ft w.f = ft
prevCrc := w.encoder.crc.Sum32() prevCrc := w.encoder.crc.Sum32()
w.encoder = newEncoder(w.f, prevCrc) w.encoder = newEncoder(w.f, prevCrc)
if err := w.saveCrc(prevCrc); err != nil { if err = w.saveCrc(prevCrc); err != nil {
return err return err
} }
if err := w.encoder.encode(&walpb.Record{Type: metadataType, Data: w.metadata}); err != nil { if err = w.encoder.encode(&walpb.Record{Type: metadataType, Data: w.metadata}); err != nil {
return err return err
} }
if err := w.saveState(&w.state); err != nil { if err = w.saveState(&w.state); err != nil {
return err return err
} }
// close temp wal file // close temp wal file
if err := w.sync(); err != nil { if err = w.sync(); err != nil {
return err return err
} }
if err := w.f.Close(); err != nil { if err = w.f.Close(); err != nil {
return err return err
} }
// atomically move temp wal file to wal file // atomically move temp wal file to wal file
if err := os.Rename(ftpath, fpath); err != nil { if err = os.Rename(ftpath, fpath); err != nil {
return err return err
} }
@ -366,8 +365,7 @@ func (w *WAL) cut() error {
if err != nil { if err != nil {
return err return err
} }
err = fileutil.Preallocate(f, segmentSizeBytes) if err = fileutil.Preallocate(f, segmentSizeBytes); err != nil {
if err != nil {
plog.Errorf("failed to allocate space when creating new wal file (%v)", err) plog.Errorf("failed to allocate space when creating new wal file (%v)", err)
return err return err
} }
@ -382,8 +380,7 @@ func (w *WAL) cut() error {
return err return err
} }
err = l.Lock() if err := l.Lock(); err != nil {
if err != nil {
return err return err
} }
w.locks = append(w.locks, l) w.locks = append(w.locks, l)

16
wal/wal_test.go
View File

@ -153,10 +153,10 @@ func TestCut(t *testing.T) {
state := raftpb.HardState{Term: 1} state := raftpb.HardState{Term: 1}
// TODO(unihorn): remove this when cut can operate on an empty file // TODO(unihorn): remove this when cut can operate on an empty file
if err := w.Save(state, []raftpb.Entry{{}}); err != nil { if err = w.Save(state, []raftpb.Entry{{}}); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := w.cut(); err != nil { if err = w.cut(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
wname := walName(1, 1) wname := walName(1, 1)
@ -165,10 +165,10 @@ func TestCut(t *testing.T) {
} }
es := []raftpb.Entry{{Index: 1, Term: 1, Data: []byte{1}}} es := []raftpb.Entry{{Index: 1, Term: 1, Data: []byte{1}}}
if err := w.Save(raftpb.HardState{}, es); err != nil { if err = w.Save(raftpb.HardState{}, es); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := w.cut(); err != nil { if err = w.cut(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
snap := walpb.Snapshot{Index: 2, Term: 1} snap := walpb.Snapshot{Index: 2, Term: 1}
@ -212,7 +212,7 @@ func TestRecover(t *testing.T) {
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := w.SaveSnapshot(walpb.Snapshot{}); err != nil { if err = w.SaveSnapshot(walpb.Snapshot{}); err != nil {
t.Fatal(err) t.Fatal(err)
} }
ents := []raftpb.Entry{{Index: 1, Term: 1, Data: []byte{1}}, {Index: 2, Term: 2, Data: []byte{2}}} ents := []raftpb.Entry{{Index: 1, Term: 1, Data: []byte{1}}, {Index: 2, Term: 2, Data: []byte{2}}}
@ -385,10 +385,10 @@ func TestOpenAtUncommittedIndex(t *testing.T) {
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := w.SaveSnapshot(walpb.Snapshot{}); err != nil { if err = w.SaveSnapshot(walpb.Snapshot{}); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := w.Save(raftpb.HardState{}, []raftpb.Entry{{Index: 0}}); err != nil { if err = w.Save(raftpb.HardState{}, []raftpb.Entry{{Index: 0}}); err != nil {
t.Fatal(err) t.Fatal(err)
} }
w.Close() w.Close()
@ -398,7 +398,7 @@ func TestOpenAtUncommittedIndex(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
// commit up to index 0, try to read index 1 // commit up to index 0, try to read index 1
if _, _, _, err := w.ReadAll(); err != nil { if _, _, _, err = w.ReadAll(); err != nil {
t.Errorf("err = %v, want nil", err) t.Errorf("err = %v, want nil", err)
} }
w.Close() w.Close()