func updateHardState(eng engine.ReadWriter, s storagebase.ReplicaState) error { // Load a potentially existing HardState as we may need to preserve // information about cast votes. For example, during a Split for which // another node's new right-hand side has contacted us before our left-hand // side called in here to create the group. rangeID := s.Desc.RangeID oldHS, err := loadHardState(eng, rangeID) if err != nil { return err } newHS := raftpb.HardState{ Term: s.TruncatedState.Term, Commit: s.RaftAppliedIndex, } if !raft.IsEmptyHardState(oldHS) { if oldHS.Commit > newHS.Commit { newHS.Commit = oldHS.Commit } if oldHS.Term > newHS.Term { newHS.Term = oldHS.Term } newHS.Vote = oldHS.Vote } return setHardState(eng, rangeID, newHS) }
// synthesizeHardState synthesizes a HardState from the given ReplicaState and // any existing on-disk HardState in the context of a snapshot, while verifying // that the application of the snapshot does not violate Raft invariants. It // must be called after the supplied state and ReadWriter have been updated // with the result of the snapshot. // If there is an existing HardState, we must respect it and we must not apply // a snapshot that would move the state backwards. func synthesizeHardState( ctx context.Context, eng engine.ReadWriter, s storagebase.ReplicaState, oldHS raftpb.HardState, ) error { newHS := raftpb.HardState{ Term: s.TruncatedState.Term, // Note that when applying a Raft snapshot, the applied index is // equal to the Commit index represented by the snapshot. Commit: s.RaftAppliedIndex, } if oldHS.Commit > newHS.Commit { return errors.Errorf("can't decrease HardState.Commit from %d to %d", oldHS.Commit, newHS.Commit) } if oldHS.Term > newHS.Term { // The existing HardState is allowed to be ahead of us, which is // relevant in practice for the split trigger. We already checked above // that we're not rewinding the acknowledged index, and we haven't // updated votes yet. newHS.Term = oldHS.Term } // If the existing HardState voted in this term, remember that. if oldHS.Term == newHS.Term { newHS.Vote = oldHS.Vote } return errors.Wrapf(setHardState(ctx, eng, s.Desc.RangeID, newHS), "writing HardState %+v", &newHS) }
// writeInitialState bootstraps a new Raft group (i.e. it is called when we // bootstrap a Range, or when setting up the right hand side of a split). // Its main task is to persist a consistent Raft (and associated Replica) state // which does not start from zero but presupposes a few entries already having // applied. // The supplied MVCCStats are used for the Stats field after adjusting for // persisting the state itself, and the updated stats are returned. func writeInitialState( eng engine.ReadWriter, ms enginepb.MVCCStats, desc roachpb.RangeDescriptor, ) (enginepb.MVCCStats, error) { rangeID := desc.RangeID var s storagebase.ReplicaState s.TruncatedState = &roachpb.RaftTruncatedState{ Term: raftInitialLogTerm, Index: raftInitialLogIndex, } s.RaftAppliedIndex = s.TruncatedState.Index s.Desc = &roachpb.RangeDescriptor{ RangeID: rangeID, } s.Stats = ms newMS, err := saveState(eng, s) if err != nil { return enginepb.MVCCStats{}, err } // Load a potentially existing HardState as we may need to preserve // information about cast votes. For example, during a Split for which // another node's new right-hand side has contacted us before our left-hand // side called in here to create the group. oldHS, err := loadHardState(eng, rangeID) if err != nil { return enginepb.MVCCStats{}, err } newHS := raftpb.HardState{ Term: s.TruncatedState.Term, Commit: s.TruncatedState.Index, } if !raft.IsEmptyHardState(oldHS) { if oldHS.Commit > newHS.Commit { newHS.Commit = oldHS.Commit } if oldHS.Term > newHS.Term { newHS.Term = oldHS.Term } newHS.Vote = oldHS.Vote } if err := setHardState(eng, rangeID, newHS); err != nil { return enginepb.MVCCStats{}, err } if err := setLastIndex(eng, rangeID, s.TruncatedState.Index); err != nil { return enginepb.MVCCStats{}, err } return newMS, nil }