storage

package

Go to main page

Versions in this module

v1

v1.1.9

Oct 1, 2018

Changes in this version

+ const MaxCommandSizeFloor

+ const MinStatsDuration

+ const RaftLogQueueStaleSize

+ var EnableStatsBasedRebalancing = settings.RegisterBoolSetting("kv.allocator.stat_based_rebalancing.enabled", ...)

+ var ErrEpochIncremented = errors.New("heartbeat failed on epoch increment")

+ var ErrIntOverflowLeaseStatus = fmt.Errorf("proto: integer overflow")

+ var ErrIntOverflowLog = fmt.Errorf("proto: integer overflow")

+ var ErrInvalidLengthLeaseStatus = fmt.Errorf("proto: negative length found during unmarshaling")

+ var ErrInvalidLengthLog = fmt.Errorf("proto: negative length found during unmarshaling")

+ var LeaseState_name = map[int32]string

+ var LeaseState_value = map[string]int32

+ var MaxCommandSize = settings.RegisterValidatedByteSizeSetting("kv.raft.command.max_size", "maximum size of a raft command", 64 << 20, ...)

+ var RangeLogEventType_name = map[int32]string

+ var RangeLogEventType_value = map[string]int32

+ var TimeUntilStoreDead = settings.RegisterNonNegativeDurationSetting("server.time_until_store_dead", ...)

+ func HasRaftLeader(raftStatus *raft.Status) bool

+ func ReadClusterVersion(ctx context.Context, reader engine.Reader) (cluster.ClusterVersion, error)

+ func ReadVersionFromEngineOrDefault(ctx context.Context, e engine.Engine) (cluster.ClusterVersion, error)

+ func SetAddSSTableCmd(cmd Command)

+ func SynthesizeClusterVersionFromEngines(ctx context.Context, engines []engine.Engine, ...) (cluster.ClusterVersion, error)

+ func TestingRelocateRange(ctx context.Context, db *client.DB, rangeDesc roachpb.RangeDescriptor, ...) error

+ func WriteClusterVersion(ctx context.Context, writer engine.ReadWriter, cv cluster.ClusterVersion) error

+ func WriteClusterVersionToEngines(ctx context.Context, engines []engine.Engine, cv cluster.ClusterVersion) error

type AllocatorAction

+ const AllocatorConsiderRebalance

+ const AllocatorRemoveDecommissioning

+ type CommandQueueMetrics struct

+ MaxOverlapsSeen int64

+ ReadCommands int64

+ TreeSize int32

+ WriteCommands int64

type EvalResult

+ func (p *EvalResult) IsZero() bool

+ type LeaseState int32

+ const LeaseState_ERROR

+ const LeaseState_EXPIRED

+ const LeaseState_PROSCRIBED

+ const LeaseState_STASIS

+ const LeaseState_VALID

+ func (LeaseState) EnumDescriptor() ([]byte, []int)

+ func (x LeaseState) String() string

type LeaseStatus

+ Lease cockroach_roachpb2.Lease

+ Liveness *Liveness

+ State LeaseState

+ Timestamp cockroach_util_hlc.Timestamp

+ func (*LeaseStatus) Descriptor() ([]byte, []int)

+ func (*LeaseStatus) ProtoMessage()

+ func (m *LeaseStatus) Marshal() (dAtA []byte, err error)

+ func (m *LeaseStatus) MarshalTo(dAtA []byte) (int, error)

+ func (m *LeaseStatus) Reset()

+ func (m *LeaseStatus) Size() (n int)

+ func (m *LeaseStatus) String() string

+ func (m *LeaseStatus) Unmarshal(dAtA []byte) error

type Liveness

+ Decommissioning bool

+ func (l *Liveness) IsLive(now hlc.Timestamp, maxOffset time.Duration) bool

type NodeLiveness

+ func (nl *NodeLiveness) DisableAllHeartbeatsForTest() func()

+ func (nl *NodeLiveness) SetDecommissioning(ctx context.Context, nodeID roachpb.NodeID, decommission bool) error

type OutgoingSnapshot

+ RaftEntryCache *raftEntryCache

+ WithSideloaded func(func(sideloadStorage) error) error

+ type RangeInfo struct

+ Desc *roachpb.RangeDescriptor

+ LogicalBytes int64

+ WritesPerSecond float64

+ type RangeLogEvent struct

+ EventType RangeLogEventType

+ Info *RangeLogEvent_Info

+ OtherRangeID github_com_cockroachdb_cockroach_pkg_roachpb.RangeID

+ RangeID github_com_cockroachdb_cockroach_pkg_roachpb.RangeID

+ StoreID github_com_cockroachdb_cockroach_pkg_roachpb.StoreID

+ Timestamp time.Time

+ func (*RangeLogEvent) Descriptor() ([]byte, []int)

+ func (*RangeLogEvent) ProtoMessage()

+ func (m *RangeLogEvent) Marshal() (dAtA []byte, err error)

+ func (m *RangeLogEvent) MarshalTo(dAtA []byte) (int, error)

+ func (m *RangeLogEvent) Reset()

+ func (m *RangeLogEvent) Size() (n int)

+ func (m *RangeLogEvent) String() string

+ func (m *RangeLogEvent) Unmarshal(dAtA []byte) error

+ type RangeLogEventReason string

+ const ReasonAdminRequest

+ const ReasonRangeOverReplicated

+ const ReasonRangeUnderReplicated

+ const ReasonRebalance

+ const ReasonStoreDead

+ const ReasonStoreDecommissioning

+ const ReasonUnknown

+ type RangeLogEventType int32

+ const RangeLogEventType_add

+ const RangeLogEventType_remove

+ const RangeLogEventType_split

+ func (RangeLogEventType) EnumDescriptor() ([]byte, []int)

+ func (x RangeLogEventType) String() string

+ type RangeLogEvent_Info struct

+ AddedReplica *cockroach_roachpb.ReplicaDescriptor

+ Details string

+ NewDesc *cockroach_roachpb.RangeDescriptor

+ Reason RangeLogEventReason

+ RemovedReplica *cockroach_roachpb.ReplicaDescriptor

+ UpdatedDesc *cockroach_roachpb.RangeDescriptor

+ func (*RangeLogEvent_Info) Descriptor() ([]byte, []int)

+ func (*RangeLogEvent_Info) ProtoMessage()

+ func (m *RangeLogEvent_Info) Marshal() (dAtA []byte, err error)

+ func (m *RangeLogEvent_Info) MarshalTo(dAtA []byte) (int, error)

+ func (m *RangeLogEvent_Info) Reset()

+ func (m *RangeLogEvent_Info) Size() (n int)

+ func (m *RangeLogEvent_Info) String() string

+ func (m *RangeLogEvent_Info) Unmarshal(dAtA []byte) error

type Replica

+ func (r *Replica) LastReplicaAdded() (roachpb.ReplicaID, time.Time)

+ func (r *Replica) OwnsValidLease(ts hlc.Timestamp) bool

+ func (r *Replica) QueriesPerSecond() float64

+ func (r *Replica) WritesPerSecond() float64

type ReplicaEvalContext

+ func (rec ReplicaEvalContext) ClusterSettings() *cluster.Settings

type ReplicaMetrics

+ CmdQMetricsGlobal CommandQueueMetrics

+ CmdQMetricsLocal CommandQueueMetrics

+ LeaseStatus LeaseStatus

+ type ResolveOptions struct

+ Poison bool

+ Wait bool

type SpanSet

+ func (ss *SpanSet) String() string

type Store

+ func (s *Store) AllocatorDryRun(ctx context.Context, repl *Replica) ([]tracing.RecordedSpan, error)

+ func (s *Store) ClusterSettings() *cluster.Settings

type StoreConfig

+ IntentResolverTaskLimit int

+ Settings *cluster.Settings

type StoreMetrics

+ AddSSTableApplications *metric.Counter

+ AddSSTableProposals *metric.Counter

+ AverageWritesPerSecond *metric.GaugeFloat64

+ TotalBytes *metric.Gauge

+ Used *metric.Gauge

type StoreTestingKnobs

+ BootstrapVersion *cluster.ClusterVersion

+ DisableLeaseCapacityGossip bool

+ DisableRaftSnapshotQueue bool

+ DisableReplicaRebalancing bool

+ OnCommandQueueAction func(*roachpb.BatchRequest, storagebase.CommandQueueAction)

+ TestingProposalFilter storagebase.ReplicaCommandFilter

type Stores

+ func (ls *Stores) SynthesizeClusterVersion(ctx context.Context) (cluster.ClusterVersion, error)

+ func (ls *Stores) WriteClusterVersion(ctx context.Context, cv cluster.ClusterVersion) error

v1.1.0-rc.1

Oct 4, 2017

v1.0.2

Jun 7, 2017

Changes in this version

+ const IntersectingSnapshotMsg

+ const MinTSCacheWindow

+ const RaftLogQueueStaleThreshold

+ const RaftLogQueueTimerDuration

+ const ReplicaGCQueueCandidateTimeout

+ const ReplicaGCQueueInactivityThreshold

+ const TestTimeUntilStoreDead

+ const TestTimeUntilStoreDeadOff

+ const TimeSeriesMaintenanceInterval

+ var EnableLoadBasedLeaseRebalancing = settings.RegisterBoolSetting("kv.allocator.load_based_lease_rebalancing.enabled", ...)

+ var ErrIntOverflowApi = fmt.Errorf("proto: integer overflow")

+ var ErrIntOverflowLiveness = fmt.Errorf("proto: integer overflow")

+ var ErrIntOverflowRaft = fmt.Errorf("proto: integer overflow")

+ var ErrInvalidLengthApi = fmt.Errorf("proto: negative length found during unmarshaling")

+ var ErrInvalidLengthLiveness = fmt.Errorf("proto: negative length found during unmarshaling")

+ var ErrInvalidLengthRaft = fmt.Errorf("proto: negative length found during unmarshaling")

+ var ErrNoLivenessRecord = errors.New("node not in the liveness table")

+ var LeaseRebalancingAggressiveness = settings.RegisterFloatSetting("kv.allocator.lease_rebalancing_aggressiveness", ..., 1.0)

+ var MinLeaseTransferStatsDuration = replStatsRotateInterval

+ var SnapshotRequest_Priority_name = map[int32]string

+ var SnapshotRequest_Priority_value = map[string]int32

+ var SnapshotResponse_Status_name = map[int32]string

+ var SnapshotResponse_Status_value = map[string]int32

+ func ComputeStatsForRange(d *roachpb.RangeDescriptor, e engine.Reader, nowNanos int64) (enginepb.MVCCStats, error)

+ func DecodeRaftCommand(data []byte) (storagebase.CmdIDKey, []byte)

+ func DefaultDeclareKeys(desc roachpb.RangeDescriptor, header roachpb.Header, req roachpb.Request, ...)

+ func EnableLeaseHistory(maxEntries int) func()

+ func IsSnapshotError(err error) bool

+ func IterateRangeDescriptors(ctx context.Context, eng engine.Reader, ...) error

+ func NewReplicaCorruptionError(err error) *roachpb.ReplicaCorruptionError

+ func NodeLivenessDurations(raftElectionTimeout time.Duration) (livenessActive time.Duration, livenessRenewal time.Duration)

+ func RaftElectionTimeout(raftTickInterval time.Duration, raftElectionTimeoutTicks int) time.Duration

+ func RangeLeaseDurations(raftElectionTimeout time.Duration) (rangeLeaseActive time.Duration, rangeLeaseRenewal time.Duration)

+ func ReadStoreIdent(ctx context.Context, eng engine.Engine) (roachpb.StoreIdent, error)

+ func RegisterConsistencyServer(s *grpc.Server, srv ConsistencyServer)

+ func RegisterMultiRaftServer(s *grpc.Server, srv MultiRaftServer)

+ func RelocateRange(ctx context.Context, db *client.DB, rangeDesc roachpb.RangeDescriptor, ...) error

+ func SetExportCmd(cmd Command)

+ func SetImportCmd(fn ImportCmdFunc)

+ func SetWriteBatchCmd(cmd Command)

+ func TrackRaftProtos() func() []reflect.Type

+ type AbortCache struct

+ func NewAbortCache(rangeID roachpb.RangeID) *AbortCache

+ func (sc *AbortCache) ClearData(e engine.Engine) error

+ func (sc *AbortCache) CopyFrom(ctx context.Context, e engine.ReadWriter, ms *enginepb.MVCCStats, ...) (int, error)

+ func (sc *AbortCache) CopyInto(e engine.ReadWriter, ms *enginepb.MVCCStats, destRangeID roachpb.RangeID) (int, error)

+ func (sc *AbortCache) Del(ctx context.Context, e engine.ReadWriter, ms *enginepb.MVCCStats, ...) error

+ func (sc *AbortCache) Get(ctx context.Context, e engine.Reader, txnID uuid.UUID, ...) (bool, error)

+ func (sc *AbortCache) Iterate(ctx context.Context, e engine.Reader, f func([]byte, roachpb.AbortCacheEntry))

+ func (sc *AbortCache) Put(ctx context.Context, e engine.ReadWriter, ms *enginepb.MVCCStats, ...) error

+ type Allocator struct

+ func MakeAllocator(storePool *StorePool, nodeLatencyFn func(addr string) (time.Duration, bool)) Allocator

+ func (a *Allocator) AllocateTarget(ctx context.Context, constraints config.Constraints, ...) (*roachpb.StoreDescriptor, error)

+ func (a *Allocator) ComputeAction(ctx context.Context, zone config.ZoneConfig, desc *roachpb.RangeDescriptor) (AllocatorAction, float64)

+ func (a *Allocator) ShouldTransferLease(ctx context.Context, constraints config.Constraints, ...) bool

+ func (a *Allocator) TransferLeaseTarget(ctx context.Context, constraints config.Constraints, ...) roachpb.ReplicaDescriptor

+ func (a Allocator) RebalanceTarget(ctx context.Context, constraints config.Constraints, ...) (*roachpb.StoreDescriptor, error)

+ func (a Allocator) RemoveTarget(ctx context.Context, constraints config.Constraints, ...) (roachpb.ReplicaDescriptor, error)

+ type AllocatorAction int

+ const AllocatorAdd

+ const AllocatorNoop

+ const AllocatorRemove

+ const AllocatorRemoveDead

+ func (a AllocatorAction) String() string

+ type CollectChecksumRequest struct

+ Checksum []byte

+ ChecksumID github_com_cockroachdb_cockroach_pkg_util_uuid.UUID

+ RangeID github_com_cockroachdb_cockroach_pkg_roachpb.RangeID

+ func (*CollectChecksumRequest) Descriptor() ([]byte, []int)

+ func (*CollectChecksumRequest) ProtoMessage()

+ func (m *CollectChecksumRequest) Marshal() (dAtA []byte, err error)

+ func (m *CollectChecksumRequest) MarshalTo(dAtA []byte) (int, error)

+ func (m *CollectChecksumRequest) Reset()

+ func (m *CollectChecksumRequest) Size() (n int)

+ func (m *CollectChecksumRequest) String() string

+ func (m *CollectChecksumRequest) Unmarshal(dAtA []byte) error

+ type CollectChecksumResponse struct

+ Checksum []byte

+ Snapshot *cockroach_roachpb1.RaftSnapshotData

+ func (*CollectChecksumResponse) Descriptor() ([]byte, []int)

+ func (*CollectChecksumResponse) ProtoMessage()

+ func (m *CollectChecksumResponse) Marshal() (dAtA []byte, err error)

+ func (m *CollectChecksumResponse) MarshalTo(dAtA []byte) (int, error)

+ func (m *CollectChecksumResponse) Reset()

+ func (m *CollectChecksumResponse) Size() (n int)

+ func (m *CollectChecksumResponse) String() string

+ func (m *CollectChecksumResponse) Unmarshal(dAtA []byte) error

+ type Command struct

+ DeclareKeys func(roachpb.RangeDescriptor, roachpb.Header, roachpb.Request, *SpanSet)

+ Eval func(context.Context, engine.ReadWriter, CommandArgs, roachpb.Response) (EvalResult, error)

+ type CommandArgs struct

+ Args roachpb.Request

+ EvalCtx ReplicaEvalContext

+ Header roachpb.Header

+ MaxKeys int64

+ Stats *enginepb.MVCCStats

+ type CommandQueue struct

+ func NewCommandQueue(coveringOptimization bool) *CommandQueue

+ func (cq *CommandQueue) String() string

+ type ConfChangeContext struct

+ CommandID string

+ Payload []byte

+ Replica cockroach_roachpb.ReplicaDescriptor

+ func (*ConfChangeContext) Descriptor() ([]byte, []int)

+ func (*ConfChangeContext) ProtoMessage()

+ func (m *ConfChangeContext) Marshal() (dAtA []byte, err error)

+ func (m *ConfChangeContext) MarshalTo(dAtA []byte) (int, error)

+ func (m *ConfChangeContext) Reset()

+ func (m *ConfChangeContext) Size() (n int)

+ func (m *ConfChangeContext) String() string

+ func (m *ConfChangeContext) Unmarshal(dAtA []byte) error

+ type ConsistencyClient interface

+ CollectChecksum func(ctx context.Context, in *CollectChecksumRequest, opts ...grpc.CallOption) (*CollectChecksumResponse, error)

+ func NewConsistencyClient(cc *grpc.ClientConn) ConsistencyClient

+ type ConsistencyServer interface

+ CollectChecksum func(context.Context, *CollectChecksumRequest) (*CollectChecksumResponse, error)

+ type EvalResult struct

+ Local LocalEvalResult

+ Replicated storagebase.ReplicatedEvalResult

+ WriteBatch *storagebase.WriteBatch

+ func (p *EvalResult) MergeAndDestroy(q EvalResult) error

+ type GCInfo struct

+ AbortSpanConsidered int

+ AbortSpanGCNum int

+ AbortSpanTotal int

+ IntentTxns int

+ IntentsConsidered int

+ Now hlc.Timestamp

+ NumKeysAffected int

+ Policy config.GCPolicy

+ PushTxn int

+ ResolveSuccess int

+ ResolveTotal int

+ Threshold hlc.Timestamp

+ TransactionSpanGCAborted int

+ TransactionSpanGCCommitted int

+ TransactionSpanGCPending int

+ TransactionSpanTotal int

+ TxnSpanGCThreshold hlc.Timestamp

+ func RunGC(ctx context.Context, desc *roachpb.RangeDescriptor, snap engine.Reader, ...) ([]roachpb.GCRequest_GCKey, GCInfo, error)

+ type HeartbeatCallback func(context.Context) error

+ type ImportCmdFunc func(context.Context, CommandArgs) (*roachpb.ImportResponse, error)

+ type IncomingSnapshot struct

+ Batches [][]byte

+ LogEntries [][]byte

+ SnapUUID uuid.UUID

+ State *storagebase.ReplicaState

+ type IsLiveCallback func(nodeID roachpb.NodeID)

+ type KeyRange interface

+ Desc func() *roachpb.RangeDescriptor

+ type LeaseStatus struct

+ type Liveness struct

+ Draining bool

+ Epoch int64

+ Expiration cockroach_util_hlc.Timestamp

+ NodeID github_com_cockroachdb_cockroach_pkg_roachpb.NodeID

+ func (*Liveness) Descriptor() ([]byte, []int)

+ func (*Liveness) ProtoMessage()

+ func (m *Liveness) Marshal() (dAtA []byte, err error)

+ func (m *Liveness) MarshalTo(dAtA []byte) (int, error)

+ func (m *Liveness) Reset()

+ func (m *Liveness) Size() (n int)

+ func (m *Liveness) String() string

+ func (m *Liveness) Unmarshal(dAtA []byte) error

+ type LivenessMetrics struct

+ EpochIncrements *metric.Counter

+ HeartbeatFailures *metric.Counter

+ HeartbeatSuccesses *metric.Counter

+ LiveNodes *metric.Gauge

+ type LocalEvalResult struct

+ Err *roachpb.Error

+ Reply *roachpb.BatchResponse

+ type MultiRaftClient interface

+ RaftMessageBatch func(ctx context.Context, opts ...grpc.CallOption) (MultiRaft_RaftMessageBatchClient, error)

+ RaftSnapshot func(ctx context.Context, opts ...grpc.CallOption) (MultiRaft_RaftSnapshotClient, error)

+ func NewMultiRaftClient(cc *grpc.ClientConn) MultiRaftClient

+ type MultiRaftServer interface

+ RaftMessageBatch func(MultiRaft_RaftMessageBatchServer) error

+ RaftSnapshot func(MultiRaft_RaftSnapshotServer) error

+ type MultiRaft_RaftMessageBatchClient interface

+ Recv func() (*RaftMessageResponse, error)

+ Send func(*RaftMessageRequestBatch) error

+ type MultiRaft_RaftMessageBatchServer interface

+ Recv func() (*RaftMessageRequestBatch, error)

+ Send func(*RaftMessageResponse) error

+ type MultiRaft_RaftSnapshotClient interface

+ Recv func() (*SnapshotResponse, error)

+ Send func(*SnapshotRequest) error

+ type MultiRaft_RaftSnapshotServer interface

+ Recv func() (*SnapshotRequest, error)

+ Send func(*SnapshotResponse) error

+ type NodeAddressResolver func(roachpb.NodeID) (net.Addr, error)

+ func GossipAddressResolver(gossip *gossip.Gossip) NodeAddressResolver

+ type NodeLiveness struct

+ func NewNodeLiveness(ambient log.AmbientContext, clock *hlc.Clock, db *client.DB, g *gossip.Gossip, ...) *NodeLiveness

+ func (nl *NodeLiveness) GetIsLiveMap() map[roachpb.NodeID]bool

+ func (nl *NodeLiveness) GetLiveness(nodeID roachpb.NodeID) (*Liveness, error)

+ func (nl *NodeLiveness) GetLivenessThreshold() time.Duration

+ func (nl *NodeLiveness) GetLivenesses() []Liveness

+ func (nl *NodeLiveness) Heartbeat(ctx context.Context, liveness *Liveness) error

+ func (nl *NodeLiveness) IncrementEpoch(ctx context.Context, liveness *Liveness) error

+ func (nl *NodeLiveness) IsLive(nodeID roachpb.NodeID) (bool, error)

+ func (nl *NodeLiveness) Metrics() LivenessMetrics

+ func (nl *NodeLiveness) PauseHeartbeat(pause bool)

+ func (nl *NodeLiveness) RegisterCallback(cb IsLiveCallback)

+ func (nl *NodeLiveness) Self() (*Liveness, error)

+ func (nl *NodeLiveness) SetDraining(ctx context.Context, drain bool)

+ func (nl *NodeLiveness) StartHeartbeat(ctx context.Context, stopper *stop.Stopper, alive HeartbeatCallback)

+ type NodeLivenessFunc func(roachpb.NodeID, time.Time, time.Duration) nodeStatus

+ func MakeStorePoolNodeLivenessFunc(nodeLiveness *NodeLiveness) NodeLivenessFunc

+ type NotBootstrappedError struct

+ func (e *NotBootstrappedError) Error() string

+ type OutgoingSnapshot struct

+ EngineSnap engine.Reader

+ Iter *ReplicaDataIterator

+ RaftSnap raftpb.Snapshot

+ SnapUUID uuid.UUID

+ State storagebase.ReplicaState

+ func (s *OutgoingSnapshot) Close()

+ type OutgoingSnapshotStream interface

+ Recv func() (*SnapshotResponse, error)

+ Send func(*SnapshotRequest) error

+ type ProposalData struct

+ Local *LocalEvalResult

+ Request *roachpb.BatchRequest

+ type RaftHeartbeat struct

+ Commit uint64

+ FromReplicaID github_com_cockroachdb_cockroach_pkg_roachpb.ReplicaID

+ Quiesce bool

+ RangeID github_com_cockroachdb_cockroach_pkg_roachpb.RangeID

+ Term uint64

+ ToReplicaID github_com_cockroachdb_cockroach_pkg_roachpb.ReplicaID

+ func (*RaftHeartbeat) Descriptor() ([]byte, []int)

+ func (*RaftHeartbeat) ProtoMessage()

+ func (m *RaftHeartbeat) Marshal() (dAtA []byte, err error)

+ func (m *RaftHeartbeat) MarshalTo(dAtA []byte) (int, error)

+ func (m *RaftHeartbeat) Reset()

+ func (m *RaftHeartbeat) Size() (n int)

+ func (m *RaftHeartbeat) String() string

+ func (m *RaftHeartbeat) Unmarshal(dAtA []byte) error

+ type RaftMessageHandler interface

+ HandleRaftRequest func(ctx context.Context, req *RaftMessageRequest, ...) *roachpb.Error

+ HandleRaftResponse func(context.Context, *RaftMessageResponse) error

+ HandleSnapshot func(header *SnapshotRequest_Header, respStream SnapshotResponseStream) error

+ type RaftMessageRequest struct

+ FromReplica cockroach_roachpb.ReplicaDescriptor

+ HeartbeatResps []RaftHeartbeat

+ Heartbeats []RaftHeartbeat

+ Message raftpb.Message

+ Quiesce bool

+ RangeID github_com_cockroachdb_cockroach_pkg_roachpb.RangeID

+ ToReplica cockroach_roachpb.ReplicaDescriptor

+ func (*RaftMessageRequest) Descriptor() ([]byte, []int)

+ func (*RaftMessageRequest) GetUser() string

+ func (*RaftMessageRequest) ProtoMessage()

+ func (m *RaftMessageRequest) Marshal() (dAtA []byte, err error)

+ func (m *RaftMessageRequest) MarshalTo(dAtA []byte) (int, error)

+ func (m *RaftMessageRequest) Reset()

+ func (m *RaftMessageRequest) Size() (n int)

+ func (m *RaftMessageRequest) String() string

+ func (m *RaftMessageRequest) Unmarshal(dAtA []byte) error

+ type RaftMessageRequestBatch struct

+ Requests []RaftMessageRequest

+ func (*RaftMessageRequestBatch) Descriptor() ([]byte, []int)

+ func (*RaftMessageRequestBatch) ProtoMessage()

+ func (m *RaftMessageRequestBatch) Marshal() (dAtA []byte, err error)

+ func (m *RaftMessageRequestBatch) MarshalTo(dAtA []byte) (int, error)

+ func (m *RaftMessageRequestBatch) Reset()

+ func (m *RaftMessageRequestBatch) Size() (n int)

+ func (m *RaftMessageRequestBatch) String() string

+ func (m *RaftMessageRequestBatch) Unmarshal(dAtA []byte) error

+ type RaftMessageResponse struct

+ FromReplica cockroach_roachpb.ReplicaDescriptor

+ RangeID github_com_cockroachdb_cockroach_pkg_roachpb.RangeID

+ ToReplica cockroach_roachpb.ReplicaDescriptor

+ Union RaftMessageResponseUnion

+ func (*RaftMessageResponse) Descriptor() ([]byte, []int)

+ func (*RaftMessageResponse) ProtoMessage()

+ func (m *RaftMessageResponse) Marshal() (dAtA []byte, err error)

+ func (m *RaftMessageResponse) MarshalTo(dAtA []byte) (int, error)

+ func (m *RaftMessageResponse) Reset()

+ func (m *RaftMessageResponse) Size() (n int)

+ func (m *RaftMessageResponse) String() string

+ func (m *RaftMessageResponse) Unmarshal(dAtA []byte) error

+ type RaftMessageResponseStream interface

+ Context func() context.Context

+ Send func(*RaftMessageResponse) error

+ type RaftMessageResponseUnion struct

+ Error *cockroach_roachpb3.Error

+ func (*RaftMessageResponseUnion) Descriptor() ([]byte, []int)

+ func (*RaftMessageResponseUnion) ProtoMessage()

+ func (m *RaftMessageResponseUnion) Marshal() (dAtA []byte, err error)

+ func (m *RaftMessageResponseUnion) MarshalTo(dAtA []byte) (int, error)

+ func (m *RaftMessageResponseUnion) Reset()

+ func (m *RaftMessageResponseUnion) Size() (n int)

+ func (m *RaftMessageResponseUnion) String() string

+ func (m *RaftMessageResponseUnion) Unmarshal(dAtA []byte) error

+ func (this *RaftMessageResponseUnion) GetValue() interface{}

+ func (this *RaftMessageResponseUnion) SetValue(value interface{}) bool

+ type RaftTransport struct

+ func NewDummyRaftTransport() *RaftTransport

+ func NewRaftTransport(ambient log.AmbientContext, resolver NodeAddressResolver, ...) *RaftTransport

+ func (t *RaftTransport) GetCircuitBreaker(nodeID roachpb.NodeID) *circuit.Breaker

+ func (t *RaftTransport) Listen(storeID roachpb.StoreID, handler RaftMessageHandler)

+ func (t *RaftTransport) RaftMessageBatch(stream MultiRaft_RaftMessageBatchServer) error

+ func (t *RaftTransport) RaftSnapshot(stream MultiRaft_RaftSnapshotServer) error

+ func (t *RaftTransport) SendAsync(req *RaftMessageRequest) bool

+ func (t *RaftTransport) SendSnapshot(ctx context.Context, storePool *StorePool, header SnapshotRequest_Header, ...) error

+ func (t *RaftTransport) Stop(storeID roachpb.StoreID)

+ type RangeEventLogType string

+ const RangeEventLogAdd

+ const RangeEventLogRemove

+ const RangeEventLogSplit

+ type Replica struct

+ RangeID roachpb.RangeID

+ func NewReplica(desc *roachpb.RangeDescriptor, store *Store, replicaID roachpb.ReplicaID) (*Replica, error)

+ func (r *Replica) AdminMerge(ctx context.Context, args roachpb.AdminMergeRequest) (roachpb.AdminMergeResponse, *roachpb.Error)

+ func (r *Replica) AdminSplit(ctx context.Context, args roachpb.AdminSplitRequest) (roachpb.AdminSplitResponse, *roachpb.Error)

+ func (r *Replica) AdminTransferLease(ctx context.Context, target roachpb.StoreID) error

+ func (r *Replica) ChangeReplicas(ctx context.Context, changeType roachpb.ReplicaChangeType, ...) error

+ func (r *Replica) CheckConsistency(ctx context.Context, args roachpb.CheckConsistencyRequest) (roachpb.CheckConsistencyResponse, *roachpb.Error)

+ func (r *Replica) ContainsKey(key roachpb.Key) bool

+ func (r *Replica) ContainsKeyRange(start, end roachpb.Key) bool

+ func (r *Replica) Desc() *roachpb.RangeDescriptor

+ func (r *Replica) Entries(lo, hi, maxBytes uint64) ([]raftpb.Entry, error)

+ func (r *Replica) FirstIndex() (uint64, error)

+ func (r *Replica) GetFirstIndex() (uint64, error)

+ func (r *Replica) GetLeaseHistory() []roachpb.Lease

+ func (r *Replica) GetMVCCStats() enginepb.MVCCStats

+ func (r *Replica) GetMaxBytes() int64

+ func (r *Replica) GetReplicaDescriptor() (roachpb.ReplicaDescriptor, error)

+ func (r *Replica) GetSnapshot(ctx context.Context, snapType string) (*OutgoingSnapshot, error)

+ func (r *Replica) GetTempPrefix() string

+ func (r *Replica) InitialState() (raftpb.HardState, raftpb.ConfState, error)

+ func (r *Replica) IsDestroyed() error

+ func (r *Replica) IsFirstRange() bool

+ func (r *Replica) IsInitialized() bool

+ func (r *Replica) IsLeaseValid(lease *roachpb.Lease, ts hlc.Timestamp) bool

+ func (r *Replica) LastIndex() (uint64, error)

+ func (r *Replica) Less(i btree.Item) bool

+ func (r *Replica) Metrics(ctx context.Context, now hlc.Timestamp, cfg config.SystemConfig, ...) ReplicaMetrics

+ func (r *Replica) NodeID() roachpb.NodeID

+ func (r *Replica) RaftStatus() *raft.Status

+ func (r *Replica) Send(ctx context.Context, ba roachpb.BatchRequest) (*roachpb.BatchResponse, *roachpb.Error)

+ func (r *Replica) SetMaxBytes(maxBytes int64)

+ func (r *Replica) Snapshot() (raftpb.Snapshot, error)

+ func (r *Replica) State() storagebase.RangeInfo

+ func (r *Replica) String() string

+ func (r *Replica) Term(i uint64) (uint64, error)

+ type ReplicaDataIterator struct

+ func NewReplicaDataIterator(d *roachpb.RangeDescriptor, e engine.Reader, replicatedOnly bool) *ReplicaDataIterator

+ func (ri *ReplicaDataIterator) Close()

+ func (ri *ReplicaDataIterator) Key() engine.MVCCKey

+ func (ri *ReplicaDataIterator) Next()

+ func (ri *ReplicaDataIterator) Valid() (bool, error)

+ func (ri *ReplicaDataIterator) Value() []byte

+ type ReplicaEvalContext struct

+ func (rec ReplicaEvalContext) AbortCache() *AbortCache

+ func (rec ReplicaEvalContext) ContainsKey(key roachpb.Key) (bool, error)

+ func (rec ReplicaEvalContext) DB() *client.DB

+ func (rec ReplicaEvalContext) Desc() (*roachpb.RangeDescriptor, error)

+ func (rec ReplicaEvalContext) Engine() engine.Engine

+ func (rec ReplicaEvalContext) FirstIndex() (uint64, error)

+ func (rec ReplicaEvalContext) GCThreshold() (hlc.Timestamp, error)

+ func (rec ReplicaEvalContext) GetLastReplicaGCTimestamp(ctx context.Context) (hlc.Timestamp, error)

+ func (rec ReplicaEvalContext) GetLease() (*roachpb.Lease, *roachpb.Lease, error)

+ func (rec ReplicaEvalContext) GetMVCCStats() (enginepb.MVCCStats, error)

+ func (rec ReplicaEvalContext) GetTempPrefix() string

+ func (rec ReplicaEvalContext) IsFirstRange() bool

+ func (rec ReplicaEvalContext) NodeID() roachpb.NodeID

+ func (rec ReplicaEvalContext) RangeID() roachpb.RangeID

+ func (rec ReplicaEvalContext) StoreID() roachpb.StoreID

+ func (rec ReplicaEvalContext) StoreTestingKnobs() StoreTestingKnobs

+ func (rec ReplicaEvalContext) String() string

+ func (rec ReplicaEvalContext) Term(i uint64) (uint64, error)

+ func (rec ReplicaEvalContext) Tracer() opentracing.Tracer

+ func (rec ReplicaEvalContext) TxnSpanGCThreshold() (hlc.Timestamp, error)

+ type ReplicaGCQueueMetrics struct

+ RemoveReplicaCount *metric.Counter

+ type ReplicaMetrics struct

+ BehindCount int64

+ Leader bool

+ LeaseType roachpb.LeaseType

+ LeaseValid bool

+ Leaseholder bool

+ Quiescent bool

+ RangeCounter bool

+ SelfBehindCount int64

+ Unavailable bool

+ Underreplicated bool

+ type ReplicaPlaceholder struct

+ func (r *ReplicaPlaceholder) Desc() *roachpb.RangeDescriptor

+ func (r *ReplicaPlaceholder) Less(i btree.Item) bool

+ func (r *ReplicaPlaceholder) String() string

+ type ReplicaSnapshotDiff struct

+ Key roachpb.Key

+ LeaseHolder bool

+ Timestamp hlc.Timestamp

+ Value []byte

+ type ReplicaSnapshotDiffSlice []ReplicaSnapshotDiff

+ func (rsds ReplicaSnapshotDiffSlice) String() string

+ func (rsds ReplicaSnapshotDiffSlice) WriteTo(w io.Writer) (int64, error)

+ type ReplicateQueueMetrics struct

+ AddReplicaCount *metric.Counter

+ RebalanceReplicaCount *metric.Counter

+ RemoveDeadReplicaCount *metric.Counter

+ RemoveReplicaCount *metric.Counter

+ TransferLeaseCount *metric.Counter

+ type Server struct

+ func MakeServer(descriptor *roachpb.NodeDescriptor, stores *Stores) Server

+ func (is Server) CollectChecksum(ctx context.Context, req *CollectChecksumRequest) (*CollectChecksumResponse, error)

+ type SnapshotRequest struct

+ Final bool

+ Header *SnapshotRequest_Header

+ KVBatch []byte

+ LogEntries [][]byte

+ func (*SnapshotRequest) Descriptor() ([]byte, []int)

+ func (*SnapshotRequest) ProtoMessage()

+ func (m *SnapshotRequest) Marshal() (dAtA []byte, err error)

+ func (m *SnapshotRequest) MarshalTo(dAtA []byte) (int, error)

+ func (m *SnapshotRequest) Reset()

+ func (m *SnapshotRequest) Size() (n int)

+ func (m *SnapshotRequest) String() string

+ func (m *SnapshotRequest) Unmarshal(dAtA []byte) error

+ type SnapshotRequest_Header struct

+ CanDecline bool

+ Priority SnapshotRequest_Priority

+ RaftMessageRequest RaftMessageRequest

+ RangeSize int64

+ State cockroach_storage_storagebase.ReplicaState

+ func (*SnapshotRequest_Header) Descriptor() ([]byte, []int)

+ func (*SnapshotRequest_Header) ProtoMessage()

+ func (m *SnapshotRequest_Header) Marshal() (dAtA []byte, err error)

+ func (m *SnapshotRequest_Header) MarshalTo(dAtA []byte) (int, error)

+ func (m *SnapshotRequest_Header) Reset()

+ func (m *SnapshotRequest_Header) Size() (n int)

+ func (m *SnapshotRequest_Header) String() string

+ func (m *SnapshotRequest_Header) Unmarshal(dAtA []byte) error

+ type SnapshotRequest_Priority int32

+ const SnapshotRequest_REBALANCE

+ const SnapshotRequest_RECOVERY

+ const SnapshotRequest_UNKNOWN

+ func (SnapshotRequest_Priority) EnumDescriptor() ([]byte, []int)

+ func (x *SnapshotRequest_Priority) UnmarshalJSON(data []byte) error

+ func (x SnapshotRequest_Priority) Enum() *SnapshotRequest_Priority

+ func (x SnapshotRequest_Priority) String() string

+ type SnapshotResponse struct

+ Message string

+ Status SnapshotResponse_Status

+ func (*SnapshotResponse) Descriptor() ([]byte, []int)

+ func (*SnapshotResponse) ProtoMessage()

+ func (m *SnapshotResponse) Marshal() (dAtA []byte, err error)

+ func (m *SnapshotResponse) MarshalTo(dAtA []byte) (int, error)

+ func (m *SnapshotResponse) Reset()

+ func (m *SnapshotResponse) Size() (n int)

+ func (m *SnapshotResponse) String() string

+ func (m *SnapshotResponse) Unmarshal(dAtA []byte) error

+ type SnapshotResponseStream interface

+ Context func() context.Context

+ Recv func() (*SnapshotRequest, error)

+ Send func(*SnapshotResponse) error

+ type SnapshotResponse_Status int32

+ const SnapshotResponse_ACCEPTED

+ const SnapshotResponse_APPLIED

+ const SnapshotResponse_DECLINED

+ const SnapshotResponse_ERROR

+ const SnapshotResponse_UNKNOWN

+ func (SnapshotResponse_Status) EnumDescriptor() ([]byte, []int)

+ func (x *SnapshotResponse_Status) UnmarshalJSON(data []byte) error

+ func (x SnapshotResponse_Status) Enum() *SnapshotResponse_Status

+ func (x SnapshotResponse_Status) String() string

+ type SnapshotStorePool interface

+ type SpanAccess int

+ const SpanReadOnly

+ const SpanReadWrite

+ type SpanSet struct

+ func (ss *SpanSet) Add(access SpanAccess, span roachpb.Span)

+ type SpanSetIterator struct

+ func (s *SpanSetIterator) Close()

+ func (s *SpanSetIterator) ComputeStats(start, end engine.MVCCKey, nowNanos int64) (enginepb.MVCCStats, error)

+ func (s *SpanSetIterator) Iterator() engine.Iterator

+ func (s *SpanSetIterator) Key() engine.MVCCKey

+ func (s *SpanSetIterator) Less(key engine.MVCCKey) bool

+ func (s *SpanSetIterator) Next()

+ func (s *SpanSetIterator) NextKey()

+ func (s *SpanSetIterator) Prev()

+ func (s *SpanSetIterator) PrevKey()

+ func (s *SpanSetIterator) Seek(key engine.MVCCKey)

+ func (s *SpanSetIterator) SeekReverse(key engine.MVCCKey)

+ func (s *SpanSetIterator) UnsafeKey() engine.MVCCKey

+ func (s *SpanSetIterator) UnsafeValue() []byte

+ func (s *SpanSetIterator) Valid() (bool, error)

+ func (s *SpanSetIterator) Value() []byte

+ func (s *SpanSetIterator) ValueProto(msg proto.Message) error

+ type Store struct

+ Ident roachpb.StoreIdent

+ func NewStore(cfg StoreConfig, eng engine.Engine, nodeDesc *roachpb.NodeDescriptor) *Store

+ func (s *Store) AnnotateCtx(ctx context.Context) context.Context

+ func (s *Store) Attrs() roachpb.Attributes

+ func (s *Store) Bootstrap(ident roachpb.StoreIdent) error

+ func (s *Store) BootstrapRange(initialValues []roachpb.KeyValue) error

+ func (s *Store) Capacity() (roachpb.StoreCapacity, error)

+ func (s *Store) Clock() *hlc.Clock

+ func (s *Store) ClusterID() uuid.UUID

+ func (s *Store) ComputeMetrics(ctx context.Context, tick int) error

+ func (s *Store) ComputeStatsForKeySpan(startKey, endKey roachpb.RKey) (enginepb.MVCCStats, int)

+ func (s *Store) DB() *client.DB

+ func (s *Store) Descriptor() (*roachpb.StoreDescriptor, error)

+ func (s *Store) Engine() engine.Engine

+ func (s *Store) GetReplica(rangeID roachpb.RangeID) (*Replica, error)

+ func (s *Store) GetTempPrefix() string

+ func (s *Store) Gossip() *gossip.Gossip

+ func (s *Store) GossipDeadReplicas(ctx context.Context) error

+ func (s *Store) GossipStore(ctx context.Context) error

+ func (s *Store) HandleRaftRequest(ctx context.Context, req *RaftMessageRequest, ...) *roachpb.Error

+ func (s *Store) HandleRaftResponse(ctx context.Context, resp *RaftMessageResponse) error

+ func (s *Store) HandleRaftUncoalescedRequest(ctx context.Context, req *RaftMessageRequest, ...) *roachpb.Error

+ func (s *Store) HandleSnapshot(header *SnapshotRequest_Header, stream SnapshotResponseStream) error

+ func (s *Store) IsDraining() bool

+ func (s *Store) IsStarted() bool

+ func (s *Store) LeaseCount() int

+ func (s *Store) LookupReplica(start, end roachpb.RKey) *Replica

+ func (s *Store) MVCCStats() enginepb.MVCCStats

+ func (s *Store) MergeRange(ctx context.Context, subsumingRng *Replica, updatedEndKey roachpb.RKey, ...) error

+ func (s *Store) Metrics() *StoreMetrics

+ func (s *Store) NewRangeDescriptor(start, end roachpb.RKey, replicas []roachpb.ReplicaDescriptor) (*roachpb.RangeDescriptor, error)

+ func (s *Store) NewSnapshot() engine.Reader

+ func (s *Store) NotifyBootstrapped()

+ func (s *Store) RaftStatus(rangeID roachpb.RangeID) *raft.Status

+ func (s *Store) ReadLastUpTimestamp(ctx context.Context) (hlc.Timestamp, error)

+ func (s *Store) Registry() *metric.Registry

+ func (s *Store) RemoveReplica(ctx context.Context, rep *Replica, consistentDesc roachpb.RangeDescriptor, ...) error

+ func (s *Store) ReplicaCount() int

+ func (s *Store) Send(ctx context.Context, ba roachpb.BatchRequest) (br *roachpb.BatchResponse, pErr *roachpb.Error)

+ func (s *Store) SetDraining(drain bool)

+ func (s *Store) SplitRange(ctx context.Context, origRng, newRng *Replica) error

+ func (s *Store) Start(ctx context.Context, stopper *stop.Stopper) error

+ func (s *Store) Stopper() *stop.Stopper

+ func (s *Store) StoreID() roachpb.StoreID

+ func (s *Store) String() string

+ func (s *Store) TestingKnobs() *StoreTestingKnobs

+ func (s *Store) Tracer() opentracing.Tracer

+ func (s *Store) WaitForInit()

+ func (s *Store) WriteLastUpTimestamp(ctx context.Context, time hlc.Timestamp) error

+ type StoreConfig struct

+ AmbientCtx log.AmbientContext

+ Clock *hlc.Clock

+ CoalescedHeartbeatsInterval time.Duration

+ ConsistencyCheckInterval time.Duration

+ ConsistencyCheckPanicOnFailure bool

+ DB *client.DB

+ DontRetryPushTxnFailures bool

+ EnableEpochRangeLeases bool

+ Gossip *gossip.Gossip

+ GossipWhenCapacityDeltaExceedsFraction float64

+ HistogramWindowInterval time.Duration

+ LogRangeEvents bool

+ MetricsSampleInterval time.Duration

+ NodeLiveness *NodeLiveness

+ RPCContext *rpc.Context

+ RaftElectionTimeoutTicks int

+ RaftEntryCacheSize uint64

+ RaftHeartbeatIntervalTicks int

+ RaftTickInterval time.Duration

+ RangeLeaseActiveDuration time.Duration

+ RangeLeaseRenewalDuration time.Duration

+ RangeRetryOptions retry.Options

+ SQLExecutor sqlutil.InternalExecutor

+ ScanInterval time.Duration

+ ScanMaxIdleTime time.Duration

+ StorePool *StorePool

+ TestingKnobs StoreTestingKnobs

+ TimeSeriesDataStore TimeSeriesDataStore

+ Transport *RaftTransport

+ func TestStoreConfig(clock *hlc.Clock) StoreConfig

+ func (sc *StoreConfig) LeaseExpiration() int64

+ func (sc *StoreConfig) SetDefaults()

+ func (sc *StoreConfig) Valid() bool

+ type StoreList struct

+ func (sl StoreList) String() string

+ type StoreMetrics struct

+ Available *metric.Gauge

+ Capacity *metric.Gauge

+ CombinedCommandQueueSize *metric.Gauge

+ CombinedCommandReadCount *metric.Gauge

+ CombinedCommandWriteCount *metric.Gauge

+ ConsistencyQueueFailures *metric.Counter

+ ConsistencyQueuePending *metric.Gauge

+ ConsistencyQueueProcessingNanos *metric.Counter

+ ConsistencyQueueSuccesses *metric.Counter

+ GCAbortSpanConsidered *metric.Counter

+ GCAbortSpanGCNum *metric.Counter

+ GCAbortSpanScanned *metric.Counter

+ GCIntentTxns *metric.Counter

+ GCIntentsConsidered *metric.Counter

+ GCNumKeysAffected *metric.Counter

+ GCPushTxn *metric.Counter

+ GCQueueFailures *metric.Counter

+ GCQueuePending *metric.Gauge

+ GCQueueProcessingNanos *metric.Counter

+ GCQueueSuccesses *metric.Counter

+ GCResolveSuccess *metric.Counter

+ GCResolveTotal *metric.Counter

+ GCTransactionSpanGCAborted *metric.Counter

+ GCTransactionSpanGCCommitted *metric.Counter

+ GCTransactionSpanGCPending *metric.Counter

+ GCTransactionSpanScanned *metric.Counter

+ GcBytesAge *metric.Gauge

+ IntentAge *metric.Gauge

+ IntentBytes *metric.Gauge

+ IntentCount *metric.Gauge

+ KeyBytes *metric.Gauge

+ KeyCount *metric.Gauge

+ LastUpdateNanos *metric.Gauge

+ LeaseEpochCount *metric.Gauge

+ LeaseExpirationCount *metric.Gauge

+ LeaseHolderCount *metric.Gauge

+ LeaseRequestErrorCount *metric.Counter

+ LeaseRequestSuccessCount *metric.Counter

+ LeaseTransferErrorCount *metric.Counter

+ LeaseTransferSuccessCount *metric.Counter

+ LiveBytes *metric.Gauge

+ LiveCount *metric.Gauge

+ MaxCommandQueueOverlaps *metric.Gauge

+ MaxCommandQueueReadCount *metric.Gauge

+ MaxCommandQueueSize *metric.Gauge

+ MaxCommandQueueTreeSize *metric.Gauge

+ MaxCommandQueueWriteCount *metric.Gauge

+ QuiescentCount *metric.Gauge

+ RaftCoalescedHeartbeatsPending *metric.Gauge

+ RaftCommandCommitLatency *metric.Histogram

+ RaftCommandsApplied *metric.Counter

+ RaftEnqueuedPending *metric.Gauge

+ RaftLeaderCount *metric.Gauge

+ RaftLeaderNotLeaseHolderCount *metric.Gauge

+ RaftLogCommitLatency *metric.Histogram

+ RaftLogFollowerBehindCount *metric.Gauge

+ RaftLogQueueFailures *metric.Counter

+ RaftLogQueuePending *metric.Gauge

+ RaftLogQueueProcessingNanos *metric.Counter

+ RaftLogQueueSuccesses *metric.Counter

+ RaftLogSelfBehindCount *metric.Gauge

+ RaftLogTruncated *metric.Counter

+ RaftRcvdMsgApp *metric.Counter

+ RaftRcvdMsgAppResp *metric.Counter

+ RaftRcvdMsgDropped *metric.Counter

+ RaftRcvdMsgHeartbeat *metric.Counter

+ RaftRcvdMsgHeartbeatResp *metric.Counter

+ RaftRcvdMsgPreVote *metric.Counter

+ RaftRcvdMsgPreVoteResp *metric.Counter

+ RaftRcvdMsgProp *metric.Counter

+ RaftRcvdMsgSnap *metric.Counter

+ RaftRcvdMsgTimeoutNow *metric.Counter

+ RaftRcvdMsgTransferLeader *metric.Counter

+ RaftRcvdMsgVote *metric.Counter

+ RaftRcvdMsgVoteResp *metric.Counter

+ RaftSnapshotQueueFailures *metric.Counter

+ RaftSnapshotQueuePending *metric.Gauge

+ RaftSnapshotQueueProcessingNanos *metric.Counter

+ RaftSnapshotQueueSuccesses *metric.Counter

+ RaftTickingDurationNanos *metric.Counter

+ RaftTicks *metric.Counter

+ RaftWorkingDurationNanos *metric.Counter

+ RangeAdds *metric.Counter

+ RangeCount *metric.Gauge

+ RangeRaftLeaderTransfers *metric.Counter

+ RangeRemoves *metric.Counter

+ RangeSnapshotsGenerated *metric.Counter

+ RangeSnapshotsNormalApplied *metric.Counter

+ RangeSnapshotsPreemptiveApplied *metric.Counter

+ RangeSplits *metric.Counter

+ RdbBlockCacheHits *metric.Gauge

+ RdbBlockCacheMisses *metric.Gauge

+ RdbBlockCachePinnedUsage *metric.Gauge

+ RdbBlockCacheUsage *metric.Gauge

+ RdbBloomFilterPrefixChecked *metric.Gauge

+ RdbBloomFilterPrefixUseful *metric.Gauge

+ RdbCompactions *metric.Gauge

+ RdbFlushes *metric.Gauge

+ RdbMemtableHits *metric.Gauge

+ RdbMemtableMisses *metric.Gauge

+ RdbMemtableTotalSize *metric.Gauge

+ RdbNumSSTables *metric.Gauge

+ RdbReadAmplification *metric.Gauge

+ RdbTableReadersMemEstimate *metric.Gauge

+ ReplicaCount *metric.Counter

+ ReplicaGCQueueFailures *metric.Counter

+ ReplicaGCQueuePending *metric.Gauge

+ ReplicaGCQueueProcessingNanos *metric.Counter

+ ReplicaGCQueueSuccesses *metric.Counter

+ ReplicateQueueFailures *metric.Counter

+ ReplicateQueuePending *metric.Gauge

+ ReplicateQueueProcessingNanos *metric.Counter

+ ReplicateQueuePurgatory *metric.Gauge

+ ReplicateQueueSuccesses *metric.Counter

+ Reserved *metric.Counter

+ ReservedReplicaCount *metric.Counter

+ SlowCommandQueueRequests *metric.Gauge

+ SlowLeaseRequests *metric.Gauge

+ SlowRaftRequests *metric.Gauge

+ SplitQueueFailures *metric.Counter

+ SplitQueuePending *metric.Gauge

+ SplitQueueProcessingNanos *metric.Counter

+ SplitQueueSuccesses *metric.Counter

+ SysBytes *metric.Gauge

+ SysCount *metric.Gauge

+ TimeSeriesMaintenanceQueueFailures *metric.Counter

+ TimeSeriesMaintenanceQueuePending *metric.Gauge

+ TimeSeriesMaintenanceQueueProcessingNanos *metric.Counter

+ TimeSeriesMaintenanceQueueSuccesses *metric.Counter

+ UnavailableRangeCount *metric.Gauge

+ UnderReplicatedRangeCount *metric.Gauge

+ ValBytes *metric.Gauge

+ ValCount *metric.Gauge

+ type StorePool struct

+ func NewStorePool(ambient log.AmbientContext, g *gossip.Gossip, clock *hlc.Clock, ...) *StorePool

+ func (sp *StorePool) GetStores() []roachpb.ReplicationTarget

+ func (sp *StorePool) String() string

+ type StoreRequestHeader struct

+ NodeID github_com_cockroachdb_cockroach_pkg_roachpb.NodeID

+ StoreID github_com_cockroachdb_cockroach_pkg_roachpb.StoreID

+ func (*StoreRequestHeader) Descriptor() ([]byte, []int)

+ func (*StoreRequestHeader) ProtoMessage()

+ func (m *StoreRequestHeader) Marshal() (dAtA []byte, err error)

+ func (m *StoreRequestHeader) MarshalTo(dAtA []byte) (int, error)

+ func (m *StoreRequestHeader) Reset()

+ func (m *StoreRequestHeader) Size() (n int)

+ func (m *StoreRequestHeader) String() string

+ func (m *StoreRequestHeader) Unmarshal(dAtA []byte) error

+ type StoreTestingKnobs struct

+ BadChecksumPanic func(roachpb.StoreIdent)

+ BadChecksumReportDiff func(roachpb.StoreIdent, []ReplicaSnapshotDiff)

+ ClockBeforeSend func(*hlc.Clock, roachpb.BatchRequest)

+ DisableAsyncIntentResolution bool

+ DisableLastProcessedCheck bool

+ DisableMaxOffsetCheck bool

+ DisableOnePhaseCommits bool

+ DisablePeriodicGossips bool

+ DisableProcessRaft bool

+ DisableRefreshReasonNewLeader bool

+ DisableRefreshReasonSnapshotApplied bool

+ DisableRefreshReasonTicks bool

+ DisableReplicaGCQueue bool

+ DisableReplicateQueue bool

+ DisableScanner bool

+ DisableSplitQueue bool

+ DisableTimeSeriesMaintenanceQueue bool

+ DontPreventUseOfOldLeaseOnStart bool

+ LeaseRequestEvent func(ts hlc.Timestamp)

+ LeaseTransferBlockedOnExtensionEvent func(nextLeader roachpb.ReplicaDescriptor)

+ MaxOffset time.Duration

+ NumKeysEvaluatedForRangeIntentResolution *int64

+ OnCampaign func(*Replica)

+ ReplicateQueueAcceptsUnsplit bool

+ SkipMinSizeCheck bool

+ TestingApplyFilter storagebase.ReplicaApplyFilter

+ TestingEvalFilter storagebase.ReplicaCommandFilter

+ TestingPostApplyFilter storagebase.ReplicaApplyFilter

+ TestingResponseFilter storagebase.ReplicaResponseFilter

+ func (*StoreTestingKnobs) ModuleTestingKnobs()

+ type Stores struct

+ func NewStores(ambient log.AmbientContext, clock *hlc.Clock) *Stores

+ func (ls *Stores) AddStore(s *Store)

+ func (ls *Stores) FirstRange() (*roachpb.RangeDescriptor, error)

+ func (ls *Stores) GetStore(storeID roachpb.StoreID) (*Store, error)

+ func (ls *Stores) GetStoreCount() int

+ func (ls *Stores) HasStore(storeID roachpb.StoreID) bool

+ func (ls *Stores) LookupReplica(start, end roachpb.RKey) (roachpb.RangeID, roachpb.ReplicaDescriptor, error)

+ func (ls *Stores) ReadBootstrapInfo(bi *gossip.BootstrapInfo) error

+ func (ls *Stores) RemoveStore(s *Store)

+ func (ls *Stores) Send(ctx context.Context, ba roachpb.BatchRequest) (*roachpb.BatchResponse, *roachpb.Error)

+ func (ls *Stores) VisitStores(visitor func(s *Store) error) error

+ func (ls *Stores) WriteBootstrapInfo(bi *gossip.BootstrapInfo) error

+ type TimeSeriesDataStore interface

+ ContainsTimeSeries func(roachpb.RKey, roachpb.RKey) bool

+ PruneTimeSeries func(context.Context, engine.Reader, roachpb.RKey, roachpb.RKey, *client.DB, ...) error

Incompatible versions in this module

v19.2.12+incompatible

Jan 12, 2021

v19.2.6+incompatible

Apr 3, 2020

v19.2.4+incompatible

Feb 6, 2020

v19.2.0+incompatible

Nov 8, 2019

v19.2.0-rc.2+incompatible

Oct 23, 2019

v19.2.0-alpha.20190805+incompatible

Aug 1, 2019

v19.1.3+incompatible

Jul 4, 2019

v19.1.0-beta.20190304+incompatible

Feb 27, 2019

v2.0.0+incompatible

Apr 3, 2018

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL