Merge pull request #9228 from mkumatag/fix_govet

Fix govet

auth/store_test.go

@@ -672,25 +672,25 @@ func TestRolesOrder(t *testing.T) {
 	}
 
 	username := "user"
-	_, err = as.UserAdd(&pb.AuthUserAddRequest{username, "pass"})
+	_, err = as.UserAdd(&pb.AuthUserAddRequest{Name: username, Password: "pass"})
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	roles := []string{"role1", "role2", "abc", "xyz", "role3"}
 	for _, role := range roles {
-		_, err = as.RoleAdd(&pb.AuthRoleAddRequest{role})
+		_, err = as.RoleAdd(&pb.AuthRoleAddRequest{Name: role})
 		if err != nil {
 			t.Fatal(err)
 		}
 
-		_, err = as.UserGrantRole(&pb.AuthUserGrantRoleRequest{username, role})
+		_, err = as.UserGrantRole(&pb.AuthUserGrantRoleRequest{User: username, Role: role})
 		if err != nil {
 			t.Fatal(err)
 		}
 	}
 
-	user, err := as.UserGet(&pb.AuthUserGetRequest{username})
+	user, err := as.UserGet(&pb.AuthUserGetRequest{Name: username})
 	if err != nil {
 		t.Fatal(err)
 	}

clientv3/leasing/cache.go

@@ -298,7 +298,7 @@ func (lc *leaseCache) evalOps(ops []v3.Op) ([]*v3pb.ResponseOp, bool) {
 		}
 		resps[i] = &v3pb.ResponseOp{
 			Response: &v3pb.ResponseOp_ResponseRange{
-				(*v3pb.RangeResponse)(resp),
+				ResponseRange: (*v3pb.RangeResponse)(resp),
 			},
 		}
 	}

clientv3/leasing/txn.go

@@ -85,7 +85,7 @@ func (txn *txnLeasing) eval() (*v3.TxnResponse, error) {
 	if !ok {
 		return nil, nil
 	}
-	return &v3.TxnResponse{copyHeader(txn.lkv.leases.header), succeeded, resps}, nil
+	return &v3.TxnResponse{Header: copyHeader(txn.lkv.leases.header), Succeeded: succeeded, Responses: resps}, nil
 }
 
 // fallback computes the ops to fetch all possible conflicting

e2e/v3_curl_test.go

@@ -156,7 +156,7 @@ func testV3CurlTxn(t *testing.T, pathPrefix string) {
 				Key:         []byte("foo"),
 				Result:      pb.Compare_EQUAL,
 				Target:      pb.Compare_CREATE,
-				TargetUnion: &pb.Compare_CreateRevision{0},
+				TargetUnion: &pb.Compare_CreateRevision{CreateRevision: 0},
 			},
 		},
 		Success: []*pb.RequestOp{

etcdctl/ctlv3/command/move_leader_command.go

@@ -53,16 +53,16 @@ func transferLeadershipCommandFunc(cmd *cobra.Command, args []string) {
 	var leaderCli *clientv3.Client
 	var leaderID uint64
 	for _, ep := range eps {
-		cli, err := clientv3.New(clientv3.Config{
+		cli, cerr := clientv3.New(clientv3.Config{
 			Endpoints:   []string{ep},
 			DialTimeout: 3 * time.Second,
 		})
-		if err != nil {
-			ExitWithError(ExitError, err)
+		if cerr != nil {
+			ExitWithError(ExitError, cerr)
 		}
-		resp, err := cli.Status(ctx, ep)
-		if err != nil {
-			ExitWithError(ExitError, err)
+		resp, serr := cli.Status(ctx, ep)
+		if serr != nil {
+			ExitWithError(ExitError, serr)
 		}
 
 		if resp.Header.GetMemberId() == resp.Leader {

integration/metrics_test.go

@@ -75,8 +75,8 @@ func TestMetricDbSizeDefrag(t *testing.T) {
 
 	// clear out historical keys
 	creq := &pb.CompactionRequest{Revision: int64(numPuts), Physical: true}
-	if _, err := kvc.Compact(context.TODO(), creq); err != nil {
-		t.Fatal(err)
+	if _, kerr := kvc.Compact(context.TODO(), creq); kerr != nil {
+		t.Fatal(kerr)
 	}
 
 	// defrag should give freed space back to fs

integration/v3_grpc_test.go

@@ -166,7 +166,7 @@ func TestV3HashKV(t *testing.T) {
 		}
 
 		rev := resp.Header.Revision
-		hresp, err := mvc.HashKV(context.Background(), &pb.HashKVRequest{0})
+		hresp, err := mvc.HashKV(context.Background(), &pb.HashKVRequest{Revision: 0})
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -177,7 +177,7 @@ func TestV3HashKV(t *testing.T) {
 		prevHash := hresp.Hash
 		prevCompactRev := hresp.CompactRevision
 		for i := 0; i < 10; i++ {
-			hresp, err := mvc.HashKV(context.Background(), &pb.HashKVRequest{0})
+			hresp, err := mvc.HashKV(context.Background(), &pb.HashKVRequest{Revision: 0})
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -519,7 +519,7 @@ func TestV3TxnRangeCompare(t *testing.T) {
 				RangeEnd:    []byte{0},
 				Target:      pb.Compare_CREATE,
 				Result:      pb.Compare_LESS,
-				TargetUnion: &pb.Compare_CreateRevision{6},
+				TargetUnion: &pb.Compare_CreateRevision{CreateRevision: 6},
 			},
 			true,
 		},
@@ -530,7 +530,7 @@ func TestV3TxnRangeCompare(t *testing.T) {
 				RangeEnd:    []byte{0},
 				Target:      pb.Compare_CREATE,
 				Result:      pb.Compare_LESS,
-				TargetUnion: &pb.Compare_CreateRevision{5},
+				TargetUnion: &pb.Compare_CreateRevision{CreateRevision: 5},
 			},
 			false,
 		},
@@ -541,7 +541,7 @@ func TestV3TxnRangeCompare(t *testing.T) {
 				RangeEnd:    []byte("/a0"),
 				Target:      pb.Compare_CREATE,
 				Result:      pb.Compare_LESS,
-				TargetUnion: &pb.Compare_CreateRevision{5},
+				TargetUnion: &pb.Compare_CreateRevision{CreateRevision: 5},
 			},
 			true,
 		},
@@ -552,7 +552,7 @@ func TestV3TxnRangeCompare(t *testing.T) {
 				RangeEnd:    []byte("/a0"),
 				Target:      pb.Compare_CREATE,
 				Result:      pb.Compare_LESS,
-				TargetUnion: &pb.Compare_CreateRevision{4},
+				TargetUnion: &pb.Compare_CreateRevision{CreateRevision: 4},
 			},
 			false,
 		},
@@ -563,7 +563,7 @@ func TestV3TxnRangeCompare(t *testing.T) {
 				RangeEnd:    []byte("/b0"),
 				Target:      pb.Compare_VALUE,
 				Result:      pb.Compare_EQUAL,
-				TargetUnion: &pb.Compare_Value{[]byte("x")},
+				TargetUnion: &pb.Compare_Value{Value: []byte("x")},
 			},
 			false,
 		},
@@ -574,7 +574,7 @@ func TestV3TxnRangeCompare(t *testing.T) {
 				RangeEnd:    []byte("/a0"),
 				Target:      pb.Compare_LEASE,
 				Result:      pb.Compare_GREATER,
-				TargetUnion: &pb.Compare_Lease{0},
+				TargetUnion: &pb.Compare_Lease{Lease: 0},
 			},
 			false,
 		},
@@ -585,7 +585,7 @@ func TestV3TxnRangeCompare(t *testing.T) {
 				RangeEnd:    []byte("/a0"),
 				Target:      pb.Compare_LEASE,
 				Result:      pb.Compare_EQUAL,
-				TargetUnion: &pb.Compare_Lease{0},
+				TargetUnion: &pb.Compare_Lease{Lease: 0},
 			},
 			true,
 		},

lease/leasehttp/http.go

@@ -62,7 +62,7 @@ func (h *leaseHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	switch r.URL.Path {
 	case LeasePrefix:
 		lreq := pb.LeaseKeepAliveRequest{}
-		if err := lreq.Unmarshal(b); err != nil {
+		if uerr := lreq.Unmarshal(b); uerr != nil {
 			http.Error(w, "error unmarshalling request", http.StatusBadRequest)
 			return
 		}
@@ -72,14 +72,14 @@ func (h *leaseHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 			http.Error(w, ErrLeaseHTTPTimeout.Error(), http.StatusRequestTimeout)
 			return
 		}
-		ttl, err := h.l.Renew(lease.LeaseID(lreq.ID))
-		if err != nil {
-			if err == lease.ErrLeaseNotFound {
-				http.Error(w, err.Error(), http.StatusNotFound)
+		ttl, rerr := h.l.Renew(lease.LeaseID(lreq.ID))
+		if rerr != nil {
+			if rerr == lease.ErrLeaseNotFound {
+				http.Error(w, rerr.Error(), http.StatusNotFound)
 				return
 			}
 
-			http.Error(w, err.Error(), http.StatusBadRequest)
+			http.Error(w, rerr.Error(), http.StatusBadRequest)
 			return
 		}
 		// TODO: fill out ResponseHeader
@@ -92,7 +92,7 @@ func (h *leaseHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 	case LeaseInternalPrefix:
 		lreq := leasepb.LeaseInternalRequest{}
-		if err := lreq.Unmarshal(b); err != nil {
+		if lerr := lreq.Unmarshal(b); lerr != nil {
 			http.Error(w, "error unmarshalling request", http.StatusBadRequest)
 			return
 		}

mvcc/kvstore_test.go

@@ -141,12 +141,12 @@ func TestStorePut(t *testing.T) {
 		}
 
 		wact := []testutil.Action{
-			{"seqput", []interface{}{keyBucketName, tt.wkey, data}},
+			{Name: "seqput", Params: []interface{}{keyBucketName, tt.wkey, data}},
 		}
 
 		if tt.rr != nil {
 			wact = []testutil.Action{
-				{"seqput", []interface{}{keyBucketName, tt.wkey, data}},
+				{Name: "seqput", Params: []interface{}{keyBucketName, tt.wkey, data}},
 			}
 		}
 
@@ -154,8 +154,8 @@ func TestStorePut(t *testing.T) {
 			t.Errorf("#%d: tx action = %+v, want %+v", i, g, wact)
 		}
 		wact = []testutil.Action{
-			{"get", []interface{}{[]byte("foo"), tt.wputrev.main}},
-			{"put", []interface{}{[]byte("foo"), tt.wputrev}},
+			{Name: "get", Params: []interface{}{[]byte("foo"), tt.wputrev.main}},
+			{Name: "put", Params: []interface{}{[]byte("foo"), tt.wputrev}},
 		}
 		if g := fi.Action(); !reflect.DeepEqual(g, wact) {
 			t.Errorf("#%d: index action = %+v, want %+v", i, g, wact)
@@ -221,13 +221,13 @@ func TestStoreRange(t *testing.T) {
 		wstart := newRevBytes()
 		revToBytes(tt.idxr.revs[0], wstart)
 		wact := []testutil.Action{
-			{"range", []interface{}{keyBucketName, wstart, []byte(nil), int64(0)}},
+			{Name: "range", Params: []interface{}{keyBucketName, wstart, []byte(nil), int64(0)}},
 		}
 		if g := b.tx.Action(); !reflect.DeepEqual(g, wact) {
 			t.Errorf("#%d: tx action = %+v, want %+v", i, g, wact)
 		}
 		wact = []testutil.Action{
-			{"range", []interface{}{[]byte("foo"), []byte("goo"), wrev}},
+			{Name: "range", Params: []interface{}{[]byte("foo"), []byte("goo"), wrev}},
 		}
 		if g := fi.Action(); !reflect.DeepEqual(g, wact) {
 			t.Errorf("#%d: index action = %+v, want %+v", i, g, wact)
@@ -296,14 +296,14 @@ func TestStoreDeleteRange(t *testing.T) {
 			t.Errorf("#%d: marshal err = %v, want nil", i, err)
 		}
 		wact := []testutil.Action{
-			{"seqput", []interface{}{keyBucketName, tt.wkey, data}},
+			{Name: "seqput", Params: []interface{}{keyBucketName, tt.wkey, data}},
 		}
 		if g := b.tx.Action(); !reflect.DeepEqual(g, wact) {
 			t.Errorf("#%d: tx action = %+v, want %+v", i, g, wact)
 		}
 		wact = []testutil.Action{
-			{"range", []interface{}{[]byte("foo"), []byte("goo"), tt.wrrev}},
-			{"tombstone", []interface{}{[]byte("foo"), tt.wdelrev}},
+			{Name: "range", Params: []interface{}{[]byte("foo"), []byte("goo"), tt.wrrev}},
+			{Name: "tombstone", Params: []interface{}{[]byte("foo"), tt.wdelrev}},
 		}
 		if g := fi.Action(); !reflect.DeepEqual(g, wact) {
 			t.Errorf("#%d: index action = %+v, want %+v", i, g, wact)
@@ -335,16 +335,16 @@ func TestStoreCompact(t *testing.T) {
 	end := make([]byte, 8)
 	binary.BigEndian.PutUint64(end, uint64(4))
 	wact := []testutil.Action{
-		{"put", []interface{}{metaBucketName, scheduledCompactKeyName, newTestRevBytes(revision{3, 0})}},
-		{"range", []interface{}{keyBucketName, make([]byte, 17), end, int64(10000)}},
-		{"delete", []interface{}{keyBucketName, key2}},
-		{"put", []interface{}{metaBucketName, finishedCompactKeyName, newTestRevBytes(revision{3, 0})}},
+		{Name: "put", Params: []interface{}{metaBucketName, scheduledCompactKeyName, newTestRevBytes(revision{3, 0})}},
+		{Name: "range", Params: []interface{}{keyBucketName, make([]byte, 17), end, int64(10000)}},
+		{Name: "delete", Params: []interface{}{keyBucketName, key2}},
+		{Name: "put", Params: []interface{}{metaBucketName, finishedCompactKeyName, newTestRevBytes(revision{3, 0})}},
 	}
 	if g := b.tx.Action(); !reflect.DeepEqual(g, wact) {
 		t.Errorf("tx actions = %+v, want %+v", g, wact)
 	}
 	wact = []testutil.Action{
-		{"compact", []interface{}{int64(3)}},
+		{Name: "compact", Params: []interface{}{int64(3)}},
 	}
 	if g := fi.Action(); !reflect.DeepEqual(g, wact) {
 		t.Errorf("index action = %+v, want %+v", g, wact)
@@ -391,9 +391,9 @@ func TestStoreRestore(t *testing.T) {
 		t.Errorf("current rev = %v, want 5", s.currentRev)
 	}
 	wact := []testutil.Action{
-		{"range", []interface{}{metaBucketName, finishedCompactKeyName, []byte(nil), int64(0)}},
-		{"range", []interface{}{metaBucketName, scheduledCompactKeyName, []byte(nil), int64(0)}},
-		{"range", []interface{}{keyBucketName, newTestRevBytes(revision{1, 0}), newTestRevBytes(revision{math.MaxInt64, math.MaxInt64}), int64(restoreChunkKeys)}},
+		{Name: "range", Params: []interface{}{metaBucketName, finishedCompactKeyName, []byte(nil), int64(0)}},
+		{Name: "range", Params: []interface{}{metaBucketName, scheduledCompactKeyName, []byte(nil), int64(0)}},
+		{Name: "range", Params: []interface{}{keyBucketName, newTestRevBytes(revision{1, 0}), newTestRevBytes(revision{math.MaxInt64, math.MaxInt64}), int64(restoreChunkKeys)}},
 	}
 	if g := b.tx.Action(); !reflect.DeepEqual(g, wact) {
 		t.Errorf("tx actions = %+v, want %+v", g, wact)
@@ -405,8 +405,8 @@ func TestStoreRestore(t *testing.T) {
 	}
 	ki := &keyIndex{key: []byte("foo"), modified: revision{5, 0}, generations: gens}
 	wact = []testutil.Action{
-		{"keyIndex", []interface{}{ki}},
-		{"insert", []interface{}{ki}},
+		{Name: "keyIndex", Params: []interface{}{ki}},
+		{Name: "insert", Params: []interface{}{ki}},
 	}
 	if g := fi.Action(); !reflect.DeepEqual(g, wact) {
 		t.Errorf("index action = %+v, want %+v", g, wact)

raft/rafttest/node_bench_test.go

@@ -23,7 +23,7 @@ import (
 )
 
 func BenchmarkProposal3Nodes(b *testing.B) {
-	peers := []raft.Peer{{1, nil}, {2, nil}, {3, nil}}
+	peers := []raft.Peer{{Id: 1, Context: nil}, {Id: 2, Context: nil}, {Id: 3, Context: nil}}
 	nt := newRaftNetwork(1, 2, 3)
 
 	nodes := make([]*node, 0)

raft/rafttest/node_test.go

@@ -23,7 +23,7 @@ import (
 )
 
 func TestBasicProgress(t *testing.T) {
-	peers := []raft.Peer{{1, nil}, {2, nil}, {3, nil}, {4, nil}, {5, nil}}
+	peers := []raft.Peer{{Id: 1, Context: nil}, {Id: 2, Context: nil}, {Id: 3, Context: nil}, {Id: 4, Context: nil}, {Id: 5, Context: nil}}
 	nt := newRaftNetwork(1, 2, 3, 4, 5)
 
 	nodes := make([]*node, 0)
@@ -49,7 +49,7 @@ func TestBasicProgress(t *testing.T) {
 }
 
 func TestRestart(t *testing.T) {
-	peers := []raft.Peer{{1, nil}, {2, nil}, {3, nil}, {4, nil}, {5, nil}}
+	peers := []raft.Peer{{Id: 1, Context: nil}, {Id: 2, Context: nil}, {Id: 3, Context: nil}, {Id: 4, Context: nil}, {Id: 5, Context: nil}}
 	nt := newRaftNetwork(1, 2, 3, 4, 5)
 
 	nodes := make([]*node, 0)
@@ -89,7 +89,7 @@ func TestRestart(t *testing.T) {
 }
 
 func TestPause(t *testing.T) {
-	peers := []raft.Peer{{1, nil}, {2, nil}, {3, nil}, {4, nil}, {5, nil}}
+	peers := []raft.Peer{{Id: 1, Context: nil}, {Id: 2, Context: nil}, {Id: 3, Context: nil}, {Id: 4, Context: nil}, {Id: 5, Context: nil}}
 	nt := newRaftNetwork(1, 2, 3, 4, 5)
 
 	nodes := make([]*node, 0)