storage

package

Go to main page

Versions in this module

v1

v1.1.7

Mar 20, 2018

v1.1.6

Mar 2, 2018

v1.1.5

Jan 29, 2018

v1.1.4

Jan 1, 2018

Changes in this version

type StoreTestingKnobs

+ DisableRaftSnapshotQueue bool

v1.1.3

Nov 21, 2017

v1.1.2

Oct 26, 2017

Changes in this version

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

type SpanSet

+ func (ss *SpanSet) String() string

v1.1.1

Oct 16, 2017

v1.1.0

Oct 4, 2017

Changes in this version

+ const MaxCommandSizeFloor

+ const MinStatsDuration

+ const RaftLogQueueStaleSize

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

+ 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 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

+ 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.7

Feb 11, 2018

v1.0.6

Sep 9, 2017

v1.0.5

Aug 17, 2017

v1.0.4

Jul 20, 2017

v1.0.3

Jul 6, 2017

v1.0.2

Jun 7, 2017

v1.0.1

May 18, 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

v2.1.0-alpha.20180416+incompatible

Apr 10, 2018

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