stateloader: simplify SynthesizeHardState

Epic: none
Release note: none

Author: pav-kv

pkg/kv/kvserver/logstore/stateloader.go

@@ -167,17 +167,13 @@ func (sl StateLoader) SetHardState(
 // SynthesizeHardState synthesizes an on-disk HardState from the given input,
 // taking care that a HardState compatible with the existing data is written.
 func (sl StateLoader) SynthesizeHardState(
-	ctx context.Context,
-	writer storage.Writer,
-	oldHS raftpb.HardState,
-	truncState kvserverpb.RaftTruncatedState,
-	raftAppliedIndex kvpb.RaftIndex,
+	ctx context.Context, writer storage.Writer, oldHS raftpb.HardState, applied EntryID,
 ) error {
 	newHS := raftpb.HardState{
-		Term: uint64(truncState.Term),
-		// Note that when applying a Raft snapshot, the applied index is
-		// equal to the Commit index represented by the snapshot.
-		Commit: uint64(raftAppliedIndex),
+		Term: uint64(applied.Term),
+		// NB: when applying a Raft snapshot, the applied index is equal to the
+		// Commit index represented by the snapshot.
+		Commit: uint64(applied.Index),
 	}
 
 	if oldHS.Commit > newHS.Commit {

pkg/kv/kvserver/stateloader/initial_test.go

@@ -12,7 +12,7 @@ import (
 	"testing"
 
 	"github.com/cockroachdb/cockroach/pkg/kv/kvpb"
-	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/kvserverpb"
+	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/logstore"
 	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/print"
 	"github.com/cockroachdb/cockroach/pkg/raft/raftpb"
 	"github.com/cockroachdb/cockroach/pkg/roachpb"
@@ -64,20 +64,20 @@ func TestSynthesizeHardState(t *testing.T) {
 	tHS := raftpb.HardState{Term: 2, Vote: 3, Commit: 4, Lead: 5, LeadEpoch: 6}
 
 	testCases := []struct {
-		TruncTerm        kvpb.RaftTerm
-		RaftAppliedIndex kvpb.RaftIndex
-		OldHS            *raftpb.HardState
-		NewHS            raftpb.HardState
-		Err              string
+		AppliedTerm  kvpb.RaftTerm
+		AppliedIndex kvpb.RaftIndex
+		OldHS        *raftpb.HardState
+		NewHS        raftpb.HardState
+		Err          string
 	}{
-		{OldHS: nil, TruncTerm: 42, RaftAppliedIndex: 24, NewHS: raftpb.HardState{Term: 42, Vote: 0, Commit: 24}},
+		{OldHS: nil, AppliedTerm: 42, AppliedIndex: 24, NewHS: raftpb.HardState{Term: 42, Vote: 0, Commit: 24}},
 		// Can't wind back the committed index of the new HardState.
-		{OldHS: &tHS, RaftAppliedIndex: kvpb.RaftIndex(tHS.Commit - 1), Err: "can't decrease HardState.Commit"},
-		{OldHS: &tHS, RaftAppliedIndex: kvpb.RaftIndex(tHS.Commit), NewHS: tHS},
-		{OldHS: &tHS, RaftAppliedIndex: kvpb.RaftIndex(tHS.Commit + 1), NewHS: raftpb.HardState{Term: tHS.Term, Vote: 3, Commit: tHS.Commit + 1, Lead: 5, LeadEpoch: 6}},
+		{OldHS: &tHS, AppliedIndex: kvpb.RaftIndex(tHS.Commit - 1), Err: "can't decrease HardState.Commit"},
+		{OldHS: &tHS, AppliedIndex: kvpb.RaftIndex(tHS.Commit), NewHS: tHS},
+		{OldHS: &tHS, AppliedIndex: kvpb.RaftIndex(tHS.Commit + 1), NewHS: raftpb.HardState{Term: tHS.Term, Vote: 3, Commit: tHS.Commit + 1, Lead: 5, LeadEpoch: 6}},
 		// Higher Term is picked up, but Vote, Lead, and LeadEpoch aren't carried
 		// over when the term changes.
-		{OldHS: &tHS, RaftAppliedIndex: kvpb.RaftIndex(tHS.Commit), TruncTerm: 11, NewHS: raftpb.HardState{Term: 11, Vote: 0, Commit: tHS.Commit, Lead: 0}},
+		{OldHS: &tHS, AppliedIndex: kvpb.RaftIndex(tHS.Commit), AppliedTerm: 11, NewHS: raftpb.HardState{Term: 11, Vote: 0, Commit: tHS.Commit, Lead: 0}},
 	}
 
 	for i, test := range testCases {
@@ -97,9 +97,8 @@ func TestSynthesizeHardState(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			err = rsl.SynthesizeHardState(
-				context.Background(), batch, oldHS, kvserverpb.RaftTruncatedState{Term: test.TruncTerm}, test.RaftAppliedIndex,
-			)
+			err = rsl.SynthesizeHardState(context.Background(), batch, oldHS,
+				logstore.EntryID{Index: test.AppliedIndex, Term: test.AppliedTerm})
 			if !testutils.IsError(err, test.Err) {
 				t.Fatalf("%d: expected %q got %v", i, test.Err, err)
 			} else if err != nil {

pkg/kv/kvserver/stateloader/stateloader.go

@@ -453,13 +453,13 @@ func (rsl StateLoader) SynthesizeRaftState(
 	if err != nil {
 		return err
 	}
-	truncState, err := rsl.LoadRaftTruncatedState(ctx, readWriter)
-	if err != nil {
-		return err
-	}
 	as, err := rsl.LoadRangeAppliedState(ctx, readWriter)
 	if err != nil {
 		return err
 	}
-	return rsl.SynthesizeHardState(ctx, readWriter, hs, truncState, as.RaftAppliedIndex)
+	applied := logstore.EntryID{
+		Index: as.RaftAppliedIndex,
+		Term:  as.RaftAppliedIndexTerm,
+	}
+	return rsl.SynthesizeHardState(ctx, readWriter, hs, applied)
 }