// loadLastIndex retrieves the last index from storage. func (r *Replica) loadLastIndex() (uint64, error) { lastIndex := uint64(0) v, _, err := engine.MVCCGet(r.rm.Engine(), keys.RaftLastIndexKey(r.Desc().RangeID), roachpb.ZeroTimestamp, true /* consistent */, nil) if err != nil { return 0, err } if v != nil { var err error _, lastIndex, err = encoding.DecodeUint64(v.GetRawBytes()) if err != nil { return 0, err } } else { // The log is empty, which means we are either starting from scratch // or the entire log has been truncated away. raftTruncatedState // handles both cases. lastEnt, err := r.raftTruncatedState() if err != nil { return 0, err } lastIndex = lastEnt.Index } return lastIndex, nil }
// loadLastIndexLocked retrieves the last index from storage. // loadLastIndexLocked requires that the replica lock is held. func (r *Replica) loadLastIndexLocked() (uint64, error) { lastIndex := uint64(0) v, _, err := engine.MVCCGet(r.store.Engine(), keys.RaftLastIndexKey(r.RangeID), roachpb.ZeroTimestamp, true /* consistent */, nil) if err != nil { return 0, err } if v != nil { int64LastIndex, err := v.GetInt() if err != nil { return 0, err } lastIndex = uint64(int64LastIndex) } else { // The log is empty, which means we are either starting from scratch // or the entire log has been truncated away. raftTruncatedState // handles both cases. lastEnt, err := r.raftTruncatedStateLocked() if err != nil { return 0, err } lastIndex = lastEnt.Index } return lastIndex, nil }
func loadLastIndex( ctx context.Context, reader engine.Reader, rangeID roachpb.RangeID, ) (uint64, error) { lastIndex := uint64(0) v, _, err := engine.MVCCGet(ctx, reader, keys.RaftLastIndexKey(rangeID), hlc.ZeroTimestamp, true /* consistent */, nil) if err != nil { return 0, err } if v != nil { int64LastIndex, err := v.GetInt() if err != nil { return 0, err } lastIndex = uint64(int64LastIndex) } else { // The log is empty, which means we are either starting from scratch // or the entire log has been truncated away. lastEnt, err := loadTruncatedState(ctx, reader, rangeID) if err != nil { return 0, err } lastIndex = lastEnt.Index } return lastIndex, nil }
// loadLastIndex retrieves the last index from storage. func loadLastIndex(eng engine.Reader, rangeID roachpb.RangeID, isInitialized bool) (uint64, error) { lastIndex := uint64(0) v, _, err := engine.MVCCGet(context.Background(), eng, keys.RaftLastIndexKey(rangeID), roachpb.ZeroTimestamp, true /* consistent */, nil) if err != nil { return 0, err } if v != nil { int64LastIndex, err := v.GetInt() if err != nil { return 0, err } lastIndex = uint64(int64LastIndex) } else { // The log is empty, which means we are either starting from scratch // or the entire log has been truncated away. raftTruncatedState // handles both cases. lastEnt, err := raftTruncatedState(eng, rangeID, isInitialized) if err != nil { return 0, err } lastIndex = lastEnt.Index } return lastIndex, nil }
// setLastIndex persists a new last index. func setLastIndex(eng engine.Engine, rangeID roachpb.RangeID, lastIndex uint64) error { var value roachpb.Value value.SetInt(int64(lastIndex)) return engine.MVCCPut(eng, nil, keys.RaftLastIndexKey(rangeID), roachpb.ZeroTimestamp, value, nil /* txn */) }
func setLastIndex(eng engine.ReadWriter, rangeID roachpb.RangeID, lastIndex uint64) error { var value roachpb.Value value.SetInt(int64(lastIndex)) return engine.MVCCPut(context.Background(), eng, nil, keys.RaftLastIndexKey(rangeID), hlc.ZeroTimestamp, value, nil /* txn */) }
// createRangeData creates sample range data in all possible areas of // the key space. Returns a slice of the encoded keys of all created // data. func createRangeData(t *testing.T, r *Replica) []engine.MVCCKey { ts0 := hlc.ZeroTimestamp ts := hlc.Timestamp{WallTime: 1} desc := r.Desc() keyTSs := []struct { key roachpb.Key ts hlc.Timestamp }{ {keys.AbortCacheKey(r.RangeID, testTxnID), ts0}, {keys.AbortCacheKey(r.RangeID, testTxnID2), ts0}, {keys.RangeFrozenStatusKey(r.RangeID), ts0}, {keys.RangeLastGCKey(r.RangeID), ts0}, {keys.RaftAppliedIndexKey(r.RangeID), ts0}, {keys.RaftTruncatedStateKey(r.RangeID), ts0}, {keys.LeaseAppliedIndexKey(r.RangeID), ts0}, {keys.RangeStatsKey(r.RangeID), ts0}, {keys.RaftHardStateKey(r.RangeID), ts0}, {keys.RaftLastIndexKey(r.RangeID), ts0}, {keys.RaftLogKey(r.RangeID, 1), ts0}, {keys.RaftLogKey(r.RangeID, 2), ts0}, {keys.RangeLastReplicaGCTimestampKey(r.RangeID), ts0}, {keys.RangeLastVerificationTimestampKey(r.RangeID), ts0}, {keys.RangeDescriptorKey(desc.StartKey), ts}, {keys.TransactionKey(roachpb.Key(desc.StartKey), uuid.NewV4()), ts0}, {keys.TransactionKey(roachpb.Key(desc.StartKey.Next()), uuid.NewV4()), ts0}, {keys.TransactionKey(fakePrevKey(desc.EndKey), uuid.NewV4()), ts0}, // TODO(bdarnell): KeyMin.Next() results in a key in the reserved system-local space. // Once we have resolved https://github.com/cockroachdb/cockroach/issues/437, // replace this with something that reliably generates the first valid key in the range. //{r.Desc().StartKey.Next(), ts}, // The following line is similar to StartKey.Next() but adds more to the key to // avoid falling into the system-local space. {append(append([]byte{}, desc.StartKey...), '\x02'), ts}, {fakePrevKey(r.Desc().EndKey), ts}, } keys := []engine.MVCCKey{} for _, keyTS := range keyTSs { if err := engine.MVCCPut(context.Background(), r.store.Engine(), nil, keyTS.key, keyTS.ts, roachpb.MakeValueFromString("value"), nil); err != nil { t.Fatal(err) } keys = append(keys, engine.MVCCKey{Key: keyTS.key, Timestamp: keyTS.ts}) } return keys }
// setLastIndex persists a new last index. func setLastIndex(eng engine.Engine, raftID proto.RaftID, lastIndex uint64) error { return engine.MVCCPut(eng, nil, keys.RaftLastIndexKey(raftID), proto.ZeroTimestamp, proto.Value{ Bytes: encoding.EncodeUint64(nil, lastIndex), }, nil) }
// setLastIndex persists a new last index. func setLastIndex(eng engine.Engine, rangeID roachpb.RangeID, lastIndex uint64) error { return engine.MVCCPut(eng, nil, keys.RaftLastIndexKey(rangeID), roachpb.ZeroTimestamp, roachpb.MakeValueFromBytes(encoding.EncodeUint64(nil, lastIndex)), nil) }