stateloader: rm trunc state from WriteInitialReplicaState

Epic: none
Release note: none

Author: pav-kv

pkg/kv/kvserver/batcheval/cmd_end_transaction.go

@@ -1460,11 +1460,14 @@ func splitTriggerHelper(
 		if err != nil {
 			return enginepb.MVCCStats{}, result.Result{}, errors.Wrap(err, "unable to load replica version")
 		}
-		*h.AbsPostSplitRight(), err = stateloader.WriteInitialReplicaState(
+		if *h.AbsPostSplitRight(), err = stateloader.WriteInitialReplicaState(
 			ctx, batch, *h.AbsPostSplitRight(), split.RightDesc, rightLease,
 			*gcThreshold, *gcHint, replicaVersion,
-		)
-		if err != nil {
+		); err != nil {
+			return enginepb.MVCCStats{}, result.Result{}, errors.Wrap(err, "unable to write initial Replica state")
+		}
+		// TODO(arulajmani): remove WriteInitialTruncState.
+		if err := stateloader.WriteInitialTruncState(ctx, batch, split.RightDesc.RangeID); err != nil {
 			return enginepb.MVCCStats{}, result.Result{}, errors.Wrap(err, "unable to write initial Replica state")
 		}
 	}

pkg/kv/kvserver/stateloader/BUILD.bazel

@@ -12,6 +12,7 @@ go_library(
         "//pkg/kv/kvpb",
         "//pkg/kv/kvserver/kvserverpb",
         "//pkg/kv/kvserver/logstore",
+        "//pkg/raft/raftpb",
         "//pkg/roachpb",
         "//pkg/storage",
         "//pkg/storage/enginepb",
@@ -34,7 +35,7 @@ go_test(
     embed = [":stateloader"],
     deps = [
         "//pkg/kv/kvpb",
-        "//pkg/kv/kvserver/kvserverpb",
+        "//pkg/kv/kvserver/logstore",
         "//pkg/kv/kvserver/print",
         "//pkg/raft/raftpb",
         "//pkg/roachpb",

pkg/kv/kvserver/stateloader/initial.go

@@ -9,6 +9,8 @@ import (
 	"context"
 
 	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/kvserverpb"
+	"github.com/cockroachdb/cockroach/pkg/kv/kvserver/logstore"
+	"github.com/cockroachdb/cockroach/pkg/raft/raftpb"
 	"github.com/cockroachdb/cockroach/pkg/roachpb"
 	"github.com/cockroachdb/cockroach/pkg/storage"
 	"github.com/cockroachdb/cockroach/pkg/storage/enginepb"
@@ -56,13 +58,9 @@ func WriteInitialReplicaState(
 	gcHint roachpb.GCHint,
 	replicaVersion roachpb.Version,
 ) (enginepb.MVCCStats, error) {
-	truncState := &kvserverpb.RaftTruncatedState{
-		Term:  RaftInitialLogTerm,
-		Index: RaftInitialLogIndex,
-	}
 	s := kvserverpb.ReplicaState{
-		RaftAppliedIndex:     truncState.Index,
-		RaftAppliedIndexTerm: truncState.Term,
+		RaftAppliedIndex:     RaftInitialLogIndex,
+		RaftAppliedIndexTerm: RaftInitialLogTerm,
 		LeaseAppliedIndex:    InitialLeaseAppliedIndex,
 		Desc: &roachpb.RangeDescriptor{
 			RangeID: desc.RangeID,
@@ -101,11 +99,6 @@ func WriteInitialReplicaState(
 		log.Fatalf(ctx, "expected trivial version, but found %+v", existingVersion)
 	}
 
-	// TODO(sep-raft-log): SetRaftTruncatedState will be in a separate batch when
-	// the Raft log engine is separated. Figure out the ordering required here.
-	if err := rsl.SetRaftTruncatedState(ctx, readWriter, truncState); err != nil {
-		return enginepb.MVCCStats{}, err
-	}
 	newMS, err := rsl.Save(ctx, readWriter, s)
 	if err != nil {
 		return enginepb.MVCCStats{}, err
@@ -114,6 +107,16 @@ func WriteInitialReplicaState(
 	return newMS, nil
 }
 
+// WriteInitialTruncState writes the initial RaftTruncatedState.
+// TODO(arulajmani): remove this.
+func WriteInitialTruncState(ctx context.Context, w storage.Writer, rangeID roachpb.RangeID) error {
+	return logstore.NewStateLoader(rangeID).SetRaftTruncatedState(ctx, w,
+		&kvserverpb.RaftTruncatedState{
+			Index: RaftInitialLogIndex,
+			Term:  RaftInitialLogTerm,
+		})
+}
+
 // WriteInitialRangeState writes the initial range state. It's called during
 // bootstrap.
 func WriteInitialRangeState(
@@ -134,17 +137,35 @@ func WriteInitialRangeState(
 	); err != nil {
 		return err
 	}
-
-	// TODO(sep-raft-log): when the log storage is separated, the below can't be
-	// written in the same batch. Figure out the ordering required here.
-	sl := Make(desc.RangeID)
-	if err := sl.SynthesizeRaftState(ctx, readWriter); err != nil {
-		return err
-	}
 	// Maintain the invariant that any replica (uninitialized or initialized),
 	// with persistent state, has a RaftReplicaID.
-	if err := sl.SetRaftReplicaID(ctx, readWriter, replicaID); err != nil {
+	if err := Make(desc.RangeID).SetRaftReplicaID(ctx, readWriter, replicaID); err != nil {
 		return err
 	}
-	return nil
+
+	// TODO(sep-raft-log): when the log storage is separated, raft state must be
+	// written separately.
+	return WriteInitialRaftState(ctx, readWriter, desc.RangeID)
+}
+
+// WriteInitialRaftState writes raft state for an initialized replica created
+// during cluster bootstrap.
+func WriteInitialRaftState(
+	ctx context.Context, writer storage.Writer, rangeID roachpb.RangeID,
+) error {
+	sl := logstore.NewStateLoader(rangeID)
+	// Initialize the HardState with the term and commit index matching the
+	// initial applied state of the replica.
+	if err := sl.SetHardState(ctx, writer, raftpb.HardState{
+		Term:   RaftInitialLogTerm,
+		Commit: RaftInitialLogIndex,
+	}); err != nil {
+		return err
+	}
+	// The raft log is initialized empty, with the truncated state matching the
+	// committed / applied initial state of the replica.
+	return sl.SetRaftTruncatedState(ctx, writer, &kvserverpb.RaftTruncatedState{
+		Index: RaftInitialLogIndex,
+		Term:  RaftInitialLogTerm,
+	})
 }

pkg/kv/kvserver/stateloader/stateloader.go

@@ -442,10 +442,14 @@ func UninitializedReplicaState(rangeID roachpb.RangeID) kvserverpb.ReplicaState
 
 // The rest is not technically part of ReplicaState.
 
-// SynthesizeRaftState creates a Raft state which synthesizes both a HardState
-// and a lastIndex from pre-seeded data in the engine (typically created via
-// WriteInitialReplicaState and, on a split, perhaps the activity of an
-// uninitialized Raft group)
+// SynthesizeRaftState creates a Raft state which synthesizes HardState from
+// pre-seeded data in the engine: the state machine state created by
+// WriteInitialReplicaState on a split, and the existing HardState of an
+// uninitialized replica.
+//
+// TODO(sep-raft-log): this is now only used in splits, when initializing a
+// replica. Make the implementation straightforward, most of the stuff here is
+// constant except the existing HardState.
 func (rsl StateLoader) SynthesizeRaftState(
 	ctx context.Context, readWriter storage.ReadWriter,
 ) error {

pkg/kv/kvserver/stateloader/testdata/TestWriteInitialRangeState.txt

@@ -1,10 +1,10 @@
 echo
 ----
-Put: 0,0 /Local/RangeID/5/u/RaftTruncatedState (0x01698d757266747400): index:10 term:5 
 Put: 0,0 /Local/RangeID/5/r/RangeLease (0x01698d72726c6c2d00): <empty>
 Put: 0,0 /Local/RangeID/5/r/RangeGCThreshold (0x01698d726c67632d00): 0,0
 Put: 0,0 /Local/RangeID/5/r/RangeGCHint (0x01698d727267636800): latest_range_delete_timestamp:<> gc_timestamp:<> gc_timestamp_next:<> 
 Put: 0,0 /Local/RangeID/5/r/RangeVersion (0x01698d727276657200): 10.2
 Put: 0,0 /Local/RangeID/5/r/RangeAppliedState (0x01698d727261736b00): raft_applied_index:10 lease_applied_index:10 range_stats:<sys_bytes:142 sys_count:4 > raft_closed_timestamp:<> raft_applied_index_term:5 
-Put: 0,0 /Local/RangeID/5/u/RaftHardState (0x01698d757266746800): term:5 vote:0 commit:10 lead:0 lead_epoch:0 
 Put: 0,0 /Local/RangeID/5/u/RaftReplicaID (0x01698d757266747200): replica_id:3 
+Put: 0,0 /Local/RangeID/5/u/RaftHardState (0x01698d757266746800): term:5 vote:0 commit:10 lead:0 lead_epoch:0 
+Put: 0,0 /Local/RangeID/5/u/RaftTruncatedState (0x01698d757266747400): index:10 term:5