-
Notifications
You must be signed in to change notification settings - Fork 218
/
pdpb.proto
543 lines (418 loc) · 13 KB
/
pdpb.proto
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
syntax = "proto3";
package pdpb;
import "metapb.proto";
import "eraftpb.proto";
import "gogoproto/gogo.proto";
import "rustproto.proto";
option (gogoproto.sizer_all) = true;
option (gogoproto.marshaler_all) = true;
option (gogoproto.unmarshaler_all) = true;
option (rustproto.lite_runtime_all) = true;
option java_package = "org.tikv.kvproto";
service PD {
// GetMembers get the member list of this cluster. It does not require
// the cluster_id in request matchs the id of this cluster.
rpc GetMembers(GetMembersRequest) returns (GetMembersResponse) {}
rpc Tso(stream TsoRequest) returns (stream TsoResponse) {}
rpc Bootstrap(BootstrapRequest) returns (BootstrapResponse) {}
rpc IsBootstrapped(IsBootstrappedRequest) returns (IsBootstrappedResponse) {}
rpc AllocID(AllocIDRequest) returns (AllocIDResponse) {}
rpc GetStore(GetStoreRequest) returns (GetStoreResponse) {}
rpc PutStore(PutStoreRequest) returns (PutStoreResponse) {}
rpc GetAllStores(GetAllStoresRequest) returns (GetAllStoresResponse) {}
rpc StoreHeartbeat(StoreHeartbeatRequest) returns (StoreHeartbeatResponse) {}
rpc RegionHeartbeat(stream RegionHeartbeatRequest) returns (stream RegionHeartbeatResponse) {}
rpc GetRegion(GetRegionRequest) returns (GetRegionResponse) {}
rpc GetPrevRegion(GetRegionRequest) returns (GetRegionResponse) {}
rpc GetRegionByID(GetRegionByIDRequest) returns (GetRegionResponse) {}
rpc ScanRegions(ScanRegionsRequest) returns (ScanRegionsResponse) {}
rpc AskSplit(AskSplitRequest) returns (AskSplitResponse) {
// Use AskBatchSplit instead.
option deprecated = true;
}
rpc ReportSplit(ReportSplitRequest) returns (ReportSplitResponse) {
// Use ResportBatchSplit instead.
option deprecated = true;
}
rpc AskBatchSplit(AskBatchSplitRequest) returns (AskBatchSplitResponse) {}
rpc ReportBatchSplit(ReportBatchSplitRequest) returns (ReportBatchSplitResponse) {}
rpc GetClusterConfig(GetClusterConfigRequest) returns (GetClusterConfigResponse) {}
rpc PutClusterConfig(PutClusterConfigRequest) returns (PutClusterConfigResponse) {}
rpc ScatterRegion(ScatterRegionRequest) returns (ScatterRegionResponse) {}
rpc GetGCSafePoint(GetGCSafePointRequest) returns (GetGCSafePointResponse) {}
rpc UpdateGCSafePoint(UpdateGCSafePointRequest) returns (UpdateGCSafePointResponse) {}
rpc SyncRegions(stream SyncRegionRequest) returns (stream SyncRegionResponse) {}
rpc GetOperator(GetOperatorRequest) returns (GetOperatorResponse) {}
}
message RequestHeader {
// cluster_id is the ID of the cluster which be sent to.
uint64 cluster_id = 1;
}
message ResponseHeader {
// cluster_id is the ID of the cluster which sent the response.
uint64 cluster_id = 1;
Error error = 2;
}
enum ErrorType {
OK = 0;
UNKNOWN = 1;
NOT_BOOTSTRAPPED = 2;
STORE_TOMBSTONE = 3;
ALREADY_BOOTSTRAPPED = 4;
INCOMPATIBLE_VERSION = 5;
REGION_NOT_FOUND = 6;
}
message Error {
ErrorType type = 1;
string message = 2;
}
message TsoRequest {
RequestHeader header = 1;
uint32 count = 2;
}
message Timestamp {
int64 physical = 1;
int64 logical = 2;
}
message TsoResponse {
ResponseHeader header = 1;
uint32 count = 2;
Timestamp timestamp = 3;
}
message BootstrapRequest {
RequestHeader header = 1;
metapb.Store store = 2;
metapb.Region region = 3;
}
message BootstrapResponse {
ResponseHeader header = 1;
}
message IsBootstrappedRequest {
RequestHeader header = 1;
}
message IsBootstrappedResponse {
ResponseHeader header = 1;
bool bootstrapped = 2;
}
message AllocIDRequest {
RequestHeader header = 1;
}
message AllocIDResponse {
ResponseHeader header = 1;
uint64 id = 2;
}
message GetStoreRequest {
RequestHeader header = 1;
uint64 store_id = 2;
}
message GetStoreResponse {
ResponseHeader header = 1;
metapb.Store store = 2;
StoreStats stats = 3;
}
message PutStoreRequest {
RequestHeader header = 1;
metapb.Store store = 2;
}
message PutStoreResponse {
ResponseHeader header = 1;
}
message GetAllStoresRequest {
RequestHeader header = 1;
// Do NOT return tombstone stores if set to true.
bool exclude_tombstone_stores = 2;
}
message GetAllStoresResponse {
ResponseHeader header = 1;
repeated metapb.Store stores = 2;
}
message GetRegionRequest {
RequestHeader header = 1;
bytes region_key = 2;
}
message GetRegionResponse {
ResponseHeader header = 1;
metapb.Region region = 2;
metapb.Peer leader = 3;
repeated metapb.Peer slaves = 4;
}
message GetRegionByIDRequest {
RequestHeader header = 1;
uint64 region_id = 2;
}
// Use GetRegionResponse as the response of GetRegionByIDRequest.
message ScanRegionsRequest {
RequestHeader header = 1;
bytes start_key = 2;
int32 limit = 3; // no limit when limit <= 0.
bytes end_key = 4; // end_key is +inf when it is empty.
}
message ScanRegionsResponse {
ResponseHeader header = 1;
repeated metapb.Region regions = 2;
repeated metapb.Peer leaders = 3;
}
message GetClusterConfigRequest {
RequestHeader header = 1;
}
message GetClusterConfigResponse {
ResponseHeader header = 1;
metapb.Cluster cluster = 2;
}
message PutClusterConfigRequest {
RequestHeader header = 1;
metapb.Cluster cluster = 2;
}
message PutClusterConfigResponse {
ResponseHeader header = 1;
}
message Member {
// name is the name of the PD member.
string name = 1;
// member_id is the unique id of the PD member.
uint64 member_id = 2;
repeated string peer_urls = 3;
repeated string client_urls = 4;
int32 leader_priority = 5;
}
message GetMembersRequest {
RequestHeader header = 1;
}
message GetMembersResponse {
ResponseHeader header = 1;
repeated Member members = 2;
Member leader = 3;
Member etcd_leader = 4;
}
message PeerStats {
metapb.Peer peer = 1;
uint64 down_seconds = 2;
}
message RegionHeartbeatRequest {
RequestHeader header = 1;
metapb.Region region = 2;
// Leader Peer sending the heartbeat.
metapb.Peer leader = 3;
// Leader considers that these peers are down.
repeated PeerStats down_peers = 4;
// Pending peers are the peers that the leader can't consider as
// working followers.
repeated metapb.Peer pending_peers = 5;
// Bytes read/written during this period.
uint64 bytes_written = 6;
uint64 bytes_read = 7;
// Keys read/written during this period.
uint64 keys_written = 8;
uint64 keys_read = 9;
// Approximate region size.
uint64 approximate_size = 10;
reserved 11;
// Actually reported time interval
TimeInterval interval = 12;
// Approximate number of keys.
uint64 approximate_keys = 13;
// Term is the term of raft group.
uint64 term = 14;
}
message ChangePeer {
metapb.Peer peer = 1;
eraftpb.ConfChangeType change_type = 2;
}
message TransferLeader {
metapb.Peer peer = 1;
}
message Merge {
metapb.Region target = 1;
}
message SplitRegion {
CheckPolicy policy = 1;
repeated bytes keys = 2;
}
enum CheckPolicy {
SCAN = 0;
APPROXIMATE = 1;
USEKEY = 2;
}
message RegionHeartbeatResponse {
ResponseHeader header = 1;
// Notice, Pd only allows handling reported epoch >= current pd's.
// Leader peer reports region status with RegionHeartbeatRequest
// to pd regularly, pd will determine whether this region
// should do ChangePeer or not.
// E,g, max peer number is 3, region A, first only peer 1 in A.
// 1. Pd region state -> Peers (1), ConfVer (1).
// 2. Leader peer 1 reports region state to pd, pd finds the
// peer number is < 3, so first changes its current region
// state -> Peers (1, 2), ConfVer (1), and returns ChangePeer Adding 2.
// 3. Leader does ChangePeer, then reports Peers (1, 2), ConfVer (2),
// pd updates its state -> Peers (1, 2), ConfVer (2).
// 4. Leader may report old Peers (1), ConfVer (1) to pd before ConfChange
// finished, pd stills responses ChangePeer Adding 2, of course, we must
// guarantee the second ChangePeer can't be applied in TiKV.
ChangePeer change_peer = 2;
// Pd can return transfer_leader to let TiKV does leader transfer itself.
TransferLeader transfer_leader = 3;
// ID of the region
uint64 region_id = 4;
metapb.RegionEpoch region_epoch = 5;
// Leader of the region at the moment of the corresponding request was made.
metapb.Peer target_peer = 6;
Merge merge = 7;
// PD sends split_region to let TiKV split a region into two regions.
SplitRegion split_region = 8;
}
message AskSplitRequest {
RequestHeader header = 1;
metapb.Region region = 2;
}
message AskSplitResponse {
ResponseHeader header = 1;
// We split the region into two, first uses the origin
// parent region id, and the second uses the new_region_id.
// We must guarantee that the new_region_id is global unique.
uint64 new_region_id = 2;
// The peer ids for the new split region.
repeated uint64 new_peer_ids = 3;
}
message ReportSplitRequest {
RequestHeader header = 1;
metapb.Region left = 2;
metapb.Region right = 3;
}
message ReportSplitResponse {
ResponseHeader header = 1;
}
message AskBatchSplitRequest {
RequestHeader header = 1;
metapb.Region region = 2;
uint32 split_count = 3;
}
message SplitID {
uint64 new_region_id = 1;
repeated uint64 new_peer_ids = 2;
}
message AskBatchSplitResponse {
ResponseHeader header = 1;
repeated SplitID ids = 2;
}
message ReportBatchSplitRequest {
RequestHeader header = 1;
repeated metapb.Region regions = 2;
}
message ReportBatchSplitResponse {
ResponseHeader header = 1;
}
message TimeInterval {
// The unix timestamp in seconds of the start of this period.
uint64 start_timestamp = 1;
// The unix timestamp in seconds of the end of this period.
uint64 end_timestamp = 2;
}
message RecordPair {
string key = 1;
uint64 value = 2;
}
message StoreStats {
uint64 store_id = 1;
// Capacity for the store.
uint64 capacity = 2;
// Available size for the store.
uint64 available = 3;
// Total region count in this store.
uint32 region_count = 4;
// Current sending snapshot count.
uint32 sending_snap_count = 5;
// Current receiving snapshot count.
uint32 receiving_snap_count = 6;
// When the store is started (unix timestamp in seconds).
uint32 start_time = 7;
// How many region is applying snapshot.
uint32 applying_snap_count = 8;
// If the store is busy
bool is_busy = 9;
// Actually used space by db
uint64 used_size = 10;
// Bytes written for the store during this period.
uint64 bytes_written = 11;
// Keys written for the store during this period.
uint64 keys_written = 12;
// Bytes read for the store during this period.
uint64 bytes_read = 13;
// Keys read for the store during this period.
uint64 keys_read = 14;
// Actually reported time interval
TimeInterval interval = 15;
// Threads' CPU usages in the store
repeated RecordPair cpu_usages = 16;
// Threads' read disk I/O rates in the store
repeated RecordPair read_io_rates = 17;
// Threads' write disk I/O rates in the store
repeated RecordPair write_io_rates = 18;
// Operations' latencies in the store
repeated RecordPair op_latencies = 19;
}
message StoreHeartbeatRequest {
RequestHeader header = 1;
StoreStats stats = 2;
}
message StoreHeartbeatResponse {
ResponseHeader header = 1;
}
message ScatterRegionRequest {
RequestHeader header = 1;
uint64 region_id = 2;
// PD will use these region information if it can't find the region.
// For example, the region is just split and hasn't report to PD yet.
metapb.Region region = 3;
metapb.Peer leader = 4;
}
message ScatterRegionResponse {
ResponseHeader header = 1;
}
message GetGCSafePointRequest {
RequestHeader header = 1;
}
message GetGCSafePointResponse {
ResponseHeader header = 1;
uint64 safe_point = 2;
}
message UpdateGCSafePointRequest {
RequestHeader header = 1;
uint64 safe_point = 2;
}
message UpdateGCSafePointResponse {
ResponseHeader header = 1;
uint64 new_safe_point = 2;
}
message SyncRegionRequest{
RequestHeader header = 1;
Member member = 2;
// the follower PD will use the start index to locate historical changes
// that require synchronization.
uint64 start_index = 3;
}
message SyncRegionResponse{
ResponseHeader header = 1;
// the leader PD will send the repsonds include
// changed regions records and the index of the first record.
repeated metapb.Region regions = 2;
uint64 start_index = 3;
}
message GetOperatorRequest {
RequestHeader header = 1;
uint64 region_id = 2;
}
enum OperatorStatus {
SUCCESS = 0;
TIMEOUT = 1;
CANCEL = 2;
REPLACE = 3;
RUNNING = 4;
}
message GetOperatorResponse {
ResponseHeader header = 1;
uint64 region_id = 2;
bytes desc = 3;
OperatorStatus status = 4;
bytes kind = 5;
}