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 {
return nil, err
}
if err := assertStatusCode(resp.StatusCode, http.StatusOK); err != nil {
if err = assertStatusCode(resp.StatusCode, http.StatusOK); err != nil {
return nil, err
}
var userList struct {
Roles []string `json:"roles"`
}
err = json.Unmarshal(body, &userList)
if err != nil {
if err = json.Unmarshal(body, &userList); err != nil {
return nil, err
}
return userList.Roles, nil
@ -218,17 +217,16 @@ func (r *httpAuthRoleAPI) modRole(ctx context.Context, req *authRoleAPIAction) (
if err != nil {
return nil, err
}
if err := assertStatusCode(resp.StatusCode, http.StatusOK); err != nil {
if err = assertStatusCode(resp.StatusCode, http.StatusOK); err != nil {
var sec authError
err := json.Unmarshal(body, &sec)
err = json.Unmarshal(body, &sec)
if err != nil {
return nil, err
}
return nil, sec
}
var role Role
err = json.Unmarshal(body, &role)
if err != nil {
if err = json.Unmarshal(body, &role); err != nil {
return nil, err
}
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 {
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
err := json.Unmarshal(body, &sec)
err = json.Unmarshal(body, &sec)
if err != nil {
return err
}
@ -179,9 +179,9 @@ func (u *httpAuthUserAPI) ListUsers(ctx context.Context) ([]string, error) {
if err != nil {
return nil, err
}
if err := assertStatusCode(resp.StatusCode, http.StatusOK); err != nil {
if err = assertStatusCode(resp.StatusCode, http.StatusOK); err != nil {
var sec authError
err := json.Unmarshal(body, &sec)
err = json.Unmarshal(body, &sec)
if err != nil {
return nil, err
}
@ -190,8 +190,7 @@ func (u *httpAuthUserAPI) ListUsers(ctx context.Context) ([]string, error) {
var userList struct {
Users []string `json:"users"`
}
err = json.Unmarshal(body, &userList)
if err != nil {
if err = json.Unmarshal(body, &userList); err != nil {
return nil, err
}
return userList.Users, nil
@ -221,9 +220,9 @@ func (u *httpAuthUserAPI) addRemoveUser(ctx context.Context, req *authUserAPIAct
if err != nil {
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
err := json.Unmarshal(body, &sec)
err = json.Unmarshal(body, &sec)
if err != nil {
return err
}
@ -280,17 +279,16 @@ func (u *httpAuthUserAPI) modUser(ctx context.Context, req *authUserAPIAction) (
if err != nil {
return nil, err
}
if err := assertStatusCode(resp.StatusCode, http.StatusOK); err != nil {
if err = assertStatusCode(resp.StatusCode, http.StatusOK); err != nil {
var sec authError
err := json.Unmarshal(body, &sec)
err = json.Unmarshal(body, &sec)
if err != nil {
return nil, err
}
return nil, sec
}
var user User
err = json.Unmarshal(body, &user)
if err != nil {
if err = json.Unmarshal(body, &user); err != nil {
return nil, err
}
return &user, nil

2
etcdctl/command/backup_command.go
View File

@ -61,7 +61,7 @@ func handleBackup(c *cli.Context) {
if snapshot != nil {
walsnap.Index, walsnap.Term = snapshot.Metadata.Index, snapshot.Metadata.Term
newss := snap.New(destSnap)
if err := newss.SaveSnap(*snapshot); err != nil {
if err = newss.SaveSnap(*snapshot); err != nil {
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)
}
urls := struct{ PeerURLs []string }{}
err := json.Unmarshal(b, &urls)
err = json.Unmarshal(b, &urls)
if err != nil {
return err
}

24
etcdserver/auth/auth.go
View File

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

4
etcdserver/cluster_util.go
View File

@ -78,7 +78,7 @@ func getClusterFromRemotePeers(urls []string, timeout time.Duration, logerr bool
continue
}
var membs []*Member
if err := json.Unmarshal(b, &membs); err != nil {
if err = json.Unmarshal(b, &membs); err != nil {
if logerr {
plog.Warningf("could not unmarshal cluster response: %v", err)
}
@ -246,7 +246,7 @@ func getVersion(m *Member, rt http.RoundTripper) (*version.Versions, error) {
continue
}
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)
continue
}

8
etcdserver/raft.go
View File

@ -158,14 +158,14 @@ func (r *raftNode) start(s *EtcdServer) {
}
}
apply := apply{
ap := apply{
entries: rd.CommittedEntries,
snapshot: rd.Snapshot,
done: make(chan struct{}),
}
select {
case r.applyc <- apply:
case r.applyc <- ap:
case <-r.stopped:
return
}
@ -185,7 +185,7 @@ func (r *raftNode) start(s *EtcdServer) {
r.s.send(rd.Messages)
select {
case <-apply.done:
case <-ap.done:
case <-r.stopped:
return
}
@ -253,7 +253,7 @@ func startNode(cfg *ServerConfig, cl *cluster, ids []types.ID) (id types.ID, n r
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)
}
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
// 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.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 {
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)
}
}

2
pkg/fileutil/lock_test.go
View File

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

2
pkg/fileutil/purge_test.go
View File

@ -121,7 +121,7 @@ func TestPurgeFileHoldingLock(t *testing.T) {
}
select {
case err := <-errch:
case err = <-errch:
t.Errorf("unexpected purge error %v", err)
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
}
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()
if to == nil {
@ -94,9 +94,9 @@ func (rn *raftNetwork) send(m raftpb.Message) {
if drop != 0 && rand.Float64() < drop {
return
}
// TODO: shall we delay without blocking the send call?
if delay.d != 0 && rand.Float64() < delay.rate {
rd := rand.Int63n(int64(delay.d))
// TODO: shall we dl without blocking the send call?
if dl.d != 0 && rand.Float64() < dl.rate {
rd := rand.Int63n(int64(dl.d))
time.Sleep(time.Duration(rd))
}

80
storage/index_test.go
View File

@ -20,10 +20,10 @@ import (
)
func TestIndexGet(t *testing.T) {
index := newTreeIndex()
index.Put([]byte("foo"), revision{main: 2})
index.Put([]byte("foo"), revision{main: 4})
index.Tombstone([]byte("foo"), revision{main: 6})
ti := newTreeIndex()
ti.Put([]byte("foo"), revision{main: 2})
ti.Put([]byte("foo"), revision{main: 4})
ti.Tombstone([]byte("foo"), revision{main: 6})
tests := []struct {
rev int64
@ -42,7 +42,7 @@ func TestIndexGet(t *testing.T) {
{6, revision{}, revision{}, 0, ErrRevisionNotFound},
}
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 {
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")}
allRevs := []revision{{main: 1}, {main: 2}, {main: 3}}
index := newTreeIndex()
ti := newTreeIndex()
for i := range allKeys {
index.Put(allKeys[i], allRevs[i])
ti.Put(allKeys[i], allRevs[i])
}
atRev := int64(3)
@ -107,7 +107,7 @@ func TestIndexRange(t *testing.T) {
},
}
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) {
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) {
index := newTreeIndex()
index.Put([]byte("foo"), revision{main: 1})
ti := newTreeIndex()
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 {
t.Errorf("tombstone error = %v, want nil", err)
}
_, _, _, err = index.Get([]byte("foo"), 2)
_, _, _, err = ti.Get([]byte("foo"), 2)
if err != ErrRevisionNotFound {
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 {
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")}
allRevs := []revision{{main: 1}, {main: 2}, {main: 3}, {main: 4}, {main: 5}, {main: 6}}
index := newTreeIndex()
ti := newTreeIndex()
for i := range allKeys {
index.Put(allKeys[i], allRevs[i])
ti.Put(allKeys[i], allRevs[i])
}
atRev := int64(1)
@ -184,7 +184,7 @@ func TestIndexRangeSince(t *testing.T) {
},
}
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) {
t.Errorf("#%d: revs = %+v, want %+v", i, revs, tt.wrevs)
}
@ -214,56 +214,56 @@ func TestIndexCompact(t *testing.T) {
}
// Continuous Compact
index := newTreeIndex()
ti := newTreeIndex()
for _, tt := range tests {
if tt.remove {
index.Tombstone(tt.key, tt.rev)
ti.Tombstone(tt.key, tt.rev)
} else {
index.Put(tt.key, tt.rev)
ti.Put(tt.key, tt.rev)
}
}
for i := int64(1); i < maxRev; i++ {
am := index.Compact(i)
am := ti.Compact(i)
windex := newTreeIndex()
wti := newTreeIndex()
for _, tt := range tests {
if _, ok := am[tt.rev]; ok || tt.rev.GreaterThan(revision{main: i}) {
if tt.remove {
windex.Tombstone(tt.key, tt.rev)
wti.Tombstone(tt.key, tt.rev)
} 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) {
t.Errorf("#%d: not equal index", i)
if !ti.Equal(wti) {
t.Errorf("#%d: not equal ti", i)
}
}
// Once Compact
for i := int64(1); i < maxRev; i++ {
index := newTreeIndex()
ti := newTreeIndex()
for _, tt := range tests {
if tt.remove {
index.Tombstone(tt.key, tt.rev)
ti.Tombstone(tt.key, tt.rev)
} 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 {
if _, ok := am[tt.rev]; ok || tt.rev.GreaterThan(revision{main: i}) {
if tt.remove {
windex.Tombstone(tt.key, tt.rev)
wti.Tombstone(tt.key, tt.rev)
} 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) {
t.Errorf("#%d: not equal index", i)
if !ti.Equal(wti) {
t.Errorf("#%d: not equal ti", i)
}
}
}
@ -282,11 +282,11 @@ func TestIndexRestore(t *testing.T) {
}
// Continuous Restore
index := newTreeIndex()
ti := newTreeIndex()
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 {
t.Errorf("#%d: modified = %v, want %v", i, modified, tt.modified)
}
@ -303,10 +303,10 @@ func TestIndexRestore(t *testing.T) {
// Once Restore
for i, tt := range tests {
index := newTreeIndex()
index.Restore(key, tt.created, tt.modified, tt.ver)
ti := newTreeIndex()
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 {
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 {
s, b, index := newFakeStore()
s, b, fi := newFakeStore()
s.currentRev = tt.rev
s.tx = b.BatchTx()
index.indexGetRespc <- tt.r
fi.indexGetRespc <- tt.r
s.put([]byte("foo"), []byte("bar"))
@ -115,7 +115,7 @@ func TestStorePut(t *testing.T) {
{"get", []interface{}{[]byte("foo"), tt.wputrev.main}},
{"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)
}
if s.currentRev != tt.wrev {
@ -154,11 +154,11 @@ func TestStoreRange(t *testing.T) {
},
}
for i, tt := range tests {
s, b, index := newFakeStore()
s, b, fi := newFakeStore()
s.currentRev = currev
s.tx = b.BatchTx()
b.tx.rangeRespc <- tt.r
index.indexRangeRespc <- tt.idxr
fi.indexRangeRespc <- tt.idxr
kvs, rev, err := s.rangeKeys([]byte("foo"), []byte("goo"), 1, 0)
if err != nil {
@ -181,7 +181,7 @@ func TestStoreRange(t *testing.T) {
wact = []testutil.Action{
{"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)
}
if s.currentRev != currev {
@ -218,10 +218,10 @@ func TestStoreDeleteRange(t *testing.T) {
},
}
for i, tt := range tests {
s, b, index := newFakeStore()
s, b, fi := newFakeStore()
s.currentRev = tt.rev
s.tx = b.BatchTx()
index.indexRangeRespc <- tt.r
fi.indexRangeRespc <- tt.r
n := s.deleteRange([]byte("foo"), []byte("goo"))
if n != 1 {
@ -244,7 +244,7 @@ func TestStoreDeleteRange(t *testing.T) {
{"range", []interface{}{[]byte("foo"), []byte("goo"), tt.wrrev}},
{"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)
}
if s.currentRev != tt.wrev {
@ -282,9 +282,9 @@ func TestStoreRangeHistory(t *testing.T) {
},
}
for i, tt := range tests {
s, b, index := newFakeStore()
s, b, fi := newFakeStore()
s.currentRev = currev
index.indexRangeEventsRespc <- tt.idxr
fi.indexRangeEventsRespc <- tt.idxr
b.tx.rangeRespc <- tt.r
keys, kvs, _, err := s.RangeHistory([]byte("foo"), []byte("goo"), 1, 1)
@ -301,7 +301,7 @@ func TestStoreRangeHistory(t *testing.T) {
wact := []testutil.Action{
{"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)
}
wstart, wend := revBytesRange(tt.idxr.revs[0])
@ -318,9 +318,9 @@ func TestStoreRangeHistory(t *testing.T) {
}
func TestStoreCompact(t *testing.T) {
s, b, index := newFakeStore()
s, b, fi := newFakeStore()
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)
key2 := newTestKeyBytes(revision{2, 0}, false)
b.tx.rangeRespc <- rangeResp{[][]byte{key1, key2}, nil}
@ -345,13 +345,13 @@ func TestStoreCompact(t *testing.T) {
wact = []testutil.Action{
{"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)
}
}
func TestStoreRestore(t *testing.T) {
s, b, index := newFakeStore()
s, b, fi := newFakeStore()
putkey := newTestKeyBytes(revision{3, 0}, false)
putkv := storagepb.KeyValue{
@ -398,7 +398,7 @@ func TestStoreRestore(t *testing.T) {
{"restore", []interface{}{[]byte("foo"), revision{3, 0}, revision{3, 0}, int64(1)}},
{"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)
}
}
@ -708,7 +708,7 @@ func newTestKeyBytes(rev revision, tombstone bool) []byte {
func newFakeStore() (*store, *fakeBackend, *fakeIndex) {
b := &fakeBackend{&fakeBatchTx{rangeRespc: make(chan rangeResp, 5)}}
index := &fakeIndex{
fi := &fakeIndex{
indexGetRespc: make(chan indexGetResp, 1),
indexRangeRespc: make(chan indexRangeResp, 1),
indexRangeEventsRespc: make(chan indexRangeEventsResp, 1),
@ -716,10 +716,10 @@ func newFakeStore() (*store, *fakeBackend, *fakeIndex) {
}
return &store{
b: b,
kvindex: index,
kvindex: fi,
currentRev: revision{},
compactMainRev: -1,
}, b, index
}, b, fi
}
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 {
// add tailing slash
key := path.Clean(key)
key = path.Clean(key)
if key[len(key)-1] != '/' {
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 {
err := a.stop()
if err != nil {
if err := a.stop(); err != nil {
return err
}
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]
}
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
}
_, 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 {
return nil, err
}
err = l.Lock()
if err != nil {
if err = l.Lock(); err != nil {
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 {
return nil, err
}
if err = w.SaveSnapshot(walpb.Snapshot{}); err != nil {
if err := w.SaveSnapshot(walpb.Snapshot{}); err != nil {
return nil, err
}
return w, nil
@ -339,25 +338,25 @@ func (w *WAL) cut() error {
w.f = ft
prevCrc := w.encoder.crc.Sum32()
w.encoder = newEncoder(w.f, prevCrc)
if err := w.saveCrc(prevCrc); err != nil {
if err = w.saveCrc(prevCrc); err != nil {
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
}
if err := w.saveState(&w.state); err != nil {
if err = w.saveState(&w.state); err != nil {
return err
}
// close temp wal file
if err := w.sync(); err != nil {
if err = w.sync(); err != nil {
return err
}
if err := w.f.Close(); err != nil {
if err = w.f.Close(); err != nil {
return err
}
// 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
}
@ -366,8 +365,7 @@ func (w *WAL) cut() error {
if err != nil {
return err
}
err = fileutil.Preallocate(f, segmentSizeBytes)
if err != nil {
if err = fileutil.Preallocate(f, segmentSizeBytes); err != nil {
plog.Errorf("failed to allocate space when creating new wal file (%v)", err)
return err
}
@ -382,8 +380,7 @@ func (w *WAL) cut() error {
return err
}
err = l.Lock()
if err != nil {
if err := l.Lock(); err != nil {
return err
}
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}
// 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)
}
if err := w.cut(); err != nil {
if err = w.cut(); err != nil {
t.Fatal(err)
}
wname := walName(1, 1)
@ -165,10 +165,10 @@ func TestCut(t *testing.T) {
}
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)
}
if err := w.cut(); err != nil {
if err = w.cut(); err != nil {
t.Fatal(err)
}
snap := walpb.Snapshot{Index: 2, Term: 1}
@ -212,7 +212,7 @@ func TestRecover(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if err := w.SaveSnapshot(walpb.Snapshot{}); err != nil {
if err = w.SaveSnapshot(walpb.Snapshot{}); err != nil {
t.Fatal(err)
}
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 {
t.Fatal(err)
}
if err := w.SaveSnapshot(walpb.Snapshot{}); err != nil {
if err = w.SaveSnapshot(walpb.Snapshot{}); err != nil {
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)
}
w.Close()
@ -398,7 +398,7 @@ func TestOpenAtUncommittedIndex(t *testing.T) {
t.Fatal(err)
}
// 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)
}
w.Close()