Back to godoc.org

Package storage

v1.1.8
Latest Go to latest

The latest major version is .

Published: Apr 19, 2018 | License: Apache-2.0 | Module: github.com/cockroachdb/cockroach

Overview

Package storage is a generated protocol buffer package.

It is generated from these files:
	cockroach/pkg/storage/api.proto
	cockroach/pkg/storage/lease_status.proto
	cockroach/pkg/storage/liveness.proto
	cockroach/pkg/storage/log.proto
	cockroach/pkg/storage/raft.proto

It has these top-level messages:
	StoreRequestHeader
	CollectChecksumRequest
	CollectChecksumResponse
	LeaseStatus
	Liveness
	RangeLogEvent
	RaftHeartbeat
	RaftMessageRequest
	RaftMessageRequestBatch
	RaftMessageResponseUnion
	RaftMessageResponse
	SnapshotRequest
	SnapshotResponse
	ConfChangeContext

Package storage provides access to the Store and Range abstractions. Each Cockroach node handles one or more stores, each of which multiplexes to one or more ranges, identified by [start, end) keys. Ranges are contiguous regions of the keyspace. Each range implements an instance of the Raft consensus algorithm to synchronize participating range replicas.

Each store is represented by a single engine.Engine instance. The ranges hosted by a store all have access to the same engine, but write to only a range-limited keyspace within it. Ranges access the underlying engine via the MVCC interface, which provides historical versioned values.

Example (Rebalancing)

Code:

stopper := stop.NewStopper()
defer stopper.Stop(context.TODO())

st := cluster.MakeTestingClusterSettings()
EnableStatsBasedRebalancing.Override(&st.SV, false)

clock := hlc.NewClock(hlc.UnixNano, time.Nanosecond)

// Model a set of stores in a cluster,
// randomly adding / removing stores and adding bytes.
rpcContext := rpc.NewContext(
	log.AmbientContext{Tracer: st.Tracer},
	&base.Config{Insecure: true},
	clock,
	stopper,
)
server := rpc.NewServer(rpcContext) // never started
g := gossip.NewTest(1, rpcContext, server, stopper, metric.NewRegistry())

TimeUntilStoreDead.Override(&st.SV, TestTimeUntilStoreDeadOff)
// Deterministic must be set as this test is comparing the exact output
// after each rebalance.
sp := NewStorePool(
	log.AmbientContext{Tracer: st.Tracer},
	st,
	g,
	clock,
	newMockNodeLiveness(nodeStatusLive).nodeLivenessFunc,
	/* deterministic */ true,
)
alloc := MakeAllocator(sp, func(string) (time.Duration, bool) {
	return 0, false
})

var wg sync.WaitGroup
g.RegisterCallback(gossip.MakePrefixPattern(gossip.KeyStorePrefix), func(_ string, _ roachpb.Value) { wg.Done() })

const generations = 100
const nodes = 20
const printGenerations = generations / 2

// Initialize testStores.
var testStores [nodes]testStore
for i := 0; i < len(testStores); i++ {
	testStores[i].StoreID = roachpb.StoreID(i)
	testStores[i].Node = roachpb.NodeDescriptor{NodeID: roachpb.NodeID(i)}
	testStores[i].Capacity = roachpb.StoreCapacity{Capacity: 1 << 30, Available: 1 << 30}
}
// Initialize the cluster with a single range.
testStores[0].add(alloc.randGen.Int63n(1 << 20))

table := tablewriter.NewWriter(os.Stdout)
table.SetAutoFormatHeaders(false)
table.SetAlignment(tablewriter.ALIGN_RIGHT)

header := make([]string, len(testStores)+1)
header[0] = "gen"
for i := 0; i < len(testStores); i++ {
	header[i+1] = fmt.Sprintf("store %d", i)
}
table.SetHeader(header)

for i := 0; i < generations; i++ {
	// First loop through test stores and add data.
	wg.Add(len(testStores))
	for j := 0; j < len(testStores); j++ {
		// Add a pretend range to the testStore if there's already one.
		if testStores[j].Capacity.RangeCount > 0 {
			testStores[j].add(alloc.randGen.Int63n(1 << 20))
		}
		if err := g.AddInfoProto(gossip.MakeStoreKey(roachpb.StoreID(j)), &testStores[j].StoreDescriptor, 0); err != nil {
			panic(err)
		}
	}
	wg.Wait()

	// Next loop through test stores and maybe rebalance.
	for j := 0; j < len(testStores); j++ {
		ts := &testStores[j]
		target, _ := alloc.RebalanceTarget(
			context.Background(),
			config.Constraints{},
			nil,
			testRangeInfo([]roachpb.ReplicaDescriptor{{NodeID: ts.Node.NodeID, StoreID: ts.StoreID}}, firstRange),
			storeFilterThrottled,
		)
		if target != nil {
			log.Infof(context.TODO(), "rebalancing to %+v", target)
			testStores[j].rebalance(&testStores[int(target.StoreID)], alloc.randGen.Int63n(1<<20))
		}
	}

	if i%(generations/printGenerations) == 0 {
		var totalBytes int64
		for j := 0; j < len(testStores); j++ {
			totalBytes += testStores[j].Capacity.Capacity - testStores[j].Capacity.Available
		}
		row := make([]string, len(testStores)+1)
		row[0] = fmt.Sprintf("%d", i)
		for j := 0; j < len(testStores); j++ {
			ts := testStores[j]
			bytes := ts.Capacity.Capacity - ts.Capacity.Available
			row[j+1] = fmt.Sprintf("%3d %3d%%", ts.Capacity.RangeCount, (100*bytes)/totalBytes)
		}
		table.Append(row)
	}
}

var totBytes int64
var totRanges int32
for i := 0; i < len(testStores); i++ {
	totBytes += testStores[i].Capacity.Capacity - testStores[i].Capacity.Available
	totRanges += testStores[i].Capacity.RangeCount
}
table.Render()
fmt.Printf("Total bytes=%d, ranges=%d\n", totBytes, totRanges)
+-----+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+
| gen | store 0  | store 1  | store 2  | store 3  | store 4  | store 5  | store 6  | store 7  | store 8  | store 9  | store 10 | store 11 | store 12 | store 13 | store 14 | store 15 | store 16 | store 17 | store 18 | store 19 |
+-----+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+
|   0 |   2 100% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |
|   2 |   4 100% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |
|   4 |   6 100% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |
|   6 |   8 100% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |
|   8 |  10 100% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |
|  10 |  10  68% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   1   2% |   0   0% |   0   0% |   1  11% |   0   0% |   1  18% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |   0   0% |
|  12 |  10  21% |   1  10% |   0   0% |   1   1% |   1   3% |   1   5% |   2   7% |   1   9% |   1   7% |   0   0% |   0   0% |   1   7% |   1   5% |   1  10% |   0   0% |   1   2% |   1   4% |   1   4% |   0   0% |   1   0% |
|  14 |  10   8% |   2   5% |   3   5% |   2   1% |   2   3% |   2   4% |   2   4% |   2   5% |   2   7% |   2   5% |   2   4% |   2   7% |   2   7% |   2   5% |   8  10% |   2   0% |   2   2% |   2   4% |   3   4% |   2   0% |
|  16 |  10   5% |   4   4% |   5   4% |   4   1% |   5   6% |   4   5% |   4   4% |   4   4% |   5   7% |   4   4% |   4   4% |   5   9% |   4   5% |   4   5% |   8   4% |   4   2% |   4   4% |   4   5% |   5   3% |   5   5% |
|  18 |  10   2% |   7   6% |   7   4% |   6   2% |   7   5% |   6   5% |   6   4% |   7   6% |   7   6% |   7   5% |   6   5% |   7   7% |   6   4% |   6   5% |   8   3% |   6   2% |   7   5% |   6   5% |   7   3% |   7   6% |
|  20 |  10   0% |   9   5% |   9   5% |   8   3% |   9   5% |   9   6% |   8   4% |   9   6% |   9   6% |   9   6% |   8   4% |   9   7% |   9   5% |   8   5% |  10   2% |   8   3% |   9   4% |   8   5% |   9   3% |   9   6% |
|  22 |  12   1% |  11   4% |  11   5% |  10   3% |  11   5% |  11   5% |  10   4% |  11   6% |  11   6% |  11   6% |  10   4% |  11   6% |  11   6% |  10   5% |  12   2% |  10   3% |  11   4% |  10   5% |  11   4% |  11   6% |
|  24 |  14   1% |  13   4% |  13   6% |  12   3% |  13   5% |  13   5% |  12   3% |  13   6% |  13   6% |  13   6% |  12   4% |  13   6% |  13   6% |  12   5% |  14   3% |  12   3% |  13   4% |  12   5% |  13   3% |  13   6% |
|  26 |  16   2% |  15   4% |  15   6% |  14   3% |  15   4% |  15   5% |  14   3% |  15   6% |  15   5% |  15   7% |  14   4% |  15   6% |  15   6% |  14   4% |  16   4% |  14   3% |  15   4% |  14   5% |  15   4% |  15   5% |
|  28 |  18   2% |  17   4% |  17   6% |  16   3% |  17   5% |  17   5% |  16   3% |  17   5% |  17   5% |  17   7% |  16   4% |  17   5% |  17   6% |  16   4% |  18   4% |  16   3% |  17   5% |  16   5% |  17   4% |  17   5% |
|  30 |  20   2% |  19   4% |  19   5% |  18   3% |  19   5% |  19   5% |  18   3% |  19   5% |  19   5% |  19   6% |  18   4% |  19   5% |  19   6% |  18   4% |  20   4% |  18   3% |  19   4% |  18   5% |  19   4% |  19   5% |
|  32 |  22   2% |  21   5% |  21   5% |  20   3% |  21   5% |  21   5% |  20   3% |  21   5% |  21   5% |  21   6% |  20   4% |  21   6% |  21   6% |  20   4% |  22   4% |  20   3% |  21   4% |  20   5% |  21   4% |  21   5% |
|  34 |  24   3% |  23   5% |  23   5% |  22   3% |  23   5% |  23   5% |  22   3% |  23   5% |  23   5% |  23   5% |  22   4% |  23   6% |  23   6% |  22   4% |  24   4% |  22   3% |  23   4% |  22   5% |  23   4% |  23   6% |
|  36 |  26   3% |  25   5% |  25   5% |  24   3% |  25   5% |  25   5% |  24   3% |  25   5% |  25   5% |  25   5% |  24   4% |  25   6% |  25   6% |  24   4% |  26   4% |  24   4% |  25   4% |  24   5% |  25   4% |  25   6% |
|  38 |  28   3% |  27   5% |  27   4% |  26   4% |  27   5% |  27   5% |  26   3% |  27   4% |  27   5% |  27   5% |  26   4% |  27   6% |  27   6% |  26   4% |  28   3% |  26   4% |  27   5% |  26   5% |  27   4% |  27   6% |
|  40 |  30   3% |  29   5% |  29   4% |  28   4% |  29   5% |  29   6% |  28   4% |  29   4% |  29   5% |  29   5% |  28   4% |  29   6% |  29   6% |  28   4% |  30   3% |  28   4% |  29   5% |  28   5% |  29   4% |  29   6% |
|  42 |  32   3% |  31   5% |  31   4% |  30   4% |  31   5% |  31   5% |  30   4% |  31   4% |  31   4% |  31   5% |  30   4% |  31   5% |  31   5% |  30   4% |  32   3% |  30   4% |  31   4% |  30   5% |  31   4% |  31   6% |
|  44 |  34   4% |  33   5% |  33   4% |  32   4% |  33   5% |  33   6% |  32   4% |  33   4% |  33   4% |  33   5% |  32   4% |  33   5% |  33   6% |  32   4% |  34   3% |  32   4% |  33   4% |  32   5% |  33   4% |  33   5% |
|  46 |  36   4% |  35   5% |  35   4% |  34   4% |  35   5% |  35   6% |  34   4% |  35   4% |  35   4% |  35   5% |  34   4% |  35   5% |  35   5% |  34   4% |  36   4% |  34   4% |  35   4% |  34   5% |  35   4% |  35   5% |
|  48 |  38   4% |  37   5% |  37   5% |  36   4% |  37   5% |  37   5% |  36   4% |  37   5% |  37   4% |  37   5% |  36   4% |  37   5% |  37   5% |  36   4% |  38   4% |  36   4% |  37   5% |  36   5% |  37   4% |  37   5% |
|  50 |  40   4% |  39   5% |  39   5% |  38   4% |  39   5% |  39   5% |  38   4% |  39   5% |  39   4% |  39   5% |  38   4% |  39   5% |  39   5% |  38   4% |  40   4% |  38   4% |  39   5% |  38   5% |  39   4% |  39   5% |
|  52 |  42   4% |  41   5% |  41   5% |  40   4% |  41   5% |  41   5% |  40   4% |  41   5% |  41   4% |  41   5% |  40   4% |  41   5% |  41   5% |  40   4% |  42   4% |  40   4% |  41   5% |  40   5% |  41   4% |  41   5% |
|  54 |  44   4% |  43   5% |  43   4% |  42   5% |  43   4% |  43   5% |  42   4% |  43   5% |  43   4% |  43   5% |  42   4% |  43   5% |  43   5% |  42   4% |  44   4% |  42   4% |  43   5% |  42   5% |  43   4% |  43   5% |
|  56 |  46   4% |  45   5% |  45   4% |  44   4% |  45   4% |  45   5% |  44   4% |  45   5% |  45   4% |  45   5% |  44   4% |  45   5% |  45   5% |  44   4% |  46   4% |  44   4% |  45   5% |  44   5% |  45   4% |  45   5% |
|  58 |  48   4% |  47   5% |  47   5% |  46   4% |  47   4% |  47   5% |  46   4% |  47   5% |  47   4% |  47   5% |  46   4% |  47   5% |  47   5% |  46   4% |  48   4% |  46   4% |  47   5% |  46   5% |  47   4% |  47   5% |
|  60 |  50   4% |  49   5% |  49   4% |  48   4% |  49   4% |  49   5% |  48   4% |  49   5% |  49   4% |  49   5% |  48   4% |  49   5% |  49   5% |  48   4% |  50   4% |  48   4% |  49   5% |  48   5% |  49   4% |  49   5% |
|  62 |  52   4% |  51   5% |  51   4% |  50   4% |  51   4% |  51   5% |  50   4% |  51   5% |  51   4% |  51   5% |  50   4% |  51   5% |  51   5% |  50   4% |  52   4% |  50   4% |  51   5% |  50   5% |  51   4% |  51   5% |
|  64 |  54   4% |  53   5% |  53   4% |  52   4% |  53   4% |  53   5% |  52   4% |  53   5% |  53   4% |  53   5% |  52   4% |  53   5% |  53   5% |  52   4% |  54   4% |  52   4% |  53   5% |  52   5% |  53   4% |  53   5% |
|  66 |  56   4% |  55   5% |  55   4% |  54   4% |  55   4% |  55   5% |  54   4% |  55   5% |  55   4% |  55   5% |  54   4% |  55   5% |  55   5% |  54   4% |  56   4% |  54   4% |  55   4% |  54   5% |  55   4% |  55   5% |
|  68 |  58   4% |  57   5% |  57   4% |  56   5% |  57   4% |  57   5% |  56   4% |  57   5% |  57   4% |  57   5% |  56   4% |  57   5% |  57   5% |  56   4% |  58   4% |  56   4% |  57   4% |  56   5% |  57   4% |  57   5% |
|  70 |  60   4% |  59   5% |  59   4% |  58   4% |  59   4% |  59   5% |  58   4% |  59   5% |  59   4% |  59   5% |  58   4% |  59   5% |  59   5% |  58   4% |  60   4% |  58   4% |  59   4% |  58   5% |  59   4% |  59   5% |
|  72 |  62   4% |  61   5% |  61   4% |  60   4% |  61   4% |  61   5% |  60   4% |  61   5% |  61   4% |  61   5% |  60   4% |  61   5% |  61   5% |  60   4% |  62   4% |  60   4% |  61   4% |  60   5% |  61   4% |  61   5% |
|  74 |  64   4% |  63   5% |  63   4% |  62   4% |  63   4% |  63   5% |  62   4% |  63   5% |  63   4% |  63   5% |  62   4% |  63   5% |  63   5% |  62   4% |  64   4% |  62   4% |  63   4% |  62   5% |  63   4% |  63   5% |
|  76 |  66   4% |  65   5% |  65   4% |  64   4% |  65   4% |  65   5% |  64   4% |  65   5% |  65   4% |  65   5% |  64   4% |  65   5% |  65   5% |  64   4% |  66   4% |  64   5% |  65   4% |  64   5% |  65   4% |  65   5% |
|  78 |  68   4% |  67   5% |  67   4% |  66   4% |  67   5% |  67   5% |  66   4% |  67   5% |  67   4% |  67   5% |  66   4% |  67   5% |  67   5% |  66   4% |  68   4% |  66   5% |  67   4% |  66   5% |  67   4% |  67   5% |
|  80 |  70   4% |  69   5% |  69   4% |  68   4% |  69   5% |  69   5% |  68   4% |  69   4% |  69   4% |  69   5% |  68   4% |  69   5% |  69   5% |  68   4% |  70   4% |  68   5% |  69   4% |  68   5% |  69   4% |  69   5% |
|  82 |  72   4% |  71   4% |  71   4% |  70   4% |  71   5% |  71   5% |  70   4% |  71   4% |  71   4% |  71   5% |  70   4% |  71   5% |  71   5% |  70   4% |  72   4% |  70   5% |  71   4% |  70   5% |  71   4% |  71   5% |
|  84 |  74   4% |  73   4% |  73   4% |  72   4% |  73   5% |  73   5% |  72   4% |  73   4% |  73   4% |  73   5% |  72   5% |  73   5% |  73   5% |  72   4% |  74   4% |  72   5% |  73   4% |  72   5% |  73   4% |  73   5% |
|  86 |  76   4% |  75   5% |  75   4% |  74   4% |  75   5% |  75   5% |  74   4% |  75   4% |  75   4% |  75   5% |  74   5% |  75   5% |  75   5% |  74   4% |  76   4% |  74   5% |  75   4% |  74   5% |  75   4% |  75   5% |
|  88 |  78   4% |  77   5% |  77   4% |  76   4% |  77   5% |  77   5% |  76   4% |  77   4% |  77   4% |  77   5% |  76   5% |  77   5% |  77   5% |  76   4% |  78   4% |  76   5% |  77   4% |  76   5% |  77   4% |  77   5% |
|  90 |  80   4% |  79   5% |  79   4% |  78   4% |  79   4% |  79   5% |  78   4% |  79   4% |  79   4% |  79   5% |  78   5% |  79   5% |  79   5% |  78   4% |  80   4% |  78   5% |  79   4% |  78   5% |  79   4% |  79   5% |
|  92 |  82   4% |  81   5% |  81   4% |  80   4% |  81   4% |  81   5% |  80   4% |  81   4% |  81   4% |  81   5% |  80   5% |  81   5% |  81   5% |  80   4% |  82   4% |  80   5% |  81   4% |  80   5% |  81   4% |  81   5% |
|  94 |  84   4% |  83   4% |  83   4% |  82   4% |  83   4% |  83   5% |  82   4% |  83   4% |  83   4% |  83   5% |  82   5% |  83   5% |  83   5% |  82   4% |  84   4% |  82   5% |  83   4% |  82   5% |  83   4% |  83   5% |
|  96 |  86   4% |  85   4% |  85   4% |  84   4% |  85   4% |  85   5% |  84   4% |  85   4% |  85   4% |  85   5% |  84   5% |  85   5% |  85   5% |  84   4% |  86   4% |  84   5% |  85   4% |  84   5% |  85   4% |  85   5% |
|  98 |  88   4% |  87   4% |  87   4% |  86   4% |  87   4% |  87   5% |  86   4% |  87   4% |  87   4% |  87   5% |  86   5% |  87   5% |  87   5% |  86   4% |  88   4% |  86   5% |  87   4% |  86   5% |  87   4% |  87   5% |
+-----+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------+
Total bytes=915941810, ranges=1756

Index

Examples

Constants

const (
	// RaftLogQueueTimerDuration is the duration between truncations. This needs
	// to be relatively short so that truncations can keep up with raft log entry
	// creation.
	RaftLogQueueTimerDuration = 50 * time.Millisecond
	// RaftLogQueueStaleThreshold is the minimum threshold for stale raft log
	// entries. A stale entry is one which all replicas of the range have
	// progressed past and thus is no longer needed and can be truncated.
	RaftLogQueueStaleThreshold = 100
	// RaftLogQueueStaleSize is the minimum size of the Raft log that we'll
	// truncate even if there are fewer than RaftLogQueueStaleThreshold entries
	// to truncate. The value of 64 KB was chosen experimentally by looking at
	// when Raft log truncation usually occurs when using the number of entries
	// as the sole criteria.
	RaftLogQueueStaleSize = 64 << 10
)
const (

	// ReplicaGCQueueInactivityThreshold is the inactivity duration after which
	// a range will be considered for garbage collection. Exported for testing.
	ReplicaGCQueueInactivityThreshold = 10 * 24 * time.Hour // 10 days
	// ReplicaGCQueueCandidateTimeout is the duration after which a range in
	// candidate Raft state (which is a typical sign of having been removed
	// from the group) will be considered for garbage collection.
	ReplicaGCQueueCandidateTimeout = 1 * time.Second
)
const (
	// TestTimeUntilStoreDead is the test value for TimeUntilStoreDead to
	// quickly mark stores as dead.
	TestTimeUntilStoreDead = 5 * time.Millisecond

	// TestTimeUntilStoreDeadOff is the test value for TimeUntilStoreDead that
	// prevents the store pool from marking stores as dead.
	TestTimeUntilStoreDeadOff = 24 * time.Hour
)
const (

	// IntersectingSnapshotMsg is part of the error message returned from
	// canApplySnapshotLocked and is exposed here so testing can rely on it.
	IntersectingSnapshotMsg = "snapshot intersects existing range"
)
const MaxCommandSizeFloor = 4 << 20 // 4MB

MaxCommandSizeFloor is the minimum allowed value for the MaxCommandSize cluster setting.

const (

	// MinStatsDuration defines a lower bound on how long users of replica stats
	// should wait before using those stats for anything. If the duration of a
	// measurement has been less than MinStatsDuration, these methods could easily
	// return outlier/anomalous data.
	MinStatsDuration = 5 * time.Second
)
const (
	// MinTSCacheWindow specifies the minimum duration to hold entries in the
	// cache before allowing eviction. After this window expires, transactions
	// writing to this node with timestamps lagging by more than MinTSCacheWindow
	// will necessarily have to advance their commit timestamp.
	MinTSCacheWindow = 10 * time.Second
)
const (
	// TimeSeriesMaintenanceInterval is the minimum interval between two
	// time series maintenance runs on a replica.
	TimeSeriesMaintenanceInterval = 24 * time.Hour // daily
)

Variables

var (
	ErrInvalidLengthApi = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowApi   = fmt.Errorf("proto: integer overflow")
)
var (
	ErrInvalidLengthLeaseStatus = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLeaseStatus   = fmt.Errorf("proto: integer overflow")
)
var (
	ErrInvalidLengthLiveness = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLiveness   = fmt.Errorf("proto: integer overflow")
)
var (
	ErrInvalidLengthLog = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLog   = fmt.Errorf("proto: integer overflow")
)
var (
	// ErrNoLivenessRecord is returned when asking for liveness information
	// about a node for which nothing is known.
	ErrNoLivenessRecord = errors.New("node not in the liveness table")

	// ErrEpochIncremented is returned when a heartbeat request fails because
	// the underlying liveness record has had its epoch incremented.
	ErrEpochIncremented = errors.New("heartbeat failed on epoch increment")
)
var (
	ErrInvalidLengthRaft = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRaft   = fmt.Errorf("proto: integer overflow")
)
var EnableStatsBasedRebalancing = settings.RegisterBoolSetting(
	"kv.allocator.stat_based_rebalancing.enabled",
	"set to enable rebalancing of range replicas based on write load and disk usage",
	false,
)

EnableStatsBasedRebalancing controls whether range rebalancing takes additional variables such as write load and disk usage into account. If disabled, rebalancing is done purely based on replica count.

var LeaseState_name = map[int32]string{
	0: "ERROR",
	1: "VALID",
	2: "STASIS",
	3: "EXPIRED",
	4: "PROSCRIBED",
}
var LeaseState_value = map[string]int32{
	"ERROR":      0,
	"VALID":      1,
	"STASIS":     2,
	"EXPIRED":    3,
	"PROSCRIBED": 4,
}
var MaxCommandSize = settings.RegisterValidatedByteSizeSetting(
	"kv.raft.command.max_size",
	"maximum size of a raft command",
	64<<20,
	func(size int64) error {
		if size < MaxCommandSizeFloor {
			return fmt.Errorf("max_size must be greater than %s", humanizeutil.IBytes(MaxCommandSizeFloor))
		}
		return nil
	},
)

MaxCommandSize wraps "kv.raft.command.max_size".

var MinLeaseTransferStatsDuration = 30 * time.Second

MinLeaseTransferStatsDuration configures the minimum amount of time a replica must wait for stats about request counts to accumulate before making decisions based on them. The higher this is, the less likely thrashing is (up to a point). Made configurable for the sake of testing.

var RangeLogEventType_name = map[int32]string{
	0: "split",
	1: "add",
	2: "remove",
}
var RangeLogEventType_value = map[string]int32{
	"split":  0,
	"add":    1,
	"remove": 2,
}
var SnapshotRequest_Priority_name = map[int32]string{
	0: "UNKNOWN",
	1: "RECOVERY",
	2: "REBALANCE",
}
var SnapshotRequest_Priority_value = map[string]int32{
	"UNKNOWN":   0,
	"RECOVERY":  1,
	"REBALANCE": 2,
}
var SnapshotResponse_Status_name = map[int32]string{
	0: "UNKNOWN",
	1: "ACCEPTED",
	2: "APPLIED",
	3: "ERROR",
	4: "DECLINED",
}
var SnapshotResponse_Status_value = map[string]int32{
	"UNKNOWN":  0,
	"ACCEPTED": 1,
	"APPLIED":  2,
	"ERROR":    3,
	"DECLINED": 4,
}
var TimeUntilStoreDead = settings.RegisterNonNegativeDurationSetting(
	"server.time_until_store_dead",
	"the time after which if there is no new gossiped information about a store, it is considered dead",
	5*time.Minute,
)

TimeUntilStoreDead wraps "server.time_until_store_dead".

func ComputeStatsForRange

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

ComputeStatsForRange computes the stats for a given range by iterating over all key ranges for the given range that should be accounted for in its stats.

func DecodeRaftCommand

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

DecodeRaftCommand splits a raftpb.Entry.Data into its commandID and command portions. The caller is responsible for checking that the data is not empty (which indicates a dummy entry generated by raft rather than a real command). Usage is mostly internal to the storage package but is exported for use by debugging tools.

func DefaultDeclareKeys

func DefaultDeclareKeys(
	desc roachpb.RangeDescriptor, header roachpb.Header, req roachpb.Request, spans *SpanSet,
)

DefaultDeclareKeys is the default implementation of Command.DeclareKeys

func EnableLeaseHistory

func EnableLeaseHistory(maxEntries int) func()

EnableLeaseHistory turns on the lease history for testing purposes. Returns a function to return it to its original state that can be deferred.

func HasRaftLeader

func HasRaftLeader(raftStatus *raft.Status) bool

HasRaftLeader returns true if the raft group has a raft leader currently.

func IsSnapshotError

func IsSnapshotError(err error) bool

IsSnapshotError returns true iff the error indicates a preemptive snapshot failed.

func IterateRangeDescriptors

func IterateRangeDescriptors(
	ctx context.Context, eng engine.Reader, fn func(desc roachpb.RangeDescriptor) (bool, error),
) error

IterateRangeDescriptors calls the provided function with each descriptor from the provided Engine. The return values of this method and fn have semantics similar to engine.MVCCIterate.

func NewReplicaCorruptionError

func NewReplicaCorruptionError(err error) *roachpb.ReplicaCorruptionError

NewReplicaCorruptionError creates a new error indicating a corrupt replica, with the supplied list of errors given as history.

func ReadClusterVersion

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

ReadClusterVersion reads the the cluster version from the store-local version key.

func ReadStoreIdent

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

ReadStoreIdent reads the StoreIdent from the store. It returns *NotBootstrappedError if the ident is missing (meaning that the store needs to be bootstrapped).

func ReadVersionFromEngineOrDefault

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

ReadVersionFromEngineOrDefault reads the persisted cluster version from the engine, falling back to v1.0 if no version is specified on the engine.

func RegisterConsistencyServer

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

func RegisterMultiRaftServer

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

func SetAddSSTableCmd

func SetAddSSTableCmd(cmd Command)

SetAddSSTableCmd allows setting the function that will be called as the implementation of the AddSSTable command. Only allowed to be called by Init.

func SetExportCmd

func SetExportCmd(cmd Command)

SetExportCmd allows setting the function that will be called as the implementation of the Export command. Only allowed to be called by Init.

func SetImportCmd

func SetImportCmd(fn ImportCmdFunc)

SetImportCmd allows setting the function that will be called as the implementation of the Import command. Only allowed to be called by Init.

func SetWriteBatchCmd

func SetWriteBatchCmd(cmd Command)

SetWriteBatchCmd allows setting the function that will be called as the implementation of the WriteBatch command. Only allowed to be called by Init.

func SynthesizeClusterVersionFromEngines

func SynthesizeClusterVersionFromEngines(
	ctx context.Context, engines []engine.Engine, minSupportedVersion, serverVersion roachpb.Version,
) (cluster.ClusterVersion, error)

SynthesizeClusterVersionFromEngines implements the core of (*Stores).SynthesizeClusterVersion.

func TestingRelocateRange

func TestingRelocateRange(
	ctx context.Context,
	db *client.DB,
	rangeDesc roachpb.RangeDescriptor,
	targets []roachpb.ReplicationTarget,
) error

TestingRelocateRange relocates a given range to a given set of stores. The first store in the slice becomes the new leaseholder.

This is best-effort; if replication queues are enabled and a change in membership happens at the same time, there will be errors.

func TrackRaftProtos

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

TrackRaftProtos instruments proto marshalling to track protos which are marshalled downstream of raft. It returns a function that removes the instrumentation and returns the list of downstream-of-raft protos.

func WriteClusterVersion

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

WriteClusterVersion writes the given cluster version to the store-local cluster version key.

func WriteClusterVersionToEngines

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

WriteClusterVersionToEngines writes the given version to the given engines, without any sanity checks.

type AbortCache

type AbortCache struct {
	// contains filtered or unexported fields
}

The AbortCache sets markers for aborted transactions to provide protection against an aborted but active transaction not reading values it wrote (due to its intents having been removed).

The cache is range-specific. It is updated when an intent for an aborted txn is cleared from a range, and is consulted before read commands are processed on a range.

The AbortCache stores responses in the underlying engine, using keys derived from Range ID and txn ID. Note that the epoch number is not used to query the cache: once aborted, even higher epochs are prohibited from reading data. That's because, for better or worse, the intent resolution process clears intents even from epochs higher than the txn meta used for clearing (see engine.MVCCResolveWriteIntent), and this clearing can race with the new epoch laying intents.

A AbortCache is not thread safe. Access to it is serialized through Raft.

TODO(tschottdorf): we seem to have made a half-hearted attempt at naming this the "AbortSpan" instead, but large parts of the code still call this "AbortCache". We should settle for one and rename everything post-yellow.

func NewAbortCache

func NewAbortCache(rangeID roachpb.RangeID) *AbortCache

NewAbortCache returns a new abort cache. Every range replica maintains an abort cache, not just the lease holder.

func (*AbortCache) ClearData

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

ClearData removes all persisted items stored in the cache.

func (*AbortCache) CopyFrom

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

CopyFrom copies all the persisted results from the originRangeID abort cache into this one. Note that the cache will not be locked while copying is in progress. Failures decoding individual entries return an error. The copy is done directly using the engine instead of interpreting values through MVCC for efficiency. On success, returns the number of entries (key-value pairs) copied.

func (*AbortCache) CopyInto

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

CopyInto copies all the results from this abort cache into the destRangeID abort cache. Failures decoding individual cache entries return an error. On success, returns the number of entries (key-value pairs) copied.

func (*AbortCache) Del

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

Del removes all abort cache entries for the given transaction.

func (*AbortCache) Get

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

Get looks up an abort cache entry recorded for this transaction ID. Returns whether an abort record was found and any error.

func (*AbortCache) Iterate

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

Iterate walks through the abort cache, invoking the given callback for each unmarshaled entry with the key, the transaction ID and the decoded entry. TODO(tschottdorf): should not use a pointer to UUID.

func (*AbortCache) Put

func (sc *AbortCache) Put(
	ctx context.Context,
	e engine.ReadWriter,
	ms *enginepb.MVCCStats,
	txnID uuid.UUID,
	entry *roachpb.AbortCacheEntry,
) error

Put writes an entry for the specified transaction ID.

type Allocator

type Allocator struct {
	// contains filtered or unexported fields
}

Allocator tries to spread replicas as evenly as possible across the stores in the cluster.

func MakeAllocator

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

MakeAllocator creates a new allocator using the specified StorePool.

func (*Allocator) AllocateTarget

func (a *Allocator) AllocateTarget(
	ctx context.Context,
	constraints config.Constraints,
	existing []roachpb.ReplicaDescriptor,
	rangeInfo RangeInfo,
	relaxConstraints bool,
) (*roachpb.StoreDescriptor, string, error)

AllocateTarget returns a suitable store for a new allocation with the required attributes. Nodes already accommodating existing replicas are ruled out as targets. The range ID of the replica being allocated for is also passed in to ensure that we don't try to replace an existing dead replica on a store. If relaxConstraints is true, then the required attributes will be relaxed as necessary, from least specific to most specific, in order to allocate a target.

func (*Allocator) ComputeAction

func (a *Allocator) ComputeAction(
	ctx context.Context, zone config.ZoneConfig, rangeInfo RangeInfo,
) (AllocatorAction, float64)

ComputeAction determines the exact operation needed to repair the supplied range, as governed by the supplied zone configuration. It returns the required action that should be taken and a priority.

func (Allocator) RebalanceTarget

func (a Allocator) RebalanceTarget(
	ctx context.Context,
	constraints config.Constraints,
	raftStatus *raft.Status,
	rangeInfo RangeInfo,
	filter storeFilter,
) (*roachpb.StoreDescriptor, string)

RebalanceTarget returns a suitable store for a rebalance target with required attributes. Rebalance targets are selected via the same mechanism as AllocateTarget(), except the chosen target must follow some additional criteria. Namely, if chosen, it must further the goal of balancing the cluster.

The supplied parameters are the required attributes for the range and information about the range being considered for rebalancing.

The existing replicas modulo any store with dead replicas are candidates for rebalancing. Note that rebalancing is accomplished by first adding a new replica to the range, then removing the most undesirable replica.

Simply ignoring a rebalance opportunity in the event that the target chosen by AllocateTarget() doesn't fit balancing criteria is perfectly fine, as other stores in the cluster will also be doing their probabilistic best to rebalance. This helps prevent a stampeding herd targeting an abnormally under-utilized store.

func (Allocator) RemoveTarget

func (a Allocator) RemoveTarget(
	ctx context.Context,
	constraints config.Constraints,
	candidates []roachpb.ReplicaDescriptor,
	rangeInfo RangeInfo,
) (roachpb.ReplicaDescriptor, string, error)

RemoveTarget returns a suitable replica to remove from the provided replica set. It first attempts to randomly select a target from the set of stores that have greater than the average number of replicas. Failing that, it falls back to selecting a random target from any of the existing replicas.

func (*Allocator) ShouldTransferLease

func (a *Allocator) ShouldTransferLease(
	ctx context.Context,
	constraints config.Constraints,
	existing []roachpb.ReplicaDescriptor,
	leaseStoreID roachpb.StoreID,
	rangeID roachpb.RangeID,
	stats *replicaStats,
) bool

ShouldTransferLease returns true if the specified store is overfull in terms of leases with respect to the other stores matching the specified attributes.

func (*Allocator) TransferLeaseTarget

func (a *Allocator) TransferLeaseTarget(
	ctx context.Context,
	constraints config.Constraints,
	existing []roachpb.ReplicaDescriptor,
	leaseStoreID roachpb.StoreID,
	rangeID roachpb.RangeID,
	stats *replicaStats,
	checkTransferLeaseSource bool,
	checkCandidateFullness bool,
	alwaysAllowDecisionWithoutStats bool,
) roachpb.ReplicaDescriptor

TransferLeaseTarget returns a suitable replica to transfer the range lease to from the provided list. It excludes the current lease holder replica unless asked to do otherwise by the checkTransferLeaseSource parameter.

type AllocatorAction

type AllocatorAction int

AllocatorAction enumerates the various replication adjustments that may be recommended by the allocator.

const (
	AllocatorNoop AllocatorAction
	AllocatorRemove
	AllocatorAdd
	AllocatorRemoveDead
	AllocatorRemoveDecommissioning
	AllocatorConsiderRebalance
)

These are the possible allocator actions.

func (AllocatorAction) String

func (a AllocatorAction) String() string

type CollectChecksumRequest

type CollectChecksumRequest struct {
	StoreRequestHeader `protobuf:"bytes,1,opt,name=header,embedded=header" json:"header"`
	RangeID            github_com_cockroachdb_cockroach_pkg_roachpb.RangeID "" /* 145 byte string literal not displayed */

	ChecksumID github_com_cockroachdb_cockroach_pkg_util_uuid.UUID "" /* 144 byte string literal not displayed */
	Checksum   []byte                                              `protobuf:"bytes,4,opt,name=checksum,proto3" json:"checksum,omitempty"`
}

A CollectChecksumRequest asks the addressed replica for the result of a roachpb.ComputeChecksumRequest.

func (*CollectChecksumRequest) Descriptor

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

func (*CollectChecksumRequest) Marshal

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

func (*CollectChecksumRequest) MarshalTo

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

func (*CollectChecksumRequest) ProtoMessage

func (*CollectChecksumRequest) ProtoMessage()

func (*CollectChecksumRequest) Reset

func (m *CollectChecksumRequest) Reset()

func (*CollectChecksumRequest) Size

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

func (*CollectChecksumRequest) String

func (m *CollectChecksumRequest) String() string

func (*CollectChecksumRequest) Unmarshal

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

type CollectChecksumResponse

type CollectChecksumResponse struct {
	Checksum []byte `protobuf:"bytes,1,opt,name=checksum,proto3" json:"checksum,omitempty"`
	// snapshot is set if the roachpb.ComputeChecksumRequest had snapshot = true
	// and the response checksum is different from the request checksum.
	Snapshot *cockroach_roachpb1.RaftSnapshotData `protobuf:"bytes,2,opt,name=snapshot" json:"snapshot,omitempty"`
}

func (*CollectChecksumResponse) Descriptor

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

func (*CollectChecksumResponse) Marshal

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

func (*CollectChecksumResponse) MarshalTo

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

func (*CollectChecksumResponse) ProtoMessage

func (*CollectChecksumResponse) ProtoMessage()

func (*CollectChecksumResponse) Reset

func (m *CollectChecksumResponse) Reset()

func (*CollectChecksumResponse) Size

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

func (*CollectChecksumResponse) String

func (m *CollectChecksumResponse) String() string

func (*CollectChecksumResponse) Unmarshal

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

type Command

type Command struct {
	// DeclareKeys adds all keys this command touches to the given spanSet.
	DeclareKeys func(roachpb.RangeDescriptor, roachpb.Header, roachpb.Request, *SpanSet)

	// Eval evaluates a command on the given engine. It should populate
	// the supplied response (always a non-nil pointer to the correct
	// type) and return special side effects (if any) in the EvalResult.
	// If it writes to the engine it should also update
	// *CommandArgs.Stats.
	Eval func(context.Context, engine.ReadWriter, CommandArgs, roachpb.Response) (EvalResult, error)
}

A Command is the implementation of a single request within a BatchRequest.

type CommandArgs

type CommandArgs struct {
	EvalCtx ReplicaEvalContext
	Header  roachpb.Header
	Args    roachpb.Request

	// If MaxKeys is non-zero, span requests should limit themselves to
	// that many keys. Commands using this feature should also set
	// NumKeys and ResumeSpan in their responses.
	MaxKeys int64

	// *Stats should be mutated to reflect any writes made by the command.
	Stats *enginepb.MVCCStats
}

CommandArgs contains all the arguments to a command. TODO(bdarnell): consider merging with storagebase.FilterArgs (which would probably require removing the EvalCtx field due to import order constraints).

type CommandQueue

type CommandQueue struct {
	// contains filtered or unexported fields
}

A CommandQueue maintains an interval tree of keys or key ranges for executing commands. New commands affecting keys or key ranges must wait on already-executing commands which overlap their key range.

Before executing, a command invokes getPrereqs() to acquire a slice of references to overlapping commands that are already in the command queue. After determining its prerequisite commands, the command is added to the queue via add(). getPrereqs() and add() accept a parameter indicating whether the command is read-only. Read-only commands don't need to wait on other read-only commands, so the commands returned via getPrereqs() don't include read-only on read-only overlapping commands as an optimization. Both getPrereqs() and add() must see an atomic view of the command queue, so in a concurrent setting, their execution must be synchronized under the same lock.

After determining prerequisite commands and adding the new command to the command queue, the new command must wait on each prerequisite command's pending channel for confirmation that all overlapping commands have completed and that the new command can proceed.

Once commands complete, remove() is invoked to remove the executing command and close its channel, possibly signaling waiting commands who were gated by the executing command's affected key(s).

CommandQueue is not thread safe.

func NewCommandQueue

func NewCommandQueue(coveringOptimization bool) *CommandQueue

NewCommandQueue returns a new command queue. The boolean specifies whether to enable the covering span optimization. With this optimization, whenever a command consisting of multiple spans is added, a covering span is computed and only that covering span inserted. The individual spans are inserted (i.e. the covering span expanded) only when required by a later overlapping command, the hope being that that occurs infrequently, and that in the common case savings are made due to the reduced number of spans active in the tree. As such, the optimization makes sense for workloads in which commands typically contain many spans, but are spatially disjoint.

func (*CommandQueue) String

func (cq *CommandQueue) String() string

String dumps the contents of the command queue for testing.

type CommandQueueMetrics

type CommandQueueMetrics struct {
	WriteCommands   int64
	ReadCommands    int64
	MaxOverlapsSeen int64
	TreeSize        int32
}

CommandQueueMetrics holds the metrics for a the command queue that are included in range metrics. TODO(bram): replace this struct with serverpb.CommandQueueMetrics. This will require moveing all protos out of storage into storagebase that are referenced in serverpb to prevent an import cycle.

type ConfChangeContext

type ConfChangeContext struct {
	CommandID string `protobuf:"bytes,1,opt,name=command_id,json=commandId" json:"command_id"`
	// Payload is the application-level command (i.e. an encoded
	// storagebase.RaftCommand).
	Payload []byte `protobuf:"bytes,2,opt,name=payload" json:"payload,omitempty"`
	// Replica contains full details about the replica being added or removed.
	Replica cockroach_roachpb.ReplicaDescriptor `protobuf:"bytes,3,opt,name=replica" json:"replica"`
}

ConfChangeContext is encoded in the raftpb.ConfChange.Context field.

func (*ConfChangeContext) Descriptor

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

func (*ConfChangeContext) Marshal

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

func (*ConfChangeContext) MarshalTo

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

func (*ConfChangeContext) ProtoMessage

func (*ConfChangeContext) ProtoMessage()

func (*ConfChangeContext) Reset

func (m *ConfChangeContext) Reset()

func (*ConfChangeContext) Size

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

func (*ConfChangeContext) String

func (m *ConfChangeContext) String() string

func (*ConfChangeContext) Unmarshal

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

type ConsistencyClient

type ConsistencyClient interface {
	CollectChecksum(ctx context.Context, in *CollectChecksumRequest, opts ...grpc.CallOption) (*CollectChecksumResponse, error)
}

func NewConsistencyClient

func NewConsistencyClient(cc *grpc.ClientConn) ConsistencyClient

type ConsistencyServer

type ConsistencyServer interface {
	CollectChecksum(context.Context, *CollectChecksumRequest) (*CollectChecksumResponse, error)
}

type EvalResult

type EvalResult struct {
	Local      LocalEvalResult
	Replicated storagebase.ReplicatedEvalResult
	WriteBatch *storagebase.WriteBatch
}

EvalResult is the result of evaluating a KV request. That is, the proposer (which holds the lease, at least in the case in which the command will complete successfully) has evaluated the request and is holding on to:

a) changes to be written to disk when applying the command b) changes to the state which may require special handling (i.e. code

execution) on all Replicas

c) data which isn't sent to the followers but the proposer needs for tasks

it must run when the command has applied (such as resolving intents).

func (*EvalResult) IsZero

func (p *EvalResult) IsZero() bool

IsZero reports whether p is the zero value.

func (*EvalResult) MergeAndDestroy

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

MergeAndDestroy absorbs the supplied EvalResult while validating that the resulting EvalResult makes sense. For example, it is forbidden to absorb two lease updates or log truncations, or multiple splits and/or merges.

The passed EvalResult must not be used once passed to Merge.

type GCInfo

type GCInfo struct {
	// Now is the timestamp used for age computations.
	Now hlc.Timestamp
	// Policy is the policy used for this garbage collection cycle.
	Policy config.GCPolicy
	// Stats about the userspace key-values considered, namely the number of
	// keys with GC'able data, the number of "old" intents and the number of
	// associated distinct transactions.
	NumKeysAffected, IntentsConsidered, IntentTxns int
	// TransactionSpanTotal is the total number of entries in the transaction span.
	TransactionSpanTotal int
	// Summary of transactions which were found GCable (assuming that
	// potentially necessary intent resolutions did not fail).
	TransactionSpanGCAborted, TransactionSpanGCCommitted, TransactionSpanGCPending int
	// TxnSpanGCThreshold is the cutoff for transaction span GC. Transactions
	// with a smaller LastActive() were considered for GC.
	TxnSpanGCThreshold hlc.Timestamp
	// AbortSpanTotal is the total number of transactions present in the abort cache.
	AbortSpanTotal int
	// AbortSpanConsidered is the number of abort cache entries old enough to be
	// considered for removal. An "entry" corresponds to one transaction;
	// more than one key-value pair may be associated with it.
	AbortSpanConsidered int
	// AbortSpanGCNum is the number of abort cache entries fit for removal (due
	// to their transactions having terminated).
	AbortSpanGCNum int
	// PushTxn is the total number of pushes attempted in this cycle.
	PushTxn int
	// ResolveTotal is the total number of attempted intent resolutions in
	// this cycle.
	ResolveTotal int
	// ResolveErrors is the number of successful intent resolutions.
	ResolveSuccess int
	// Threshold is the computed expiration timestamp. Equal to `Now - Policy`.
	Threshold hlc.Timestamp
}

GCInfo contains statistics and insights from a GC run.

func RunGC

func RunGC(
	ctx context.Context,
	desc *roachpb.RangeDescriptor,
	snap engine.Reader,
	now hlc.Timestamp,
	policy config.GCPolicy,
	gcFn gcFunc,
	pushTxnFn pushFunc,
	resolveIntentsFn resolveFunc,
	processAsyncFn processAsyncFunc,
) (GCInfo, error)

RunGC runs garbage collection for the specified descriptor on the provided Engine (which is not mutated). It uses the provided pushTxnFn to clarify the true status of a transaction, resolveIntentsFn to resolve intents synchronously, and processAsyncFn to asynchronously cleanup after encountered transactions.

type HeartbeatCallback

type HeartbeatCallback func(context.Context)

HeartbeatCallback is invoked whenever this node updates its own liveness status, indicating that it is alive.

type ImportCmdFunc

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

ImportCmdFunc is the type of the function that will be called as the implementation of the Import command.

type IncomingSnapshot

type IncomingSnapshot struct {
	SnapUUID uuid.UUID
	// The RocksDB BatchReprs that make up this snapshot.
	Batches [][]byte
	// The Raft log entries for this snapshot.
	LogEntries [][]byte
	// The replica state at the time the snapshot was generated (never nil).
	State *storagebase.ReplicaState
	// contains filtered or unexported fields
}

IncomingSnapshot contains the data for an incoming streaming snapshot message.

type IsLiveCallback

type IsLiveCallback func(nodeID roachpb.NodeID)

IsLiveCallback is invoked when a node's IsLive state changes to true. Callbacks can be registered via NodeLiveness.RegisterCallback().

type KeyRange

type KeyRange interface {
	Desc() *roachpb.RangeDescriptor

	btree.Item
	fmt.Stringer
	// contains filtered or unexported methods
}

KeyRange is an interface type for the replicasByKey BTree, to compare Replica and ReplicaPlaceholder.

type LeaseState

type LeaseState int32
const (
	// ERROR indicates that the lease can't be used or acquired.
	LeaseState_ERROR LeaseState = 0
	// VALID indicates that the lease can be used.
	LeaseState_VALID LeaseState = 1
	// STASIS indicates that the lease has not expired, but can't be used.
	LeaseState_STASIS LeaseState = 2
	// EXPIRED indicates that the lease can't be used.
	LeaseState_EXPIRED LeaseState = 3
	// PROSCRIBED indicates that the lease's proposed timestamp is earlier than
	// allowed.
	LeaseState_PROSCRIBED LeaseState = 4
)

func (LeaseState) EnumDescriptor

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

func (LeaseState) String

func (x LeaseState) String() string

type LeaseStatus

type LeaseStatus struct {
	// Lease which this status describes.
	Lease cockroach_roachpb2.Lease `protobuf:"bytes,1,opt,name=lease" json:"lease"`
	// Timestamp that the lease was evaluated at.
	Timestamp cockroach_util_hlc.Timestamp `protobuf:"bytes,2,opt,name=timestamp" json:"timestamp"`
	// State of the lease at timestamp.
	State LeaseState `protobuf:"varint,3,opt,name=state,proto3,enum=cockroach.storage.LeaseState" json:"state,omitempty"`
	// Liveness if this is an epoch-based lease.
	Liveness *Liveness `protobuf:"bytes,4,opt,name=liveness" json:"liveness,omitempty"`
}

LeaseStatus holds the lease state, the timestamp at which the state is accurate, the lease and optionally the liveness if the lease is epoch-based.

func (*LeaseStatus) Descriptor

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

func (*LeaseStatus) Marshal

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

func (*LeaseStatus) MarshalTo

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

func (*LeaseStatus) ProtoMessage

func (*LeaseStatus) ProtoMessage()

func (*LeaseStatus) Reset

func (m *LeaseStatus) Reset()

func (*LeaseStatus) Size

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

func (*LeaseStatus) String

func (m *LeaseStatus) String() string

func (*LeaseStatus) Unmarshal

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

type Liveness

type Liveness struct {
	NodeID github_com_cockroachdb_cockroach_pkg_roachpb.NodeID "" /* 141 byte string literal not displayed */

	Epoch int64 `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"`

	Expiration      cockroach_util_hlc.Timestamp `protobuf:"bytes,3,opt,name=expiration" json:"expiration"`
	Draining        bool                         `protobuf:"varint,4,opt,name=draining,proto3" json:"draining,omitempty"`
	Decommissioning bool                         `protobuf:"varint,5,opt,name=decommissioning,proto3" json:"decommissioning,omitempty"`
}

Liveness holds information about a node's latest heartbeat and epoch.

func (*Liveness) Descriptor

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

func (*Liveness) IsLive

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

IsLive returns whether the node is considered live at the given time with the given clock offset.

func (*Liveness) Marshal

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

func (*Liveness) MarshalTo

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

func (*Liveness) ProtoMessage

func (*Liveness) ProtoMessage()

func (*Liveness) Reset

func (m *Liveness) Reset()

func (*Liveness) Size

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

func (*Liveness) String

func (m *Liveness) String() string

func (*Liveness) Unmarshal

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

type LivenessMetrics

type LivenessMetrics struct {
	LiveNodes          *metric.Gauge
	HeartbeatSuccesses *metric.Counter
	HeartbeatFailures  *metric.Counter
	EpochIncrements    *metric.Counter
}

LivenessMetrics holds metrics for use with node liveness activity.

type LocalEvalResult

type LocalEvalResult struct {
	// The error resulting from the proposal. Most failing proposals will
	// fail-fast, i.e. will return an error to the client above Raft. However,
	// some proposals need to commit data even on error, and in that case we
	// treat the proposal like a successful one, except that the error stored
	// here will be sent to the client when the associated batch commits. In
	// the common case, this field is nil.
	Err   *roachpb.Error
	Reply *roachpb.BatchResponse
	// contains filtered or unexported fields
}

LocalEvalResult is data belonging to an evaluated command that is only used on the node on which the command was proposed. Note that the proposing node may die before the local results are processed, so any side effects here are only best-effort.

type MultiRaftClient

type MultiRaftClient interface {
	RaftMessageBatch(ctx context.Context, opts ...grpc.CallOption) (MultiRaft_RaftMessageBatchClient, error)
	RaftSnapshot(ctx context.Context, opts ...grpc.CallOption) (MultiRaft_RaftSnapshotClient, error)
}

func NewMultiRaftClient

func NewMultiRaftClient(cc *grpc.ClientConn) MultiRaftClient

type MultiRaftServer

type MultiRaftServer interface {
	RaftMessageBatch(MultiRaft_RaftMessageBatchServer) error
	RaftSnapshot(MultiRaft_RaftSnapshotServer) error
}

type MultiRaft_RaftMessageBatchClient

type MultiRaft_RaftMessageBatchClient interface {
	Send(*RaftMessageRequestBatch) error
	Recv() (*RaftMessageResponse, error)
	grpc.ClientStream
}

type MultiRaft_RaftMessageBatchServer

type MultiRaft_RaftMessageBatchServer interface {
	Send(*RaftMessageResponse) error
	Recv() (*RaftMessageRequestBatch, error)
	grpc.ServerStream
}

type MultiRaft_RaftSnapshotClient

type MultiRaft_RaftSnapshotClient interface {
	Send(*SnapshotRequest) error
	Recv() (*SnapshotResponse, error)
	grpc.ClientStream
}

type MultiRaft_RaftSnapshotServer

type MultiRaft_RaftSnapshotServer interface {
	Send(*SnapshotResponse) error
	Recv() (*SnapshotRequest, error)
	grpc.ServerStream
}

type NodeAddressResolver

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

NodeAddressResolver is the function used by RaftTransport to map node IDs to network addresses.

func GossipAddressResolver

func GossipAddressResolver(gossip *gossip.Gossip) NodeAddressResolver

GossipAddressResolver is a thin wrapper around gossip's GetNodeIDAddress that allows its return value to be used as the net.Addr interface.

type NodeLiveness

type NodeLiveness struct {
	// contains filtered or unexported fields
}

NodeLiveness encapsulates information on node liveness and provides an API for querying, updating, and invalidating node liveness. Nodes periodically "heartbeat" the range holding the node liveness system table to indicate that they're available. The resulting liveness information is used to ignore unresponsive nodes while making range quiescense decisions, as well as for efficient, node liveness epoch-based range leases.

func NewNodeLiveness

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

NewNodeLiveness returns a new instance of NodeLiveness configured with the specified gossip instance.

func (*NodeLiveness) DisableAllHeartbeatsForTest

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

DisableAllHeartbeatsForTest disables all node liveness heartbeats, including those triggered from outside the normal StartHeartbeat loop. Returns a closure to call to re-enable heartbeats. Only safe for use in tests.

func (*NodeLiveness) GetIsLiveMap

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

GetIsLiveMap returns a map of nodeID to boolean liveness status of each node.

func (*NodeLiveness) GetLiveness

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

GetLiveness returns the liveness record for the specified nodeID. ErrNoLivenessRecord is returned in the event that nothing is yet known about nodeID via liveness gossip.

func (*NodeLiveness) GetLivenessThreshold

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

GetLivenessThreshold returns the maximum duration between heartbeats before a node is considered not-live.

func (*NodeLiveness) GetLivenesses

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

GetLivenesses returns a slice containing the liveness status of every node on the cluster.

func (*NodeLiveness) Heartbeat

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

Heartbeat is called to update a node's expiration timestamp. This method does a conditional put on the node liveness record, and if successful, stores the updated liveness record in the nodes map.

func (*NodeLiveness) IncrementEpoch

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

IncrementEpoch is called to increment the current liveness epoch, thereby invalidating anything relying on the liveness of the previous epoch. This method does a conditional put on the node liveness record, and if successful, stores the updated liveness record in the nodes map. If this method is called on a node ID which is considered live according to the most recent information gathered through gossip, an error is returned.

func (*NodeLiveness) IsLive

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

IsLive returns whether or not the specified node is considered live based on the last receipt of a liveness update via gossip. It is an error if the specified node is not in the local liveness table.

func (*NodeLiveness) Metrics

func (nl *NodeLiveness) Metrics() LivenessMetrics

Metrics returns a struct which contains metrics related to node liveness activity.

func (*NodeLiveness) PauseHeartbeat

func (nl *NodeLiveness) PauseHeartbeat(pause bool)

PauseHeartbeat stops or restarts the periodic heartbeat depending on the pause parameter. When unpausing, triggers an immediate heartbeat.

func (*NodeLiveness) RegisterCallback

func (nl *NodeLiveness) RegisterCallback(cb IsLiveCallback)

RegisterCallback registers a callback to be invoked any time a node's IsLive() state changes to true.

func (*NodeLiveness) Self

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

Self returns the liveness record for this node. ErrNoLivenessRecord is returned in the event that the node has neither heartbeat its liveness record successfully, nor received a gossip message containing a former liveness update on restart.

func (*NodeLiveness) SetDecommissioning

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

SetDecommissioning runs a best-effort attempt of marking the the liveness record as decommissioning.

func (*NodeLiveness) SetDraining

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

SetDraining calls PauseHeartbeat with the given boolean and then attempts to update the liveness record.

func (*NodeLiveness) StartHeartbeat

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

StartHeartbeat starts a periodic heartbeat to refresh this node's last heartbeat in the node liveness table. The optionally provided HeartbeatCallback will be invoked whenever this node updates its own liveness.

type NodeLivenessFunc

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

A NodeLivenessFunc accepts a node ID, current time and threshold before a node is considered dead and returns whether or not the node is live.

func MakeStorePoolNodeLivenessFunc

func MakeStorePoolNodeLivenessFunc(nodeLiveness *NodeLiveness) NodeLivenessFunc

MakeStorePoolNodeLivenessFunc returns a function which determines the status of a node based on information provided by the specified NodeLiveness.

type NotBootstrappedError

type NotBootstrappedError struct{}

A NotBootstrappedError indicates that an engine has not yet been bootstrapped due to a store identifier not being present.

func (*NotBootstrappedError) Error

func (e *NotBootstrappedError) Error() string

Error formats error.

type OutgoingSnapshot

type OutgoingSnapshot struct {
	SnapUUID uuid.UUID
	// The Raft snapshot message to send. Contains SnapUUID as its data.
	RaftSnap raftpb.Snapshot
	// The RocksDB snapshot that will be streamed from.
	EngineSnap engine.Reader
	// The complete range iterator for the snapshot to stream.
	Iter *ReplicaDataIterator
	// The replica state within the snapshot.
	State storagebase.ReplicaState
	// Allows access the the original Replica's sideloaded storage. Note that
	// this isn't a snapshot of the sideloaded storage congruent with EngineSnap
	// or RaftSnap -- a log truncation could have removed files from the
	// sideloaded storage in the meantime.
	WithSideloaded func(func(sideloadStorage) error) error
	RaftEntryCache *raftEntryCache
}

OutgoingSnapshot contains the data required to stream a snapshot to a recipient. Once one is created, it needs to be closed via Close() to prevent resource leakage.

func (*OutgoingSnapshot) Close

func (s *OutgoingSnapshot) Close()

Close releases the resources associated with the snapshot.

type OutgoingSnapshotStream

type OutgoingSnapshotStream interface {
	Send(*SnapshotRequest) error
	Recv() (*SnapshotResponse, error)
}

OutgoingSnapshotStream is the minimal interface on a GRPC stream required to send a snapshot over the network.

type ProposalData

type ProposalData struct {

	// Local contains the results of evaluating the request
	// tying the upstream evaluation of the request to the
	// downstream application of the command.
	Local *LocalEvalResult

	// Request is the client's original BatchRequest.
	// TODO(tschottdorf): tests which use TestingCommandFilter use this.
	// Decide how that will work in the future, presumably the
	// CommandFilter would run at proposal time or we allow an opaque
	// struct to be attached to a proposal which is then available as it
	// applies. Other than tests, we only need a few bits of the request
	// here; this could be replaced with isLease and isChangeReplicas
	// booleans.
	Request *roachpb.BatchRequest
	// contains filtered or unexported fields
}

ProposalData is data about a command which allows it to be evaluated, proposed to raft, and for the result of the command to be returned to the caller.

type RaftHeartbeat

type RaftHeartbeat struct {
	RangeID       github_com_cockroachdb_cockroach_pkg_roachpb.RangeID   "" /* 128 byte string literal not displayed */
	FromReplicaID github_com_cockroachdb_cockroach_pkg_roachpb.ReplicaID "" /* 150 byte string literal not displayed */
	ToReplicaID   github_com_cockroachdb_cockroach_pkg_roachpb.ReplicaID "" /* 144 byte string literal not displayed */
	Term          uint64                                                 `protobuf:"varint,4,opt,name=term" json:"term"`
	Commit        uint64                                                 `protobuf:"varint,5,opt,name=commit" json:"commit"`
	Quiesce       bool                                                   `protobuf:"varint,6,opt,name=quiesce" json:"quiesce"`
}

RaftHeartbeat is a request that contains the barebones information for a raftpb.MsgHeartbeat raftpb.Message. RaftHeartbeats are coalesced and sent in a RaftMessageRequest, and reconstructed by the receiver into individual raftpb.Message protos.

func (*RaftHeartbeat) Descriptor

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

func (*RaftHeartbeat) Marshal

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

func (*RaftHeartbeat) MarshalTo

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

func (*RaftHeartbeat) ProtoMessage

func (*RaftHeartbeat) ProtoMessage()

func (*RaftHeartbeat) Reset

func (m *RaftHeartbeat) Reset()

func (*RaftHeartbeat) Size

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

func (*RaftHeartbeat) String

func (m *RaftHeartbeat) String() string

func (*RaftHeartbeat) Unmarshal

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

type RaftMessageHandler

type RaftMessageHandler interface {
	// HandleRaftRequest is called for each incoming Raft message. If it returns
	// an error it will be streamed back to the sender of the message as a
	// RaftMessageResponse. If the stream parameter is nil the request should be
	// processed synchronously. If the stream is non-nil the request can be
	// processed asynchronously and any error should be sent on the stream.
	HandleRaftRequest(ctx context.Context, req *RaftMessageRequest,
		respStream RaftMessageResponseStream) *roachpb.Error

	// HandleRaftResponse is called for each raft response. Note that
	// not all messages receive a response. An error is returned if and only if
	// the underlying Raft connection should be closed.
	HandleRaftResponse(context.Context, *RaftMessageResponse) error

	// HandleSnapshot is called for each new incoming snapshot stream, after
	// parsing the initial SnapshotRequest_Header on the stream.
	HandleSnapshot(header *SnapshotRequest_Header, respStream SnapshotResponseStream) error
}

RaftMessageHandler is the interface that must be implemented by arguments to RaftTransport.Listen.

type RaftMessageRequest

type RaftMessageRequest struct {
	RangeID     github_com_cockroachdb_cockroach_pkg_roachpb.RangeID "" /* 128 byte string literal not displayed */
	FromReplica cockroach_roachpb.ReplicaDescriptor                  `protobuf:"bytes,2,opt,name=from_replica,json=fromReplica" json:"from_replica"`
	ToReplica   cockroach_roachpb.ReplicaDescriptor                  `protobuf:"bytes,3,opt,name=to_replica,json=toReplica" json:"to_replica"`
	Message     raftpb.Message                                       `protobuf:"bytes,4,opt,name=message" json:"message"`

	Quiesce bool `protobuf:"varint,5,opt,name=quiesce" json:"quiesce"`

	Heartbeats     []RaftHeartbeat `protobuf:"bytes,6,rep,name=heartbeats" json:"heartbeats"`
	HeartbeatResps []RaftHeartbeat `protobuf:"bytes,7,rep,name=heartbeat_resps,json=heartbeatResps" json:"heartbeat_resps"`
}

RaftMessageRequest is the request used to send raft messages using our protobuf-based RPC codec. If a RaftMessageRequest has a non-empty number of heartbeats or heartbeat_resps, the contents of the message field is treated as a dummy message and discarded. A coalesced heartbeat request's replica descriptor's range ID must be zero.

func (*RaftMessageRequest) Descriptor

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

func (*RaftMessageRequest) GetUser

func (*RaftMessageRequest) GetUser() string

GetUser implements security.RequestWithUser. Raft messages are always sent by the node user.

func (*RaftMessageRequest) Marshal

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

func (*RaftMessageRequest) MarshalTo

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

func (*RaftMessageRequest) ProtoMessage

func (*RaftMessageRequest) ProtoMessage()

func (*RaftMessageRequest) Reset

func (m *RaftMessageRequest) Reset()

func (*RaftMessageRequest) Size

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

func (*RaftMessageRequest) String

func (m *RaftMessageRequest) String() string

func (*RaftMessageRequest) Unmarshal

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

type RaftMessageRequestBatch

type RaftMessageRequestBatch struct {
	Requests []RaftMessageRequest `protobuf:"bytes,1,rep,name=requests" json:"requests"`
}

func (*RaftMessageRequestBatch) Descriptor

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

func (*RaftMessageRequestBatch) Marshal

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

func (*RaftMessageRequestBatch) MarshalTo

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

func (*RaftMessageRequestBatch) ProtoMessage

func (*RaftMessageRequestBatch) ProtoMessage()

func (*RaftMessageRequestBatch) Reset

func (m *RaftMessageRequestBatch) Reset()

func (*RaftMessageRequestBatch) Size

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

func (*RaftMessageRequestBatch) String

func (m *RaftMessageRequestBatch) String() string

func (*RaftMessageRequestBatch) Unmarshal

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

type RaftMessageResponse

type RaftMessageResponse struct {
	RangeID     github_com_cockroachdb_cockroach_pkg_roachpb.RangeID "" /* 128 byte string literal not displayed */
	FromReplica cockroach_roachpb.ReplicaDescriptor                  `protobuf:"bytes,2,opt,name=from_replica,json=fromReplica" json:"from_replica"`
	ToReplica   cockroach_roachpb.ReplicaDescriptor                  `protobuf:"bytes,3,opt,name=to_replica,json=toReplica" json:"to_replica"`
	Union       RaftMessageResponseUnion                             `protobuf:"bytes,4,opt,name=union" json:"union"`
}

RaftMessageResponse may be sent to the sender of a RaftMessageRequest. RaftMessage does not use the usual request/response pattern; it is primarily modeled as a one-way stream of requests. Normal 'responses' are usually sent as new requests on a separate stream in the other direction. RaftMessageResponse is not sent for every RaftMessageRequest, but may be used for certain error conditions.

func (*RaftMessageResponse) Descriptor

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

func (*RaftMessageResponse) Marshal

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

func (*RaftMessageResponse) MarshalTo

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

func (*RaftMessageResponse) ProtoMessage

func (*RaftMessageResponse) ProtoMessage()

func (*RaftMessageResponse) Reset

func (m *RaftMessageResponse) Reset()

func (*RaftMessageResponse) Size

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

func (*RaftMessageResponse) String

func (m *RaftMessageResponse) String() string

func (*RaftMessageResponse) Unmarshal

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

type RaftMessageResponseStream

type RaftMessageResponseStream interface {
	Context() context.Context
	Send(*RaftMessageResponse) error
}

RaftMessageResponseStream is the subset of the MultiRaft_RaftMessageServer interface that is needed for sending responses.

type RaftMessageResponseUnion

type RaftMessageResponseUnion struct {
	Error *cockroach_roachpb3.Error `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
}

func (*RaftMessageResponseUnion) Descriptor

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

func (*RaftMessageResponseUnion) GetValue

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

func (*RaftMessageResponseUnion) Marshal

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

func (*RaftMessageResponseUnion) MarshalTo

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

func (*RaftMessageResponseUnion) ProtoMessage

func (*RaftMessageResponseUnion) ProtoMessage()

func (*RaftMessageResponseUnion) Reset

func (m *RaftMessageResponseUnion) Reset()

func (*RaftMessageResponseUnion) SetValue

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

func (*RaftMessageResponseUnion) Size

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

func (*RaftMessageResponseUnion) String

func (m *RaftMessageResponseUnion) String() string

func (*RaftMessageResponseUnion) Unmarshal

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

type RaftTransport

type RaftTransport struct {
	log.AmbientContext
	// contains filtered or unexported fields
}

RaftTransport handles the rpc messages for raft.

The raft transport is asynchronous with respect to the caller, and internally multiplexes outbound messages. Internally, each message is queued on a per-destination queue before being asynchronously delivered.

Callers are required to construct a RaftSender before being able to dispatch messages, and must provide an error handler which will be invoked asynchronously in the event that the recipient of any message closes its inbound RPC stream. This callback is asynchronous with respect to the outbound message which caused the remote to hang up; all that is known is which remote hung up.

func NewDummyRaftTransport

func NewDummyRaftTransport(st *cluster.Settings) *RaftTransport

NewDummyRaftTransport returns a dummy raft transport for use in tests which need a non-nil raft transport that need not function.

func NewRaftTransport

func NewRaftTransport(
	ambient log.AmbientContext,
	st *cluster.Settings,
	resolver NodeAddressResolver,
	grpcServer *grpc.Server,
	rpcContext *rpc.Context,
) *RaftTransport

NewRaftTransport creates a new RaftTransport.

func (*RaftTransport) GetCircuitBreaker

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

GetCircuitBreaker returns the circuit breaker controlling connection attempts to the specified node.

func (*RaftTransport) Listen

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

Listen registers a raftMessageHandler to receive proxied messages.

func (*RaftTransport) RaftMessageBatch

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

RaftMessageBatch proxies the incoming requests to the listening server interface.

func (*RaftTransport) RaftSnapshot

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

RaftSnapshot handles incoming streaming snapshot requests.

func (*RaftTransport) SendAsync

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

SendAsync sends a message to the recipient specified in the request. It returns false if the outgoing queue is full and calls s.onError when the recipient closes the stream.

func (*RaftTransport) SendSnapshot

func (t *RaftTransport) SendSnapshot(
	ctx context.Context,
	storePool *StorePool,
	header SnapshotRequest_Header,
	snap *OutgoingSnapshot,
	newBatch func() engine.Batch,
	sent func(),
) error

SendSnapshot streams the given outgoing snapshot. The caller is responsible for closing the OutgoingSnapshot.

func (*RaftTransport) Stop

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

Stop unregisters a raftMessageHandler.

type RangeInfo

type RangeInfo struct {
	Desc            *roachpb.RangeDescriptor
	LogicalBytes    int64
	WritesPerSecond float64
}

RangeInfo contains the information needed by the allocator to make rebalancing decisions for a given range.

type RangeLogEvent

type RangeLogEvent struct {
	Timestamp    time.Time                                            `protobuf:"bytes,1,opt,name=timestamp,stdtime" json:"timestamp"`
	RangeID      github_com_cockroachdb_cockroach_pkg_roachpb.RangeID "" /* 145 byte string literal not displayed */
	StoreID      github_com_cockroachdb_cockroach_pkg_roachpb.StoreID "" /* 145 byte string literal not displayed */
	EventType    RangeLogEventType                                    "" /* 130 byte string literal not displayed */
	OtherRangeID github_com_cockroachdb_cockroach_pkg_roachpb.RangeID "" /* 162 byte string literal not displayed */
	Info         *RangeLogEvent_Info                                  `protobuf:"bytes,6,opt,name=info" json:"info,omitempty"`
}

func (*RangeLogEvent) Descriptor

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

func (*RangeLogEvent) Marshal

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

func (*RangeLogEvent) MarshalTo

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

func (*RangeLogEvent) ProtoMessage

func (*RangeLogEvent) ProtoMessage()

func (*RangeLogEvent) Reset

func (m *RangeLogEvent) Reset()

func (*RangeLogEvent) Size

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

func (*RangeLogEvent) String

func (m *RangeLogEvent) String() string

func (*RangeLogEvent) Unmarshal

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

type RangeLogEventReason

type RangeLogEventReason string

RangeLogEventReason specifies the reason why a range-log event happened.

const (
	ReasonUnknown              RangeLogEventReason = ""
	ReasonRangeUnderReplicated RangeLogEventReason = "range under-replicated"
	ReasonRangeOverReplicated  RangeLogEventReason = "range over-replicated"
	ReasonStoreDead            RangeLogEventReason = "store dead"
	ReasonStoreDecommissioning RangeLogEventReason = "store decommissioning"
	ReasonRebalance            RangeLogEventReason = "rebalance"
	ReasonAdminRequest         RangeLogEventReason = "admin request"
)

The set of possible reasons for range events to happen.

type RangeLogEventType

type RangeLogEventType int32
const (
	// These are lower case to maintain compatibility with how they were
	// originally stored.
	// Split is the event type recorded when a range splits.
	RangeLogEventType_split RangeLogEventType = 0
	// Add is the event type recorded when a range adds a new replica.
	RangeLogEventType_add RangeLogEventType = 1
	// Remove is the event type recorded when a range removed an existing replica.
	RangeLogEventType_remove RangeLogEventType = 2
)

func (RangeLogEventType) EnumDescriptor

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

func (RangeLogEventType) String

func (x RangeLogEventType) String() string

type RangeLogEvent_Info

type RangeLogEvent_Info struct {
	UpdatedDesc    *cockroach_roachpb.RangeDescriptor   `protobuf:"bytes,1,opt,name=updated_desc,json=updatedDesc" json:"UpdatedDesc"`
	NewDesc        *cockroach_roachpb.RangeDescriptor   `protobuf:"bytes,2,opt,name=new_desc,json=newDesc" json:"NewDesc"`
	AddedReplica   *cockroach_roachpb.ReplicaDescriptor `protobuf:"bytes,3,opt,name=added_replica,json=addedReplica" json:"AddReplica"`
	RemovedReplica *cockroach_roachpb.ReplicaDescriptor `protobuf:"bytes,4,opt,name=removed_replica,json=removedReplica" json:"RemovedReplica"`
	Reason         RangeLogEventReason                  `protobuf:"bytes,5,opt,name=reason,proto3,casttype=RangeLogEventReason" json:"Reason"`
	Details        string                               `protobuf:"bytes,6,opt,name=details,proto3" json:"Details"`
}

func (*RangeLogEvent_Info) Descriptor

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

func (*RangeLogEvent_Info) Marshal

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

func (*RangeLogEvent_Info) MarshalTo

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

func (*RangeLogEvent_Info) ProtoMessage

func (*RangeLogEvent_Info) ProtoMessage()

func (*RangeLogEvent_Info) Reset

func (m *RangeLogEvent_Info) Reset()

func (*RangeLogEvent_Info) Size

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

func (*RangeLogEvent_Info) String

func (m *RangeLogEvent_Info) String() string

func (*RangeLogEvent_Info) Unmarshal

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

type Replica

type Replica struct {
	log.AmbientContext

	// TODO(tschottdorf): Duplicates r.mu.state.desc.RangeID; revisit that.
	RangeID roachpb.RangeID // Should only be set by the constructor.
	// contains filtered or unexported fields
}

A Replica is a contiguous keyspace with writes managed via an instance of the Raft consensus algorithm. Many ranges may exist in a store and they are unlikely to be contiguous. Ranges are independent units and are responsible for maintaining their own integrity by replacing failed replicas, splitting and merging as appropriate.

func NewReplica

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

NewReplica initializes the replica using the given metadata. If the replica is initialized (i.e. desc contains more than a RangeID), replicaID should be 0 and the replicaID will be discovered from the descriptor.

func (*Replica) AdminMerge

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

AdminMerge extends this range to subsume the range that comes next in the key space. The merge is performed inside of a distributed transaction which writes the left hand side range descriptor (the subsuming range) and deletes the range descriptor for the right hand side range (the subsumed range). It also updates the range addressing metadata. The handover of responsibility for the reassigned key range is carried out seamlessly through a merge trigger carried out as part of the commit of that transaction. A merge requires that the two ranges are collocated on the same set of replicas.

The supplied RangeDescriptor is used as a form of optimistic lock. See the comment of "AdminSplit" for more information on this pattern.

func (*Replica) AdminSplit

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

AdminSplit divides the range into into two ranges using args.SplitKey.

func (*Replica) AdminTransferLease

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

AdminTransferLease transfers the LeaderLease to another replica. A valid LeaseStatus must be supplied. Only the current holder of the LeaderLease can do a transfer, because it needs to stop serving reads and proposing Raft commands (CPut is a read) after sending the transfer command. If it did not stop serving reads immediately, it would potentially serve reads with timestamps greater than the start timestamp of the new (transferred) lease. More subtly, the replica can't even serve reads or propose commands with timestamps lower than the start of the new lease because it could lead to read your own write violations (see comments on the stasis period in IsLeaseValid). We could, in principle, serve reads more than the maximum clock offset in the past.

The method waits for any in-progress lease extension to be done, and it also blocks until the transfer is done. If a transfer is already in progress, this method joins in waiting for it to complete if it's transferring to the same replica. Otherwise, a NotLeaseHolderError is returned.

func (*Replica) ChangeReplicas

func (r *Replica) ChangeReplicas(
	ctx context.Context,
	changeType roachpb.ReplicaChangeType,
	target roachpb.ReplicationTarget,
	desc *roachpb.RangeDescriptor,
	reason RangeLogEventReason,
	details string,
) error

ChangeReplicas adds or removes a replica of a range. The change is performed in a distributed transaction and takes effect when that transaction is committed. When removing a replica, only the NodeID and StoreID fields of the Replica are used.

The supplied RangeDescriptor is used as a form of optimistic lock. See the comment of "adminSplitWithDescriptor" for more information on this pattern.

Changing the replicas for a range is complicated. A change is initiated by the "replicate" queue when it encounters a range which has too many replicas, too few replicas or requires rebalancing. Addition and removal of a replica is divided into four phases. The first phase, which occurs in Replica.ChangeReplicas, is performed via a distributed transaction which updates the range descriptor and the meta range addressing information. This transaction includes a special ChangeReplicasTrigger on the EndTransaction request. A ConditionalPut of the RangeDescriptor implements the optimistic lock on the RangeDescriptor mentioned previously. Like all transactions, the requests within the transaction are replicated via Raft, including the EndTransaction request.

The second phase of processing occurs when the batch containing the EndTransaction is proposed to raft. This proposing occurs on whatever replica received the batch, usually, but not always the range lease holder. defaultProposeRaftCommandLocked notices that the EndTransaction contains a ChangeReplicasTrigger and proposes a ConfChange to Raft (via raft.RawNode.ProposeConfChange).

The ConfChange is propagated to all of the replicas similar to a normal Raft command, though additional processing is done inside of Raft. A Replica encounters the ConfChange in Replica.handleRaftReady and executes it using raft.RawNode.ApplyConfChange. If a new replica was added the Raft leader will start sending it heartbeat messages and attempting to bring it up to date. If a replica was removed, it is at this point that the Raft leader will stop communicating with it.

The fourth phase of change replicas occurs when each replica for the range encounters the ChangeReplicasTrigger when applying the EndTransaction request. The replica will update its local range descriptor so as to contain the new set of replicas. If the replica is the one that is being removed, it will queue itself for removal with replicaGCQueue.

Note that a removed replica may not see the EndTransaction containing the ChangeReplicasTrigger. The ConfChange operation will be applied as soon as a quorum of nodes have committed it. If the removed replica is down or the message is dropped for some reason the removed replica will not be notified. The replica GC queue will eventually discover and cleanup this state.

When a new replica is added, it will have to catch up to the state of the other replicas. The Raft leader automatically handles this by either sending the new replica Raft log entries to apply, or by generating and sending a snapshot. See Replica.Snapshot and Replica.Entries.

Note that Replica.ChangeReplicas returns when the distributed transaction has been committed to a quorum of replicas in the range. The actual replication of data occurs asynchronously via a snapshot or application of Raft log entries. This is important for the replicate queue to be aware of. A node can process hundreds or thousands of ChangeReplicas operations per second even though the actual replication of data proceeds at a much slower base. In order to avoid having this background replication overwhelm the system, replication is throttled via a reservation system. When allocating a new replica for a range, the replicate queue reserves space for that replica on the target store via a ReservationRequest. (See StorePool.reserve). The reservation is fulfilled when the snapshot is applied.

TODO(peter): There is a rare scenario in which a replica can be brought up to date via Raft log replay. In this scenario, the reservation will be left dangling until it expires. See #7849.

TODO(peter): Describe preemptive snapshots. Preemptive snapshots are needed for the replicate queue to function properly. Currently the replicate queue will fire off as many replica additions as possible until it starts getting reservations denied at which point it will ignore the replica until the next scanner cycle.

func (*Replica) CheckConsistency

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

CheckConsistency runs a consistency check on the range. It first applies a ComputeChecksum command on the range. It then issues CollectChecksum commands to the other replicas.

TODO(tschottdorf): We should call this AdminCheckConsistency.

func (*Replica) ContainsKey

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

ContainsKey returns whether this range contains the specified key.

TODO(bdarnell): This is not the same as RangeDescriptor.ContainsKey.

func (*Replica) ContainsKeyRange

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

ContainsKeyRange returns whether this range contains the specified key range from start to end.

func (*Replica) Desc

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

Desc returns the authoritative range descriptor, acquiring a replica lock in the process.

func (*Replica) GetFirstIndex

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

GetFirstIndex is the same function as raftFirstIndexLocked but it requires that r.mu is not held.

func (*Replica) GetLeaseHistory

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

GetLeaseHistory returns the lease history stored on this replica.

func (*Replica) GetMVCCStats

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

GetMVCCStats returns a copy of the MVCC stats object for this range.

func (*Replica) GetMaxBytes

func (r *Replica) GetMaxBytes() int64

GetMaxBytes gets the range maximum byte limit.

func (*Replica) GetReplicaDescriptor

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

GetReplicaDescriptor returns the replica for this range from the range descriptor. Returns a *RangeNotFoundError if the replica is not found. No other errors are returned.

func (*Replica) GetSnapshot

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

GetSnapshot returns a snapshot of the replica appropriate for sending to a replica. If this method returns without error, callers must eventually call OutgoingSnapshot.Close.

func (*Replica) IsDestroyed

func (r *Replica) IsDestroyed() error

IsDestroyed returns a non-nil error if the replica has been destroyed.

func (*Replica) IsFirstRange

func (r *Replica) IsFirstRange() bool

IsFirstRange returns true if this is the first range.

func (*Replica) IsInitialized

func (r *Replica) IsInitialized() bool

IsInitialized is true if we know the metadata of this range, either because we created it or we have received an initial snapshot from another node. It is false when a range has been created in response to an incoming message but we are waiting for our initial snapshot.

func (*Replica) IsLeaseValid

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

IsLeaseValid returns true if the replica's lease is owned by this replica and is valid (not expired, not in stasis).

func (*Replica) LastReplicaAdded

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

LastReplicaAdded returns the ID of the most recently added replica and the time at which it was added.

func (*Replica) Less

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

Less implements the btree.Item interface.

func (*Replica) Metrics

func (r *Replica) Metrics(
	ctx context.Context,
	now hlc.Timestamp,
	cfg config.SystemConfig,
	livenessMap map[roachpb.NodeID]bool,
) ReplicaMetrics

Metrics returns the current metrics for the replica.

func (*Replica) NodeID

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

NodeID returns the ID of the node this replica belongs to.

func (*Replica) OwnsValidLease

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

OwnsValidLease returns whether this replica is the current valid leaseholder. Note that this method does not check to see if a transfer is pending, but returns the status of the current lease and ownership at the specified point in time.

func (*Replica) QueriesPerSecond

func (r *Replica) QueriesPerSecond() float64

QueriesPerSecond returns the range's average QPS if it is the current leaseholder. If it isn't, this will return 0 because the replica does not know about the reads that the leaseholder is serving.

func (*Replica) RaftStatus

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

RaftStatus returns the current raft status of the replica. It returns nil if the Raft group has not been initialized yet.

func (*Replica) Send

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

Send executes a command on this range, dispatching it to the read-only, read-write, or admin execution path as appropriate. ctx should contain the log tags from the store (and up).

func (*Replica) SetMaxBytes

func (r *Replica) SetMaxBytes(maxBytes int64)

SetMaxBytes sets the maximum byte limit before split.

func (*Replica) State

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

State returns a copy of the internal state of the Replica, along with some auxiliary information.

func (*Replica) String

func (r *Replica) String() string

String returns the string representation of the replica using an inconsistent copy of the range descriptor. Therefore, String does not require a lock and its output may not be atomic with other ongoing work in the replica. This is done to prevent deadlocks in logging sites.

func (*Replica) WritesPerSecond

func (r *Replica) WritesPerSecond() float64

WritesPerSecond returns the range's average keys written per second.

type ReplicaDataIterator

type ReplicaDataIterator struct {
	// contains filtered or unexported fields
}

ReplicaDataIterator provides a complete iteration over all key / value rows in a range, including all system-local metadata and user data. The ranges keyRange slice specifies the key ranges which comprise all of the range's data.

A ReplicaDataIterator provides a subset of the engine.Iterator interface.

func NewReplicaDataIterator

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

NewReplicaDataIterator creates a ReplicaDataIterator for the given replica.

func (*ReplicaDataIterator) Close

func (ri *ReplicaDataIterator) Close()

Close the underlying iterator.

func (*ReplicaDataIterator) Key

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

Key returns the current key.

func (*ReplicaDataIterator) Next

func (ri *ReplicaDataIterator) Next()

Next advances to the next key in the iteration.

func (*ReplicaDataIterator) Valid

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

Valid returns true if the iterator currently points to a valid value.

func (*ReplicaDataIterator) Value

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

Value returns the current value.

type ReplicaEvalContext

type ReplicaEvalContext struct {
	// contains filtered or unexported fields
}

ReplicaEvalContext is the interface through which command evaluation accesses the in-memory state of a Replica. Any state that corresponds to (mutable) on-disk data must be registered in the SpanSet if one is given.

func (ReplicaEvalContext) AbortCache

func (rec ReplicaEvalContext) AbortCache() *AbortCache

AbortCache returns the Replica's AbortCache.

func (ReplicaEvalContext) ClusterSettings

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

ClusterSettings returns the node's ClusterSettings.

func (ReplicaEvalContext) ContainsKey

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

ContainsKey returns true if the given key is within the Replica's range.

TODO(bdarnell): Replace this method with one on Desc(). See comment on Replica.ContainsKey.

func (ReplicaEvalContext) DB

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

DB returns the Replica's client DB.

func (ReplicaEvalContext) Desc

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

Desc returns the Replica's RangeDescriptor.

func (ReplicaEvalContext) Engine

func (rec ReplicaEvalContext) Engine() engine.Engine

Engine returns the Replica's underlying Engine. In most cases the evaluation Batch should be used instead.

func (ReplicaEvalContext) FirstIndex

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

FirstIndex returns the oldest index in the raft log.

func (ReplicaEvalContext) GCThreshold

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

GCThreshold returns the GC threshold of the Range, typically updated when keys are garbage collected. Reads and writes at timestamps <= this time will not be served.

func (ReplicaEvalContext) GetLastReplicaGCTimestamp

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

GetLastReplicaGCTimestamp returns the last time the Replica was considered for GC.

func (ReplicaEvalContext) GetLease

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

GetLease returns the Replica's current and next lease (if any).

func (ReplicaEvalContext) GetMVCCStats

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

GetMVCCStats returns the Replica's MVCCStats.

func (ReplicaEvalContext) IsFirstRange

func (rec ReplicaEvalContext) IsFirstRange() bool

IsFirstRange returns true if this replica is the first range in the system.

func (ReplicaEvalContext) NodeID

func (rec ReplicaEvalContext) NodeID() roachpb.NodeID

NodeID returns the Replica's NodeID.

func (ReplicaEvalContext) RangeID

func (rec ReplicaEvalContext) RangeID() roachpb.RangeID

RangeID returns the Replica's RangeID.

func (ReplicaEvalContext) StoreID

func (rec ReplicaEvalContext) StoreID() roachpb.StoreID

StoreID returns the Replica's StoreID.

func (ReplicaEvalContext) StoreTestingKnobs

func (rec ReplicaEvalContext) StoreTestingKnobs() StoreTestingKnobs

StoreTestingKnobs returns the Replica's StoreTestingKnobs.

func (ReplicaEvalContext) String

func (rec ReplicaEvalContext) String() string

String returns a string representation of the Replica.

func (ReplicaEvalContext) Term

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

Term returns the term of the given entry in the raft log.

func (ReplicaEvalContext) Tracer

func (rec ReplicaEvalContext) Tracer() opentracing.Tracer

Tracer returns the Replica's Tracer.

func (ReplicaEvalContext) TxnSpanGCThreshold

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

TxnSpanGCThreshold returns the time of the Replica's last transaction span GC.

type ReplicaGCQueueMetrics

type ReplicaGCQueueMetrics struct {
	RemoveReplicaCount *metric.Counter
}

ReplicaGCQueueMetrics is the set of metrics for the replica GC queue.

type ReplicaMetrics

type ReplicaMetrics struct {
	Leader      bool
	LeaseValid  bool
	Leaseholder bool
	LeaseType   roachpb.LeaseType
	LeaseStatus LeaseStatus
	Quiescent   bool
	// Is this the replica which collects per-range metrics? This is done either
	// on the leader or, if there is no leader, on the largest live replica ID.
	RangeCounter      bool
	Unavailable       bool
	Underreplicated   bool
	BehindCount       int64
	SelfBehindCount   int64
	CmdQMetricsLocal  CommandQueueMetrics
	CmdQMetricsGlobal CommandQueueMetrics
}

ReplicaMetrics contains details on the current status of the replica.

type ReplicaPlaceholder

type ReplicaPlaceholder struct {
	// contains filtered or unexported fields
}

ReplicaPlaceholder is created by a Store in anticipation of replacing it at some point in the future with a Replica. It has a RangeDescriptor.

func (*ReplicaPlaceholder) Desc

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

Desc returns the range Placeholder's descriptor.

func (*ReplicaPlaceholder) Less

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

Less implements the btree.Item interface.

func (*ReplicaPlaceholder) String

func (r *ReplicaPlaceholder) String() string

type ReplicaSnapshotDiff

type ReplicaSnapshotDiff struct {
	// LeaseHolder is set to true of this k:v pair is only present on the lease
	// holder.
	LeaseHolder bool
	Key         roachpb.Key
	Timestamp   hlc.Timestamp
	Value       []byte
}

ReplicaSnapshotDiff is a part of a []ReplicaSnapshotDiff which represents a diff between two replica snapshots. For now it's only a diff between their KV pairs.

type ReplicaSnapshotDiffSlice

type ReplicaSnapshotDiffSlice []ReplicaSnapshotDiff

ReplicaSnapshotDiffSlice groups multiple ReplicaSnapshotDiff records and exposes a formatting helper.

func (ReplicaSnapshotDiffSlice) String

func (rsds ReplicaSnapshotDiffSlice) String() string

func (ReplicaSnapshotDiffSlice) WriteTo

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

WriteTo writes a string representation of itself to the given writer.

type ReplicateQueueMetrics

type ReplicateQueueMetrics struct {
	AddReplicaCount        *metric.Counter
	RemoveReplicaCount     *metric.Counter
	RemoveDeadReplicaCount *metric.Counter
	RebalanceReplicaCount  *metric.Counter
	TransferLeaseCount     *metric.Counter
}

ReplicateQueueMetrics is the set of metrics for the replicate queue.

type ResolveOptions

type ResolveOptions struct {
	// Resolve intents synchronously. When set to `false`, requests a
	// semi-synchronous operation, returning when all local commands have
	// been *proposed* but not yet committed or executed. This ensures that
	// if a waiting client retries immediately after calling this function,
	// it will not hit the same intents again.
	//
	// TODO(bdarnell): Note that this functionality has been removed and
	// will be ignored, pending resolution of #8360.
	Wait   bool
	Poison bool
}

ResolveOptions is used during intent resolution. It specifies whether the caller wants the call to block, and whether the ranges containing the intents are to be poisoned.

type Server

type Server struct {
	// contains filtered or unexported fields
}

Server implements ConsistencyServer.

func MakeServer

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

MakeServer returns a new instance of Server.

func (Server) CollectChecksum

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

CollectChecksum implements ConsistencyServer.

type SnapshotRequest

type SnapshotRequest struct {
	Header *SnapshotRequest_Header `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
	// A RocksDB BatchRepr. Multiple kv_batches may be sent across multiple request messages.
	KVBatch []byte `protobuf:"bytes,2,opt,name=kv_batch,json=kvBatch" json:"kv_batch,omitempty"`
	// These are really raftpb.Entry, but we model them as raw bytes to avoid
	// roundtripping through memory. They are separate from the kv_batch to
	// allow flexibility in log implementations.
	LogEntries [][]byte `protobuf:"bytes,3,rep,name=log_entries,json=logEntries" json:"log_entries,omitempty"`
	Final      bool     `protobuf:"varint,4,opt,name=final" json:"final"`
}

SnapshotRequest is the request used to send streaming snapshot requests.

func (*SnapshotRequest) Descriptor

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

func (*SnapshotRequest) Marshal

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

func (*SnapshotRequest) MarshalTo

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

func (*SnapshotRequest) ProtoMessage

func (*SnapshotRequest) ProtoMessage()

func (*SnapshotRequest) Reset

func (m *SnapshotRequest) Reset()

func (*SnapshotRequest) Size

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

func (*SnapshotRequest) String

func (m *SnapshotRequest) String() string

func (*SnapshotRequest) Unmarshal

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

type SnapshotRequest_Header

type SnapshotRequest_Header struct {
	// The replica state at the time the snapshot was generated. Note
	// that ReplicaState.Desc differs from the above range_descriptor
	// field which holds the updated descriptor after the new replica
	// has been added while ReplicaState.Desc holds the descriptor
	// before the new replica has been added.
	State cockroach_storage_storagebase.ReplicaState `protobuf:"bytes,5,opt,name=state" json:"state"`
	// The inner raft message is of type MsgSnap, and its snapshot data contains a UUID.
	RaftMessageRequest RaftMessageRequest `protobuf:"bytes,2,opt,name=raft_message_request,json=raftMessageRequest" json:"raft_message_request"`
	// The estimated size of the range, to be used in reservation decisions.
	RangeSize int64 `protobuf:"varint,3,opt,name=range_size,json=rangeSize" json:"range_size"`
	// can_decline is set on preemptive snapshots, but not those generated
	// by raft because at that point it is better to queue up the stream
	// than to cancel it.
	CanDecline bool `protobuf:"varint,4,opt,name=can_decline,json=canDecline" json:"can_decline"`
	// The priority of the snapshot.
	Priority SnapshotRequest_Priority `protobuf:"varint,6,opt,name=priority,enum=cockroach.storage.SnapshotRequest_Priority" json:"priority"`
}

func (*SnapshotRequest_Header) Descriptor

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

func (*SnapshotRequest_Header) Marshal

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

func (*SnapshotRequest_Header) MarshalTo

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

func (*SnapshotRequest_Header) ProtoMessage

func (*SnapshotRequest_Header) ProtoMessage()

func (*SnapshotRequest_Header) Reset

func (m *SnapshotRequest_Header) Reset()

func (*SnapshotRequest_Header) Size

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

func (*SnapshotRequest_Header) String

func (m *SnapshotRequest_Header) String() string

func (*SnapshotRequest_Header) Unmarshal

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

type SnapshotRequest_Priority

type SnapshotRequest_Priority int32
const (
	SnapshotRequest_UNKNOWN SnapshotRequest_Priority = 0
	// RECOVERY is used for a Raft-initiated snapshots and for
	// up-replication snapshots (i.e. when a dead node has been
	// removed and the range needs to be up-replicated).
	SnapshotRequest_RECOVERY SnapshotRequest_Priority = 1
	// REBALANCE is used for snapshots involved in rebalancing.
	SnapshotRequest_REBALANCE SnapshotRequest_Priority = 2
)

func (SnapshotRequest_Priority) Enum

func (x SnapshotRequest_Priority) Enum() *SnapshotRequest_Priority

func (SnapshotRequest_Priority) EnumDescriptor

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

func (SnapshotRequest_Priority) String

func (x SnapshotRequest_Priority) String() string

func (*SnapshotRequest_Priority) UnmarshalJSON

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

type SnapshotResponse

type SnapshotResponse struct {
	Status  SnapshotResponse_Status `protobuf:"varint,1,opt,name=status,enum=cockroach.storage.SnapshotResponse_Status" json:"status"`
	Message string                  `protobuf:"bytes,2,opt,name=message" json:"message"`
}

func (*SnapshotResponse) Descriptor

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

func (*SnapshotResponse) Marshal

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

func (*SnapshotResponse) MarshalTo

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

func (*SnapshotResponse) ProtoMessage

func (*SnapshotResponse) ProtoMessage()

func (*SnapshotResponse) Reset

func (m *SnapshotResponse) Reset()

func (*SnapshotResponse) Size

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

func (*SnapshotResponse) String

func (m *SnapshotResponse) String() string

func (*SnapshotResponse) Unmarshal

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

type SnapshotResponseStream

type SnapshotResponseStream interface {
	Context() context.Context
	Send(*SnapshotResponse) error
	Recv() (*SnapshotRequest, error)
}

SnapshotResponseStream is the subset of the MultiRaft_RaftSnapshotServer interface that is needed for sending responses.

type SnapshotResponse_Status

type SnapshotResponse_Status int32
const (
	SnapshotResponse_UNKNOWN  SnapshotResponse_Status = 0
	SnapshotResponse_ACCEPTED SnapshotResponse_Status = 1
	SnapshotResponse_APPLIED  SnapshotResponse_Status = 2
	SnapshotResponse_ERROR    SnapshotResponse_Status = 3
	SnapshotResponse_DECLINED SnapshotResponse_Status = 4
)

func (SnapshotResponse_Status) Enum

func (x SnapshotResponse_Status) Enum() *SnapshotResponse_Status

func (SnapshotResponse_Status) EnumDescriptor

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

func (SnapshotResponse_Status) String

func (x SnapshotResponse_Status) String() string

func (*SnapshotResponse_Status) UnmarshalJSON

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

type SnapshotStorePool

type SnapshotStorePool interface {
	// contains filtered or unexported methods
}

SnapshotStorePool narrows StorePool to make sendSnapshot easier to test.

type SpanAccess

type SpanAccess int

SpanAccess records the intended mode of access in SpanSet.

const (
	SpanReadOnly SpanAccess = iota
	SpanReadWrite
)

Constants for SpanAccess. Higher-valued accesses imply lower-level ones.

type SpanSet

type SpanSet struct {
	// contains filtered or unexported fields
}

SpanSet tracks the set of key spans touched by a command. The set is divided into subsets for access type (read-only or read/write) and key scope (local or global; used to facilitate use by the separate local and global command queues).

func (*SpanSet) Add

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

Add a span to the set.

func (*SpanSet) String

func (ss *SpanSet) String() string

String prints a string representation of the span set.

type SpanSetIterator

type SpanSetIterator struct {
	// contains filtered or unexported fields
}

SpanSetIterator wraps an engine.Iterator and ensures that it can only be used to access spans in a SpanSet.

func (*SpanSetIterator) Close

func (s *SpanSetIterator) Close()

Close implements engine.Iterator.

func (*SpanSetIterator) ComputeStats

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

ComputeStats implements engine.Iterator.

func (*SpanSetIterator) Iterator

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

Iterator returns the underlying engine.Iterator.

func (*SpanSetIterator) Key

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

Key implements engine.Iterator.

func (*SpanSetIterator) Less

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

Less implements engine.Iterator.

func (*SpanSetIterator) Next

func (s *SpanSetIterator) Next()

Next implements engine.Iterator.

func (*SpanSetIterator) NextKey

func (s *SpanSetIterator) NextKey()

NextKey implements engine.Iterator.

func (*SpanSetIterator) Prev

func (s *SpanSetIterator) Prev()

Prev implements engine.Iterator.

func (*SpanSetIterator) PrevKey

func (s *SpanSetIterator) PrevKey()

PrevKey implements engine.Iterator.

func (*SpanSetIterator) Seek

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

Seek implements engine.Iterator.

func (*SpanSetIterator) SeekReverse

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

SeekReverse implements engine.Iterator.

func (*SpanSetIterator) UnsafeKey

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

UnsafeKey implements engine.Iterator.

func (*SpanSetIterator) UnsafeValue

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

UnsafeValue implements engine.Iterator.

func (*SpanSetIterator) Valid

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

Valid implements engine.Iterator.

func (*SpanSetIterator) Value

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

Value implements engine.Iterator.

func (*SpanSetIterator) ValueProto

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

ValueProto implements engine.Iterator.

type Store

type Store struct {
	Ident roachpb.StoreIdent
	// contains filtered or unexported fields
}

A Store maintains a map of ranges by start key. A Store corresponds to one physical device.

func NewStore

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

NewStore returns a new instance of a store.

func (*Store) AllocatorDryRun

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

AllocatorDryRun runs the given replica through the allocator without actually carrying out any changes, returning all trace messages collected along the way. Intended to help power a debug endpoint.

func (*Store) AnnotateCtx

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

AnnotateCtx is a convenience wrapper; see AmbientContext.

func (*Store) Attrs

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

Attrs returns the attributes of the underlying store.

func (*Store) Bootstrap

func (s *Store) Bootstrap(
	ctx context.Context, ident roachpb.StoreIdent, cv cluster.ClusterVersion,
) error

Bootstrap writes a new store ident to the underlying engine. To ensure that no crufty data already exists in the engine, it scans the engine contents before writing the new store ident. The engine should be completely empty. It returns an error if called on a non-empty engine.

func (*Store) BootstrapRange

func (s *Store) BootstrapRange(
	initialValues []roachpb.KeyValue, bootstrapVersion roachpb.Version,
) error

BootstrapRange creates the first range in the cluster and manually writes it to the store. Default range addressing records are created for meta1 and meta2. Default configurations for zones are created. All configs are specified for the empty key prefix, meaning they apply to the entire database. The zone requires three replicas with no other specifications. It also adds the range tree and the root node, the first range, to it. The 'initialValues' are written as well after each value's checksum is initialized.

func (*Store) Capacity

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

Capacity returns the capacity of the underlying storage engine. Note that this does not include reservations. Note that Capacity() has the side effect of updating some of the store's internal statistics about its replicas.

func (*Store) Clock

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

Clock accessor.

func (*Store) ClusterID

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

ClusterID accessor.

func (*Store) ClusterSettings

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

ClusterSettings returns the node's ClusterSettings.

func (*Store) ComputeMetrics

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

ComputeMetrics immediately computes the current value of store metrics which cannot be computed incrementally. This method should be invoked periodically by a higher-level system which records store metrics.

func (*Store) ComputeStatsForKeySpan

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

ComputeStatsForKeySpan computes the aggregated MVCCStats for all replicas on this store which contain any keys in the supplied range.

func (*Store) DB

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

DB accessor.

func (*Store) Descriptor

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

Descriptor returns a StoreDescriptor including current store capacity information.

func (*Store) Engine

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

Engine accessor.

func (*Store) GetReplica

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

GetReplica fetches a replica by Range ID. Returns an error if no replica is found.

func (*Store) Gossip

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

Gossip accessor.

func (*Store) GossipDeadReplicas

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

GossipDeadReplicas broadcasts the store's dead replicas on the gossip network.

func (*Store) GossipStore

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

GossipStore broadcasts the store on the gossip network.

func (*Store) HandleRaftRequest

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

HandleRaftRequest dispatches a raft message to the appropriate Replica. It requires that s.mu is not held.

func (*Store) HandleRaftResponse

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

HandleRaftResponse implements the RaftMessageHandler interface. It requires that s.mu is not held.

func (*Store) HandleRaftUncoalescedRequest

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

HandleRaftUncoalescedRequest dispatches a raft message to the appropriate Replica. It requires that s.mu is not held.

func (*Store) HandleSnapshot

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

HandleSnapshot reads an incoming streaming snapshot and applies it if possible.

func (*Store) IsDraining

func (s *Store) IsDraining() bool

IsDraining accessor.

func (*Store) IsStarted

func (s *Store) IsStarted() bool

IsStarted returns true if the Store has been started.

func (*Store) LookupReplica

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

LookupReplica looks up a replica via binary search over the "replicasByKey" btree. Returns nil if no replica is found for specified key range. Note that the specified keys are transformed using Key.Address() to ensure we lookup replicas correctly for local keys. When end is nil, a replica that contains start is looked up.

func (*Store) MVCCStats

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

MVCCStats returns the current MVCCStats accumulated for this store. TODO(mrtracy): This should be removed as part of #4465, this is only needed to support the current StatusSummary structures which will be changing.

func (*Store) MergeRange

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

MergeRange expands the subsuming range to absorb the subsumed range. This merge operation will fail if the two ranges are not collocated on the same store. The subsumed range's raftMu is assumed held.

func (*Store) Metrics

func (s *Store) Metrics() *StoreMetrics

Metrics returns the store's metric struct.

func (*Store) NewRangeDescriptor

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

NewRangeDescriptor creates a new descriptor based on start and end keys and the supplied roachpb.Replicas slice. It allocates a new range ID and returns a RangeDescriptor whose Replicas are a copy of the supplied replicas slice, with appropriate ReplicaIDs assigned.

func (*Store) NotifyBootstrapped

func (s *Store) NotifyBootstrapped()

NotifyBootstrapped tells the store that it was bootstrapped and allows idle replicas to campaign immediately. This primarily affects tests.

func (*Store) RaftStatus

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

RaftStatus returns the current raft status of the local replica of the given range.

func (*Store) ReadLastUpTimestamp

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

ReadLastUpTimestamp returns the "last up" timestamp recorded in this store. This value can be used to approximate the last time the engine was was being served as a store by a running node. If the store does not contain a "last up" timestamp (for example, on a newly bootstrapped store), the zero timestamp is returned instead.

func (*Store) Registry

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

Registry returns the store registry.

func (*Store) RemoveReplica

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

RemoveReplica removes the replica from the store's replica map and from the sorted replicasByKey btree. The version of the replica descriptor that was used to make the removal decision is passed in, and the removal is aborted if the replica ID has changed since then. If `destroy` is true, all data belonging to the replica will be deleted. In either case a tombstone record will be written.

func (*Store) ReplicaCount

func (s *Store) ReplicaCount() int

ReplicaCount returns the number of replicas contained by this store. This method is O(n) in the number of replicas and should not be called from performance critical code.

func (*Store) Send

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

Send fetches a range based on the header's replica, assembles method, args & reply into a Raft Cmd struct and executes the command using the fetched range. An incoming request may be transactional or not. If it is not transactional, the timestamp at which it executes may be higher than that optionally specified through the incoming BatchRequest, and it is not guaranteed that all operations are written at the same timestamp. If it is transactional, a timestamp must not be set - it is deduced automatically from the transaction. In particular, the read (original) timestamp will be used for all reads _and writes_ (see the TxnMeta.OrigTimestamp for details).

Should a transactional operation be forced to a higher timestamp (for instance due to the timestamp cache or finding a committed value in the path of one of its writes), the response will have a transaction set which should be used to update the client transaction.

func (*Store) SetDraining

func (s *Store) SetDraining(drain bool)

SetDraining (when called with 'true') causes incoming lease transfers to be rejected, prevents all of the Store's Replicas from acquiring or extending range leases, and attempts to transfer away any leases owned. When called with 'false', returns to the normal mode of operation.

func (*Store) SplitRange

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

SplitRange shortens the original range to accommodate the new range. The new range is added to the ranges map and the replicasByKey btree. origRng.raftMu and newRng.raftMu must be held.

This is only called from the split trigger in the context of the execution of a Raft command.

func (*Store) Start

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

Start the engine, set the GC and read the StoreIdent.

func (*Store) Stopper

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

Stopper accessor.

func (*Store) StoreID

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

StoreID accessor.

func (*Store) String

func (s *Store) String() string

String formats a store for debug output.

func (*Store) TestingKnobs

func (s *Store) TestingKnobs() *StoreTestingKnobs

TestingKnobs accessor.

func (*Store) Tracer

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

Tracer accessor.

func (*Store) WaitForInit

func (s *Store) WaitForInit()

WaitForInit waits for any asynchronous processes begun in Start() to complete their initialization. In particular, this includes gossiping. In some cases this may block until the range GC queue has completed its scan. Only for testing.

func (*Store) WriteLastUpTimestamp

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

WriteLastUpTimestamp records the supplied timestamp into the "last up" key on this store. This value should be refreshed whenever this store's node updates its own liveness record; it is used by a restarting store to determine the approximate time that it stopped.

type StoreConfig

type StoreConfig struct {
	AmbientCtx log.AmbientContext
	base.RaftConfig

	Settings     *cluster.Settings
	Clock        *hlc.Clock
	DB           *client.DB
	Gossip       *gossip.Gossip
	NodeLiveness *NodeLiveness
	StorePool    *StorePool
	Transport    *RaftTransport
	RPCContext   *rpc.Context

	// SQLExecutor is used by the store to execute SQL statements in a way that
	// is more direct than using a sql.Executor.
	SQLExecutor sqlutil.InternalExecutor

	// TimeSeriesDataStore is an interface used by the store's time series
	// maintenance queue to dispatch individual maintenance tasks.
	TimeSeriesDataStore TimeSeriesDataStore

	// DontRetryPushTxnFailures will propagate a push txn failure immediately
	// instead of utilizing the push txn queue to wait for the transaction to
	// finish or be pushed by a higher priority contender.
	DontRetryPushTxnFailures bool

	// CoalescedHeartbeatsInterval is the interval for which heartbeat messages
	// are queued and then sent as a single coalesced heartbeat; it is a
	// fraction of the RaftTickInterval so that heartbeats don't get delayed by
	// an entire tick. Delaying coalescing heartbeat responses has a bad
	// interaction with quiescence because the coalesced (delayed) heartbeat
	// response can unquiesce the leader. Consider:
	//
	// T+0: leader queues MsgHeartbeat
	// T+1: leader sends MsgHeartbeat
	//                                        follower receives MsgHeartbeat
	//                                        follower queues MsgHeartbeatResp
	// T+2: leader queues quiesce message
	//                                        follower sends MsgHeartbeatResp
	//      leader receives MsgHeartbeatResp
	// T+3: leader sends quiesce message
	//
	// Thus we want to make sure that heartbeats are responded to faster than
	// the quiesce cadence.
	CoalescedHeartbeatsInterval time.Duration

	// RaftHeartbeatIntervalTicks is the number of ticks that pass between heartbeats.
	RaftHeartbeatIntervalTicks int

	// ScanInterval is the default value for the scan interval
	ScanInterval time.Duration

	// ScanMaxIdleTime is the maximum time the scanner will be idle between ranges.
	// If enabled (> 0), the scanner may complete in less than ScanInterval for small
	// stores.
	ScanMaxIdleTime time.Duration

	// If LogRangeEvents is true, major changes to ranges will be logged into
	// the range event log.
	LogRangeEvents bool

	// RaftEntryCacheSize is the size in bytes of the Raft log entry cache
	// shared by all Raft groups managed by the store.
	RaftEntryCacheSize uint64

	// IntentResolverTaskLimit is the maximum number of asynchronous tasks that
	// may be started by the intent resolver. -1 indicates no asynchronous tasks
	// are allowed. 0 uses the default value (defaultIntentResolverTaskLimit)
	// which is non-zero.
	IntentResolverTaskLimit int

	TestingKnobs StoreTestingKnobs

	// MetricsSampleInterval is (server.Context).MetricsSampleInterval
	MetricsSampleInterval time.Duration

	// HistogramWindowInterval is (server.Context).HistogramWindowInterval
	HistogramWindowInterval time.Duration

	// EnableEpochRangeLeases controls whether epoch-based range leases are used.
	EnableEpochRangeLeases bool

	// GossipWhenCapacityDeltaExceedsFraction specifies the fraction from the last
	// gossiped store capacity values which need be exceeded before the store will
	// gossip immediately without waiting for the periodic gossip interval.
	GossipWhenCapacityDeltaExceedsFraction float64
	// contains filtered or unexported fields
}

A StoreConfig encompasses the auxiliary objects and configuration required to create a store. All fields holding a pointer or an interface are required to create a store; the rest will have sane defaults set if omitted.

func TestStoreConfig

func TestStoreConfig(clock *hlc.Clock) StoreConfig

TestStoreConfig has some fields initialized with values relevant in tests.

func (*StoreConfig) LeaseExpiration

func (sc *StoreConfig) LeaseExpiration() int64

LeaseExpiration returns an int64 to increment a manual clock with to make sure that all active range leases expire.

func (*StoreConfig) SetDefaults

func (sc *StoreConfig) SetDefaults()

SetDefaults initializes unset fields in StoreConfig to values suitable for use on a local network. TODO(tschottdorf): see if this ought to be configurable via flags.

func (*StoreConfig) Valid

func (sc *StoreConfig) Valid() bool

Valid returns true if the StoreConfig is populated correctly. We don't check for Gossip and DB since some of our tests pass that as nil.

type StoreList

type StoreList struct {
	// contains filtered or unexported fields
}

StoreList holds a list of store descriptors and associated count and used stats for those stores.

func (StoreList) String

func (sl StoreList) String() string

type StoreMetrics

type StoreMetrics struct {

	// Replica metrics.
	ReplicaCount                  *metric.Counter // Does not include reserved replicas.
	ReservedReplicaCount          *metric.Counter
	RaftLeaderCount               *metric.Gauge
	RaftLeaderNotLeaseHolderCount *metric.Gauge
	LeaseHolderCount              *metric.Gauge
	QuiescentCount                *metric.Gauge

	// Replica CommandQueue metrics.
	MaxCommandQueueSize       *metric.Gauge
	MaxCommandQueueWriteCount *metric.Gauge
	MaxCommandQueueReadCount  *metric.Gauge
	MaxCommandQueueTreeSize   *metric.Gauge
	MaxCommandQueueOverlaps   *metric.Gauge
	CombinedCommandQueueSize  *metric.Gauge
	CombinedCommandWriteCount *metric.Gauge
	CombinedCommandReadCount  *metric.Gauge

	// Range metrics.
	RangeCount                *metric.Gauge
	UnavailableRangeCount     *metric.Gauge
	UnderReplicatedRangeCount *metric.Gauge

	// Lease request metrics for successful and failed lease requests. These
	// count proposals (i.e. it does not matter how many replicas apply the
	// lease).
	LeaseRequestSuccessCount  *metric.Counter
	LeaseRequestErrorCount    *metric.Counter
	LeaseTransferSuccessCount *metric.Counter
	LeaseTransferErrorCount   *metric.Counter
	LeaseExpirationCount      *metric.Gauge
	LeaseEpochCount           *metric.Gauge

	// Storage metrics.
	LiveBytes       *metric.Gauge
	KeyBytes        *metric.Gauge
	ValBytes        *metric.Gauge
	TotalBytes      *metric.Gauge
	IntentBytes     *metric.Gauge
	LiveCount       *metric.Gauge
	KeyCount        *metric.Gauge
	ValCount        *metric.Gauge
	IntentCount     *metric.Gauge
	IntentAge       *metric.Gauge
	GcBytesAge      *metric.Gauge
	LastUpdateNanos *metric.Gauge
	Capacity        *metric.Gauge
	Available       *metric.Gauge
	Used            *metric.Gauge
	Reserved        *metric.Counter
	SysBytes        *metric.Gauge
	SysCount        *metric.Gauge

	// Rebalancing metrics.
	AverageWritesPerSecond *metric.GaugeFloat64

	// RocksDB metrics.
	RdbBlockCacheHits           *metric.Gauge
	RdbBlockCacheMisses         *metric.Gauge
	RdbBlockCacheUsage          *metric.Gauge
	RdbBlockCachePinnedUsage    *metric.Gauge
	RdbBloomFilterPrefixChecked *metric.Gauge
	RdbBloomFilterPrefixUseful  *metric.Gauge
	RdbMemtableHits             *metric.Gauge
	RdbMemtableMisses           *metric.Gauge
	RdbMemtableTotalSize        *metric.Gauge
	RdbFlushes                  *metric.Gauge
	RdbCompactions              *metric.Gauge
	RdbTableReadersMemEstimate  *metric.Gauge
	RdbReadAmplification        *metric.Gauge
	RdbNumSSTables              *metric.Gauge

	// Range event metrics.
	RangeSplits                     *metric.Counter
	RangeAdds                       *metric.Counter
	RangeRemoves                    *metric.Counter
	RangeSnapshotsGenerated         *metric.Counter
	RangeSnapshotsNormalApplied     *metric.Counter
	RangeSnapshotsPreemptiveApplied *metric.Counter
	RangeRaftLeaderTransfers        *metric.Counter

	// Raft processing metrics.
	RaftTicks                *metric.Counter
	RaftWorkingDurationNanos *metric.Counter
	RaftTickingDurationNanos *metric.Counter
	RaftCommandsApplied      *metric.Counter
	RaftLogCommitLatency     *metric.Histogram
	RaftCommandCommitLatency *metric.Histogram

	// Raft message metrics.
	RaftRcvdMsgProp           *metric.Counter
	RaftRcvdMsgApp            *metric.Counter
	RaftRcvdMsgAppResp        *metric.Counter
	RaftRcvdMsgVote           *metric.Counter
	RaftRcvdMsgVoteResp       *metric.Counter
	RaftRcvdMsgPreVote        *metric.Counter
	RaftRcvdMsgPreVoteResp    *metric.Counter
	RaftRcvdMsgSnap           *metric.Counter
	RaftRcvdMsgHeartbeat      *metric.Counter
	RaftRcvdMsgHeartbeatResp  *metric.Counter
	RaftRcvdMsgTransferLeader *metric.Counter
	RaftRcvdMsgTimeoutNow     *metric.Counter
	RaftRcvdMsgDropped        *metric.Counter

	// Raft log metrics.
	RaftLogFollowerBehindCount *metric.Gauge
	RaftLogSelfBehindCount     *metric.Gauge
	RaftLogTruncated           *metric.Counter

	RaftEnqueuedPending            *metric.Gauge
	RaftCoalescedHeartbeatsPending *metric.Gauge

	// Replica queue metrics.
	GCQueueSuccesses                          *metric.Counter
	GCQueueFailures                           *metric.Counter
	GCQueuePending                            *metric.Gauge
	GCQueueProcessingNanos                    *metric.Counter
	RaftLogQueueSuccesses                     *metric.Counter
	RaftLogQueueFailures                      *metric.Counter
	RaftLogQueuePending                       *metric.Gauge
	RaftLogQueueProcessingNanos               *metric.Counter
	RaftSnapshotQueueSuccesses                *metric.Counter
	RaftSnapshotQueueFailures                 *metric.Counter
	RaftSnapshotQueuePending                  *metric.Gauge
	RaftSnapshotQueueProcessingNanos          *metric.Counter
	ConsistencyQueueSuccesses                 *metric.Counter
	ConsistencyQueueFailures                  *metric.Counter
	ConsistencyQueuePending                   *metric.Gauge
	ConsistencyQueueProcessingNanos           *metric.Counter
	ReplicaGCQueueSuccesses                   *metric.Counter
	ReplicaGCQueueFailures                    *metric.Counter
	ReplicaGCQueuePending                     *metric.Gauge
	ReplicaGCQueueProcessingNanos             *metric.Counter
	ReplicateQueueSuccesses                   *metric.Counter
	ReplicateQueueFailures                    *metric.Counter
	ReplicateQueuePending                     *metric.Gauge
	ReplicateQueueProcessingNanos             *metric.Counter
	ReplicateQueuePurgatory                   *metric.Gauge
	SplitQueueSuccesses                       *metric.Counter
	SplitQueueFailures                        *metric.Counter
	SplitQueuePending                         *metric.Gauge
	SplitQueueProcessingNanos                 *metric.Counter
	TimeSeriesMaintenanceQueueSuccesses       *metric.Counter
	TimeSeriesMaintenanceQueueFailures        *metric.Counter
	TimeSeriesMaintenanceQueuePending         *metric.Gauge
	TimeSeriesMaintenanceQueueProcessingNanos *metric.Counter

	// GCInfo cumulative totals.
	GCNumKeysAffected            *metric.Counter
	GCIntentsConsidered          *metric.Counter
	GCIntentTxns                 *metric.Counter
	GCTransactionSpanScanned     *metric.Counter
	GCTransactionSpanGCAborted   *metric.Counter
	GCTransactionSpanGCCommitted *metric.Counter
	GCTransactionSpanGCPending   *metric.Counter
	GCAbortSpanScanned           *metric.Counter
	GCAbortSpanConsidered        *metric.Counter
	GCAbortSpanGCNum             *metric.Counter
	GCPushTxn                    *metric.Counter
	GCResolveTotal               *metric.Counter
	GCResolveSuccess             *metric.Counter

	// Slow request counts.
	SlowCommandQueueRequests *metric.Gauge
	SlowLeaseRequests        *metric.Gauge
	SlowRaftRequests         *metric.Gauge

	// AddSSTable stats: how many AddSSTable commands were proposed and how many
	// were applied?
	AddSSTableProposals    *metric.Counter
	AddSSTableApplications *metric.Counter
	// contains filtered or unexported fields
}

StoreMetrics is the set of metrics for a given store.

type StorePool

type StorePool struct {
	log.AmbientContext
	// contains filtered or unexported fields
}

StorePool maintains a list of all known stores in the cluster and information on their health.

func NewStorePool

func NewStorePool(
	ambient log.AmbientContext,
	st *cluster.Settings,
	g *gossip.Gossip,
	clock *hlc.Clock,
	nodeLivenessFn NodeLivenessFunc,
	deterministic bool,
) *StorePool

NewStorePool creates a StorePool and registers the store updating callback with gossip.

func (*StorePool) String

func (sp *StorePool) String() string

type StoreRequestHeader

type StoreRequestHeader struct {
	NodeID  github_com_cockroachdb_cockroach_pkg_roachpb.NodeID  "" /* 141 byte string literal not displayed */
	StoreID github_com_cockroachdb_cockroach_pkg_roachpb.StoreID "" /* 145 byte string literal not displayed */
}

StoreRequestHeader locates a Store on a Node.

func (*StoreRequestHeader) Descriptor

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

func (*StoreRequestHeader) Marshal

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

func (*StoreRequestHeader) MarshalTo

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

func (*StoreRequestHeader) ProtoMessage

func (*StoreRequestHeader) ProtoMessage()

func (*StoreRequestHeader) Reset

func (m *StoreRequestHeader) Reset()

func (*StoreRequestHeader) Size

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

func (*StoreRequestHeader) String

func (m *StoreRequestHeader) String() string

func (*StoreRequestHeader) Unmarshal

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

type StoreTestingKnobs

type StoreTestingKnobs struct {
	// TestingProposalFilter is called before proposing each command.
	TestingProposalFilter storagebase.ReplicaCommandFilter

	// TestingEvalFilter is called before evaluating each command. The
	// number of times this callback is run depends on the propEvalKV
	// setting, and it is therefore deprecated in favor of either
	// TestingProposalFilter (which runs only on the lease holder) or
	// TestingApplyFilter (which runs on each replica). If your filter is
	// not idempotent, consider wrapping it in a
	// ReplayProtectionFilterWrapper.
	// TODO(bdarnell,tschottdorf): Migrate existing tests which use this
	// to one of the other filters. See #10493
	// TODO(andrei): Provide guidance on what to use instead for trapping reads.
	TestingEvalFilter storagebase.ReplicaCommandFilter

	// TestingApplyFilter is called before applying the results of a
	// command on each replica. If it returns an error, the command will
	// not be applied. If it returns an error on some replicas but not
	// others, the behavior is poorly defined unless that error is a
	// ReplicaCorruptionError.
	TestingApplyFilter storagebase.ReplicaApplyFilter

	// TestingPostApplyFilter is called after a command is applied to
	// rocksdb but before in-memory side effects have been processed.
	TestingPostApplyFilter storagebase.ReplicaApplyFilter

	// TestingResponseFilter is called after the replica processes a
	// command in order for unittests to modify the batch response,
	// error returned to the client, or to simulate network failures.
	TestingResponseFilter storagebase.ReplicaResponseFilter

	// If non-nil, BadChecksumPanic is called by CheckConsistency() instead of
	// panicking on a checksum mismatch.
	BadChecksumPanic func(roachpb.StoreIdent)
	// If non-nil, BadChecksumReportDiff is called by CheckConsistency() on a
	// checksum mismatch to report the diff between snapshots.
	BadChecksumReportDiff func(roachpb.StoreIdent, []ReplicaSnapshotDiff)
	// Disables the use of one phase commits.
	DisableOnePhaseCommits bool
	// A hack to manipulate the clock before sending a batch request to a replica.
	// TODO(kaneda): This hook is not encouraged to use. Get rid of it once
	// we make TestServer take a ManualClock.
	ClockBeforeSend func(*hlc.Clock, roachpb.BatchRequest)
	// OnCampaign is called if the replica campaigns for Raft leadership
	// when initializing the Raft group. Note that this method is invoked
	// with both Replica.raftMu and Replica.mu locked.
	OnCampaign func(*Replica)
	// OnCommandQueueAction is called when the BatchRequest performs an action
	// on the CommandQueue.
	OnCommandQueueAction func(*roachpb.BatchRequest, storagebase.CommandQueueAction)
	// MaxOffset, if set, overrides the server clock's MaxOffset at server
	// creation time.
	// See also DisableMaxOffsetCheck.
	MaxOffset time.Duration
	// DisableMaxOffsetCheck disables the rejection (in Store.Send) of requests
	// with the timestamp too much in the future. Normally, this rejection is a
	// good sanity check, but certain tests unfortunately insert a "message from
	// the future" into the system to advance the clock of a TestServer. We
	// should get rid of such practices once we make TestServer take a
	// ManualClock.
	DisableMaxOffsetCheck bool
	// DontPreventUseOfOldLeaseOnStart disables the initialization of
	// replica.mu.minLeaseProposedTS on replica.Init(). This has the effect of
	// allowing the replica to use the lease that it had in a previous life (in
	// case the tests persisted the engine used in said previous life).
	DontPreventUseOfOldLeaseOnStart bool
	// LeaseRequestEvent, if set, is called when replica.requestLeaseLocked() is
	// called to acquire a new lease. This can be used to assert that a request
	// triggers a lease acquisition.
	LeaseRequestEvent func(ts hlc.Timestamp)
	// LeaseTransferBlockedOnExtensionEvent, if set, is called when
	// replica.TransferLease() encounters an in-progress lease extension.
	// nextLeader is the replica that we're trying to transfer the lease to.
	LeaseTransferBlockedOnExtensionEvent func(nextLeader roachpb.ReplicaDescriptor)
	// DisableReplicaGCQueue disables the replica GC queue.
	DisableReplicaGCQueue bool
	// DisableReplicateQueue disables the replication queue.
	DisableReplicateQueue bool
	// DisableReplicaRebalancing disables rebalancing of replicas but otherwise
	// leaves the replicate queue operational.
	DisableReplicaRebalancing bool
	// DisableSplitQueue disables the split queue.
	DisableSplitQueue bool
	// DisableTimeSeriesMaintenanceQueue disables the time series maintenance
	// queue.
	DisableTimeSeriesMaintenanceQueue bool
	// DisableRaftSnapshotQueue disables the raft snapshot queue.
	DisableRaftSnapshotQueue bool
	// DisableScanner disables the replica scanner.
	DisableScanner bool
	// DisablePeriodicGossips disables periodic gossiping.
	DisablePeriodicGossips bool
	// DisableRefreshReasonTicks disables refreshing pending commands when a new
	// leader is discovered.
	DisableRefreshReasonNewLeader bool
	// DisableRefreshReasonTicks disables refreshing pending commands when a
	// snapshot is applied.
	DisableRefreshReasonSnapshotApplied bool
	// DisableRefreshReasonTicks disables refreshing pending commands
	// periodically.
	DisableRefreshReasonTicks bool
	// DisableProcessRaft disables the process raft loop.
	DisableProcessRaft bool
	// DisableLastProcessedCheck disables checking on replica queue last processed times.
	DisableLastProcessedCheck bool
	// ReplicateQueueAcceptsUnsplit allows the replication queue to
	// process ranges that need to be split, for use in tests that use
	// the replication queue but disable the split queue.
	ReplicateQueueAcceptsUnsplit bool
	// NumKeysEvaluatedForRangeIntentResolution is set by the stores to the
	// number of keys evaluated for range intent resolution.
	NumKeysEvaluatedForRangeIntentResolution *int64
	// SkipMinSizeCheck, if set, makes the store creation process skip the check
	// for a minimum size.
	SkipMinSizeCheck bool
	// DisableAsyncIntentResolution disables the async intent resolution
	// path (but leaves synchronous resolution). This can avoid some
	// edge cases in tests that start and stop servers.
	DisableAsyncIntentResolution bool
	// DisableLeaseCapacityGossip disables the ability of a changing number of
	// leases to trigger the store to gossip its capacity. With this enabled,
	// only changes in the number of replicas can cause the store to gossip its
	// capacity.
	DisableLeaseCapacityGossip bool
	// BootstrapVersion overrides the version the stores will be bootstrapped with.
	BootstrapVersion *cluster.ClusterVersion
}

StoreTestingKnobs is a part of the context used to control parts of the system. The Testing*Filter functions are called at various points in the request pipeline if they are non-nil. These can be used either for synchronization (e.g. to write to a channel when a particular point is reached) or to change the behavior by returning an error (which aborts all further processing for the command).

func (*StoreTestingKnobs) ModuleTestingKnobs

func (*StoreTestingKnobs) ModuleTestingKnobs()

ModuleTestingKnobs is part of the base.ModuleTestingKnobs interface.

type Stores

type Stores struct {
	log.AmbientContext
	// contains filtered or unexported fields
}

Stores provides methods to access a collection of stores. There's a visitor pattern and also an implementation of the client.Sender interface which directs a call to the appropriate store based on the call's key range. Stores also implements the gossip.Storage interface, which allows gossip bootstrap information to be persisted consistently to every store and the most recent bootstrap information to be read at node startup.

func NewStores

func NewStores(
	ambient log.AmbientContext, clock *hlc.Clock, minVersion, serverVersion roachpb.Version,
) *Stores

NewStores returns a local-only sender which directly accesses a collection of stores.

func (*Stores) AddStore

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

AddStore adds the specified store to the store map.

func (*Stores) FirstRange

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

FirstRange implements the RangeDescriptorDB interface. It returns the range descriptor which contains KeyMin.

func (*Stores) GetStore

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

GetStore looks up the store by store ID. Returns an error if not found.

func (*Stores) GetStoreCount

func (ls *Stores) GetStoreCount() int

GetStoreCount returns the number of stores this node is exporting.

func (*Stores) HasStore

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

HasStore returns true if the specified store is owned by this Stores.

func (*Stores) LookupReplica

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

LookupReplica looks up replica by key [range]. Lookups are done by consulting each store in turn via Store.LookupReplica(key). Returns RangeID and replica on success; RangeKeyMismatch error if not found. If end is nil, a replica containing start is looked up. This is only for testing usage; performance doesn't matter.

func (*Stores) ReadBootstrapInfo

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

ReadBootstrapInfo implements the gossip.Storage interface. Read attempts to read gossip bootstrap info from every known store and finds the most recent from all stores to initialize the bootstrap info argument. Returns an error on any issues reading data for the stores (but excluding the case in which no data has been persisted yet).

func (*Stores) RemoveStore

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

RemoveStore removes the specified store from the store map.

func (*Stores) Send

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

Send implements the client.Sender interface. The store is looked up from the store map if specified by the request; otherwise, the command is being executed locally, and the replica is determined via lookup through each store's LookupRange method. The latter path is taken only by unit tests.

func (*Stores) SynthesizeClusterVersion

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

SynthesizeClusterVersion reads and returns the ClusterVersion protobuf (written to any of the configured stores (all of which are bootstrapped)). The returned value is also replicated to all stores for consistency, in case a new store was added or an old store re-configured. In case of non-identical versions across the stores, returns a version that carries the largest MinVersion and the smallest UseVersion.

If there aren't any stores, returns a ClusterVersion with MinSupportedVersion and UseVersion set to the minimum supported version and server version of the build, respectively.

func (*Stores) VisitStores

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

VisitStores implements a visitor pattern over stores in the storeMap. The specified function is invoked with each store in turn. Care is taken to invoke the visitor func without the lock held to avoid inconsistent lock orderings, as some visitor functions may call back into the Stores object. Stores are visited in random order.

func (*Stores) WriteBootstrapInfo

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

WriteBootstrapInfo implements the gossip.Storage interface. Write persists the supplied bootstrap info to every known store. Returns nil on success; otherwise returns first error encountered writing to the stores.

func (*Stores) WriteClusterVersion

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

WriteClusterVersion persists the supplied ClusterVersion to every configured store. Returns nil on success; otherwise returns first error encountered writing to the stores.

WriteClusterVersion makes no attempt to validate the supplied version.

type TimeSeriesDataStore

type TimeSeriesDataStore interface {
	ContainsTimeSeries(roachpb.RKey, roachpb.RKey) bool
	PruneTimeSeries(
		context.Context, engine.Reader, roachpb.RKey, roachpb.RKey, *client.DB, hlc.Timestamp,
	) error
}

TimeSeriesDataStore is an interface defined in the storage package that can be implemented by the higher-level time series system. This allows the storage queues to run periodic time series maintenance; importantly, this maintenance can then be informed by data from the local store.

Package Files

Documentation was rendered with GOOS=linux and GOARCH=amd64.

Jump to identifier

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to identifier