1 /*
2 * SystemData.cpp
3 *
4 * This source file is part of the FoundationDB open source project
5 *
6 * Copyright 2013-2018 Apple Inc. and the FoundationDB project authors
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 */
20
21 #include "fdbclient/SystemData.h"
22 #include "fdbclient/StorageServerInterface.h"
23 #include "flow/TDMetric.actor.h"
24
25 const KeyRef systemKeysPrefix = LiteralStringRef("\xff");
26 const KeyRangeRef normalKeys(KeyRef(), systemKeysPrefix);
27 const KeyRangeRef systemKeys(systemKeysPrefix, LiteralStringRef("\xff\xff") );
28 const KeyRangeRef nonMetadataSystemKeys(LiteralStringRef("\xff\x02"), LiteralStringRef("\xff\x03"));
29 const KeyRangeRef allKeys = KeyRangeRef(normalKeys.begin, systemKeys.end);
30 const KeyRef afterAllKeys = LiteralStringRef("\xff\xff\x00");
31
32 // keyServersKeys.contains(k) iff k.startsWith(keyServersPrefix)
33 const KeyRangeRef keyServersKeys( LiteralStringRef("\xff/keyServers/"), LiteralStringRef("\xff/keyServers0") );
34 const KeyRef keyServersPrefix = keyServersKeys.begin;
35 const KeyRef keyServersEnd = keyServersKeys.end;
36 const KeyRangeRef keyServersKeyServersKeys ( LiteralStringRef("\xff/keyServers/\xff/keyServers/"), LiteralStringRef("\xff/keyServers/\xff/keyServers0"));
37 const KeyRef keyServersKeyServersKey = keyServersKeyServersKeys.begin;
38
keyServersKey(const KeyRef & k)39 const Key keyServersKey( const KeyRef& k ) {
40 return k.withPrefix( keyServersPrefix );
41 }
keyServersKey(const KeyRef & k,Arena & arena)42 const KeyRef keyServersKey( const KeyRef& k, Arena& arena ) {
43 return k.withPrefix( keyServersPrefix, arena );
44 }
keyServersValue(const vector<UID> & src,const vector<UID> & dest)45 const Value keyServersValue( const vector<UID>& src, const vector<UID>& dest ) {
46 // src and dest are expected to be sorted
47 ASSERT( std::is_sorted(src.begin(), src.end()) && std::is_sorted(dest.begin(), dest.end()) );
48 BinaryWriter wr((IncludeVersion())); wr << src << dest;
49 return wr.toValue();
50 }
decodeKeyServersValue(const ValueRef & value,vector<UID> & src,vector<UID> & dest)51 void decodeKeyServersValue( const ValueRef& value, vector<UID>& src, vector<UID>& dest ) {
52 if (value.size()) {
53 BinaryReader rd(value, IncludeVersion());
54 rd >> src >> dest;
55 } else {
56 src.clear();
57 dest.clear();
58 }
59 }
60
logsValue(const vector<std::pair<UID,NetworkAddress>> & logs,const vector<std::pair<UID,NetworkAddress>> & oldLogs)61 const Value logsValue( const vector<std::pair<UID, NetworkAddress>>& logs, const vector<std::pair<UID, NetworkAddress>>& oldLogs ) {
62 BinaryWriter wr(IncludeVersion());
63 wr << logs;
64 wr << oldLogs;
65 return wr.toValue();
66 }
decodeLogsValue(const ValueRef & value)67 std::pair<vector<std::pair<UID, NetworkAddress>>,vector<std::pair<UID, NetworkAddress>>> decodeLogsValue( const ValueRef& value ) {
68 vector<std::pair<UID, NetworkAddress>> logs;
69 vector<std::pair<UID, NetworkAddress>> oldLogs;
70 BinaryReader reader( value, IncludeVersion() );
71 reader >> logs;
72 reader >> oldLogs;
73 return std::make_pair(logs, oldLogs);
74 }
75
76
77 const KeyRef serverKeysPrefix = LiteralStringRef("\xff/serverKeys/");
78 const ValueRef serverKeysTrue = LiteralStringRef("1"), // compatible with what was serverKeysTrue
79 serverKeysFalse;
80
serverKeysKey(UID serverID,const KeyRef & key)81 const Key serverKeysKey( UID serverID, const KeyRef& key ) {
82 BinaryWriter wr(Unversioned());
83 wr.serializeBytes( serverKeysPrefix );
84 wr << serverID;
85 wr.serializeBytes( LiteralStringRef("/") );
86 wr.serializeBytes( key );
87 return wr.toValue();
88 }
serverKeysPrefixFor(UID serverID)89 const Key serverKeysPrefixFor( UID serverID ) {
90 BinaryWriter wr(Unversioned());
91 wr.serializeBytes( serverKeysPrefix );
92 wr << serverID;
93 wr.serializeBytes( LiteralStringRef("/") );
94 return wr.toValue();
95 }
serverKeysDecodeServer(const KeyRef & key)96 UID serverKeysDecodeServer( const KeyRef& key ) {
97 UID server_id;
98 BinaryReader rd( key.removePrefix(serverKeysPrefix), Unversioned() );
99 rd >> server_id;
100 return server_id;
101 }
serverHasKey(ValueRef storedValue)102 bool serverHasKey( ValueRef storedValue ) {
103 return storedValue == serverKeysTrue;
104 }
105
106 const KeyRangeRef serverTagKeys(
107 LiteralStringRef("\xff/serverTag/"),
108 LiteralStringRef("\xff/serverTag0") );
109 const KeyRef serverTagPrefix = serverTagKeys.begin;
110 const KeyRangeRef serverTagConflictKeys(
111 LiteralStringRef("\xff/serverTagConflict/"),
112 LiteralStringRef("\xff/serverTagConflict0") );
113 const KeyRef serverTagConflictPrefix = serverTagConflictKeys.begin;
114 const KeyRangeRef serverTagHistoryKeys(
115 LiteralStringRef("\xff/serverTagHistory/"),
116 LiteralStringRef("\xff/serverTagHistory0") );
117 const KeyRef serverTagHistoryPrefix = serverTagHistoryKeys.begin;
118
serverTagKeyFor(UID serverID)119 const Key serverTagKeyFor( UID serverID ) {
120 BinaryWriter wr(Unversioned());
121 wr.serializeBytes( serverTagKeys.begin );
122 wr << serverID;
123 return wr.toValue();
124 }
125
serverTagHistoryKeyFor(UID serverID)126 const Key serverTagHistoryKeyFor( UID serverID ) {
127 BinaryWriter wr(Unversioned());
128 wr.serializeBytes( serverTagHistoryKeys.begin );
129 wr << serverID;
130 return addVersionStampAtEnd(wr.toValue());
131 }
132
serverTagHistoryRangeFor(UID serverID)133 const KeyRange serverTagHistoryRangeFor( UID serverID ) {
134 BinaryWriter wr(Unversioned());
135 wr.serializeBytes( serverTagHistoryKeys.begin );
136 wr << serverID;
137 return prefixRange(wr.toValue());
138 }
139
serverTagHistoryRangeBefore(UID serverID,Version version)140 const KeyRange serverTagHistoryRangeBefore( UID serverID, Version version ) {
141 BinaryWriter wr(Unversioned());
142 wr.serializeBytes( serverTagHistoryKeys.begin );
143 wr << serverID;
144 version = bigEndian64(version);
145
146 Key versionStr = makeString( 8 );
147 uint8_t* data = mutateString( versionStr );
148 memcpy(data, &version, 8);
149
150 return KeyRangeRef( wr.toValue(), versionStr.withPrefix(wr.toValue()) );
151 }
152
serverTagValue(Tag tag)153 const Value serverTagValue( Tag tag ) {
154 BinaryWriter wr(IncludeVersion());
155 wr << tag;
156 return wr.toValue();
157 }
158
decodeServerTagKey(KeyRef const & key)159 UID decodeServerTagKey( KeyRef const& key ) {
160 UID serverID;
161 BinaryReader rd( key.removePrefix(serverTagKeys.begin), Unversioned() );
162 rd >> serverID;
163 return serverID;
164 }
165
decodeServerTagHistoryKey(KeyRef const & key)166 Version decodeServerTagHistoryKey( KeyRef const& key ) {
167 Version parsedVersion;
168 memcpy(&parsedVersion, key.substr(key.size()-10).begin(), sizeof(Version));
169 parsedVersion = bigEndian64(parsedVersion);
170 return parsedVersion;
171 }
172
decodeServerTagValue(ValueRef const & value)173 Tag decodeServerTagValue( ValueRef const& value ) {
174 Tag s;
175 BinaryReader reader( value, IncludeVersion() );
176 if( reader.protocolVersion() < 0x0FDB00A560010001LL ) {
177 int16_t id;
178 reader >> id;
179 if(id == invalidTagOld) {
180 s = invalidTag;
181 } else if(id == txsTagOld) {
182 s = txsTag;
183 } else {
184 ASSERT(id >= 0);
185 s.id = id;
186 s.locality = tagLocalityUpgraded;
187 }
188 } else {
189 reader >> s;
190 }
191 return s;
192 }
193
serverTagConflictKeyFor(Tag tag)194 const Key serverTagConflictKeyFor( Tag tag ) {
195 BinaryWriter wr(Unversioned());
196 wr.serializeBytes( serverTagConflictKeys.begin );
197 wr << tag;
198 return wr.toValue();
199 }
200
201 const KeyRangeRef tagLocalityListKeys(
202 LiteralStringRef("\xff/tagLocalityList/"),
203 LiteralStringRef("\xff/tagLocalityList0") );
204 const KeyRef tagLocalityListPrefix = tagLocalityListKeys.begin;
205
tagLocalityListKeyFor(Optional<Value> dcID)206 const Key tagLocalityListKeyFor( Optional<Value> dcID ) {
207 BinaryWriter wr(AssumeVersion(currentProtocolVersion));
208 wr.serializeBytes( tagLocalityListKeys.begin );
209 wr << dcID;
210 return wr.toValue();
211 }
212
tagLocalityListValue(int8_t const & tagLocality)213 const Value tagLocalityListValue( int8_t const& tagLocality ) {
214 BinaryWriter wr(IncludeVersion());
215 wr << tagLocality;
216 return wr.toValue();
217 }
decodeTagLocalityListKey(KeyRef const & key)218 Optional<Value> decodeTagLocalityListKey( KeyRef const& key ) {
219 Optional<Value> dcID;
220 BinaryReader rd( key.removePrefix(tagLocalityListKeys.begin), AssumeVersion(currentProtocolVersion) );
221 rd >> dcID;
222 return dcID;
223 }
decodeTagLocalityListValue(ValueRef const & value)224 int8_t decodeTagLocalityListValue( ValueRef const& value ) {
225 int8_t s;
226 BinaryReader reader( value, IncludeVersion() );
227 reader >> s;
228 return s;
229 }
230
231 const KeyRangeRef datacenterReplicasKeys(
232 LiteralStringRef("\xff\x02/datacenterReplicas/"),
233 LiteralStringRef("\xff\x02/datacenterReplicas0") );
234 const KeyRef datacenterReplicasPrefix = datacenterReplicasKeys.begin;
235
datacenterReplicasKeyFor(Optional<Value> dcID)236 const Key datacenterReplicasKeyFor( Optional<Value> dcID ) {
237 BinaryWriter wr(AssumeVersion(currentProtocolVersion));
238 wr.serializeBytes( datacenterReplicasKeys.begin );
239 wr << dcID;
240 return wr.toValue();
241 }
242
datacenterReplicasValue(int const & replicas)243 const Value datacenterReplicasValue( int const& replicas ) {
244 BinaryWriter wr(IncludeVersion());
245 wr << replicas;
246 return wr.toValue();
247 }
decodeDatacenterReplicasKey(KeyRef const & key)248 Optional<Value> decodeDatacenterReplicasKey( KeyRef const& key ) {
249 Optional<Value> dcID;
250 BinaryReader rd( key.removePrefix(datacenterReplicasKeys.begin), AssumeVersion(currentProtocolVersion) );
251 rd >> dcID;
252 return dcID;
253 }
decodeDatacenterReplicasValue(ValueRef const & value)254 int decodeDatacenterReplicasValue( ValueRef const& value ) {
255 int s;
256 BinaryReader reader( value, IncludeVersion() );
257 reader >> s;
258 return s;
259 }
260
261 // "\xff\x02/tLogDatacenters/[[datacenterID]]"
262 extern const KeyRangeRef tLogDatacentersKeys;
263 extern const KeyRef tLogDatacentersPrefix;
264 const Key tLogDatacentersKeyFor( Optional<Value> dcID );
265
266 const KeyRangeRef tLogDatacentersKeys(
267 LiteralStringRef("\xff\x02/tLogDatacenters/"),
268 LiteralStringRef("\xff\x02/tLogDatacenters0") );
269 const KeyRef tLogDatacentersPrefix = tLogDatacentersKeys.begin;
270
tLogDatacentersKeyFor(Optional<Value> dcID)271 const Key tLogDatacentersKeyFor( Optional<Value> dcID ) {
272 BinaryWriter wr(AssumeVersion(currentProtocolVersion));
273 wr.serializeBytes( tLogDatacentersKeys.begin );
274 wr << dcID;
275 return wr.toValue();
276 }
decodeTLogDatacentersKey(KeyRef const & key)277 Optional<Value> decodeTLogDatacentersKey( KeyRef const& key ) {
278 Optional<Value> dcID;
279 BinaryReader rd( key.removePrefix(tLogDatacentersKeys.begin), AssumeVersion(currentProtocolVersion) );
280 rd >> dcID;
281 return dcID;
282 }
283
284 const KeyRef primaryDatacenterKey = LiteralStringRef("\xff/primaryDatacenter");
285
286 // serverListKeys.contains(k) iff k.startsWith( serverListKeys.begin ) because '/'+1 == '0'
287 const KeyRangeRef serverListKeys(
288 LiteralStringRef("\xff/serverList/"),
289 LiteralStringRef("\xff/serverList0") );
290 const KeyRef serverListPrefix = serverListKeys.begin;
291
serverListKeyFor(UID serverID)292 const Key serverListKeyFor( UID serverID ) {
293 BinaryWriter wr(Unversioned());
294 wr.serializeBytes( serverListKeys.begin );
295 wr << serverID;
296 return wr.toValue();
297 }
298
serverListValue(StorageServerInterface const & server)299 const Value serverListValue( StorageServerInterface const& server ) {
300 BinaryWriter wr(IncludeVersion());
301 wr << server;
302 return wr.toValue();
303 }
decodeServerListKey(KeyRef const & key)304 UID decodeServerListKey( KeyRef const& key ) {
305 UID serverID;
306 BinaryReader rd( key.removePrefix(serverListKeys.begin), Unversioned() );
307 rd >> serverID;
308 return serverID;
309 }
decodeServerListValue(ValueRef const & value)310 StorageServerInterface decodeServerListValue( ValueRef const& value ) {
311 StorageServerInterface s;
312 BinaryReader reader( value, IncludeVersion() );
313 reader >> s;
314 return s;
315 }
316
317 // processClassKeys.contains(k) iff k.startsWith( processClassKeys.begin ) because '/'+1 == '0'
318 const KeyRangeRef processClassKeys(
319 LiteralStringRef("\xff/processClass/"),
320 LiteralStringRef("\xff/processClass0") );
321 const KeyRef processClassPrefix = processClassKeys.begin;
322 const KeyRef processClassChangeKey = LiteralStringRef("\xff/processClassChanges");
323 const KeyRef processClassVersionKey = LiteralStringRef("\xff/processClassChangesVersion");
324 const ValueRef processClassVersionValue = LiteralStringRef("1");
325
processClassKeyFor(StringRef processID)326 const Key processClassKeyFor(StringRef processID ) {
327 BinaryWriter wr(Unversioned());
328 wr.serializeBytes( processClassKeys.begin );
329 wr << processID;
330 return wr.toValue();
331 }
332
processClassValue(ProcessClass const & processClass)333 const Value processClassValue( ProcessClass const& processClass ) {
334 BinaryWriter wr(IncludeVersion());
335 wr << processClass;
336 return wr.toValue();
337 }
338
decodeProcessClassKey(KeyRef const & key)339 Key decodeProcessClassKey( KeyRef const& key ) {
340 StringRef processID;
341 BinaryReader rd( key.removePrefix(processClassKeys.begin), Unversioned() );
342 rd >> processID;
343 return processID;
344 }
345
decodeProcessClassKeyOld(KeyRef const & key)346 UID decodeProcessClassKeyOld( KeyRef const& key ) {
347 UID processID;
348 BinaryReader rd( key.removePrefix(processClassKeys.begin), Unversioned() );
349 rd >> processID;
350 return processID;
351 }
352
decodeProcessClassValue(ValueRef const & value)353 ProcessClass decodeProcessClassValue( ValueRef const& value ) {
354 ProcessClass s;
355 BinaryReader reader( value, IncludeVersion() );
356 reader >> s;
357 return s;
358 }
359
360 const KeyRangeRef configKeys( LiteralStringRef("\xff/conf/"), LiteralStringRef("\xff/conf0") );
361 const KeyRef configKeysPrefix = configKeys.begin;
362
363 const KeyRangeRef excludedServersKeys( LiteralStringRef("\xff/conf/excluded/"), LiteralStringRef("\xff/conf/excluded0") );
364 const KeyRef excludedServersPrefix = excludedServersKeys.begin;
365 const KeyRef excludedServersVersionKey = LiteralStringRef("\xff/conf/excluded");
decodeExcludedServersKey(KeyRef const & key)366 const AddressExclusion decodeExcludedServersKey( KeyRef const& key ) {
367 ASSERT( key.startsWith( excludedServersPrefix ) );
368 // Returns an invalid NetworkAddress if given an invalid key (within the prefix)
369 // Excluded servers have IP in x.x.x.x format, port optional, and no SSL suffix
370 // Returns a valid, public NetworkAddress with a port of 0 if the key represents an IP address alone (meaning all ports)
371 // Returns a valid, public NetworkAddress with nonzero port if the key represents an IP:PORT combination
372
373 return AddressExclusion::parse(key.removePrefix( excludedServersPrefix ));
374 }
encodeExcludedServersKey(AddressExclusion const & addr)375 std::string encodeExcludedServersKey( AddressExclusion const& addr ) {
376 //FIXME: make sure what's persisted here is not affected by innocent changes elsewhere
377 return excludedServersPrefix.toString() + addr.toString();
378 }
379
380 const KeyRangeRef workerListKeys( LiteralStringRef("\xff/worker/"), LiteralStringRef("\xff/worker0") );
381 const KeyRef workerListPrefix = workerListKeys.begin;
382
workerListKeyFor(StringRef processID)383 const Key workerListKeyFor( StringRef processID ) {
384 BinaryWriter wr(Unversioned());
385 wr.serializeBytes( workerListKeys.begin );
386 wr << processID;
387 return wr.toValue();
388 }
389
workerListValue(ProcessData const & processData)390 const Value workerListValue( ProcessData const& processData ) {
391 BinaryWriter wr(IncludeVersion());
392 wr << processData;
393 return wr.toValue();
394 }
395
decodeWorkerListKey(KeyRef const & key)396 Key decodeWorkerListKey(KeyRef const& key) {
397 StringRef processID;
398 BinaryReader rd( key.removePrefix(workerListKeys.begin), Unversioned() );
399 rd >> processID;
400 return processID;
401 }
402
decodeWorkerListValue(ValueRef const & value)403 ProcessData decodeWorkerListValue( ValueRef const& value ) {
404 ProcessData s;
405 BinaryReader reader( value, IncludeVersion() );
406 reader >> s;
407 return s;
408 }
409
410 const KeyRef coordinatorsKey = LiteralStringRef("\xff/coordinators");
411 const KeyRef logsKey = LiteralStringRef("\xff/logs");
412 const KeyRef minRequiredCommitVersionKey = LiteralStringRef("\xff/minRequiredCommitVersion");
413
414 const KeyRef globalKeysPrefix = LiteralStringRef("\xff/globals");
415 const KeyRef lastEpochEndKey = LiteralStringRef("\xff/globals/lastEpochEnd");
416 const KeyRef lastEpochEndPrivateKey = LiteralStringRef("\xff\xff/globals/lastEpochEnd");
417 const KeyRef killStorageKey = LiteralStringRef("\xff/globals/killStorage");
418 const KeyRef killStoragePrivateKey = LiteralStringRef("\xff\xff/globals/killStorage");
419 const KeyRef rebootWhenDurableKey = LiteralStringRef("\xff/globals/rebootWhenDurable");
420 const KeyRef rebootWhenDurablePrivateKey = LiteralStringRef("\xff\xff/globals/rebootWhenDurable");
421 const KeyRef primaryLocalityKey = LiteralStringRef("\xff/globals/primaryLocality");
422 const KeyRef primaryLocalityPrivateKey = LiteralStringRef("\xff\xff/globals/primaryLocality");
423 const KeyRef fastLoggingEnabled = LiteralStringRef("\xff/globals/fastLoggingEnabled");
424 const KeyRef fastLoggingEnabledPrivateKey = LiteralStringRef("\xff\xff/globals/fastLoggingEnabled");
425
426 const KeyRef moveKeysLockOwnerKey = LiteralStringRef("\xff/moveKeysLock/Owner");
427 const KeyRef moveKeysLockWriteKey = LiteralStringRef("\xff/moveKeysLock/Write");
428
429 const KeyRef dataDistributionModeKey = LiteralStringRef("\xff/dataDistributionMode");
430 const UID dataDistributionModeLock = UID(6345,3425);
431
432 // Client status info prefix
433 const KeyRangeRef fdbClientInfoPrefixRange(LiteralStringRef("\xff\x02/fdbClientInfo/"), LiteralStringRef("\xff\x02/fdbClientInfo0"));
434 const KeyRef fdbClientInfoTxnSampleRate = LiteralStringRef("\xff\x02/fdbClientInfo/client_txn_sample_rate/");
435 const KeyRef fdbClientInfoTxnSizeLimit = LiteralStringRef("\xff\x02/fdbClientInfo/client_txn_size_limit/");
436
437 // Request latency measurement key
438 const KeyRef latencyBandConfigKey = LiteralStringRef("\xff\x02/latencyBandConfig");
439
440 // Keyspace to maintain wall clock to version map
441 const KeyRangeRef timeKeeperPrefixRange(LiteralStringRef("\xff\x02/timeKeeper/map/"), LiteralStringRef("\xff\x02/timeKeeper/map0"));
442 const KeyRef timeKeeperVersionKey = LiteralStringRef("\xff\x02/timeKeeper/version");
443 const KeyRef timeKeeperDisableKey = LiteralStringRef("\xff\x02/timeKeeper/disable");
444
445 // Backup Log Mutation constant variables
446 const KeyRef backupEnabledKey = LiteralStringRef("\xff/backupEnabled");
447 const KeyRangeRef backupLogKeys(LiteralStringRef("\xff\x02/blog/"), LiteralStringRef("\xff\x02/blog0"));
448 const KeyRangeRef applyLogKeys(LiteralStringRef("\xff\x02/alog/"), LiteralStringRef("\xff\x02/alog0"));
449 //static_assert( backupLogKeys.begin.size() == backupLogPrefixBytes, "backupLogPrefixBytes incorrect" );
450 const KeyRef backupVersionKey = LiteralStringRef("\xff/backupDataFormat");
451 const ValueRef backupVersionValue = LiteralStringRef("4");
452 const int backupVersion = 4;
453
454 // Log Range constant variables
455 // \xff/logRanges/[16-byte UID][begin key] := serialize( make_pair([end key], [destination key prefix]), IncludeVersion() )
456 const KeyRangeRef logRangesRange(LiteralStringRef("\xff/logRanges/"), LiteralStringRef("\xff/logRanges0"));
457
458 // Layer status metadata prefix
459 const KeyRangeRef layerStatusMetaPrefixRange(LiteralStringRef("\xff\x02/status/"), LiteralStringRef("\xff\x02/status0"));
460
461 // Backup agent status root
462 const KeyRangeRef backupStatusPrefixRange(LiteralStringRef("\xff\x02/backupstatus/"), LiteralStringRef("\xff\x02/backupstatus0"));
463
464 // Restore configuration constant variables
465 const KeyRangeRef fileRestorePrefixRange(LiteralStringRef("\xff\x02/restore-agent/"), LiteralStringRef("\xff\x02/restore-agent0"));
466
467 // Backup Agent configuration constant variables
468 const KeyRangeRef fileBackupPrefixRange(LiteralStringRef("\xff\x02/backup-agent/"), LiteralStringRef("\xff\x02/backup-agent0"));
469
470 // DR Agent configuration constant variables
471 const KeyRangeRef databaseBackupPrefixRange(LiteralStringRef("\xff\x02/db-backup-agent/"), LiteralStringRef("\xff\x02/db-backup-agent0"));
472
473 // \xff\x02/sharedLogRangesConfig/destUidLookup/[keyRange]
474 const KeyRef destUidLookupPrefix = LiteralStringRef("\xff\x02/sharedLogRangesConfig/destUidLookup/");
475 // \xff\x02/sharedLogRangesConfig/backuplatestVersions/[destUid]/[logUid]
476 const KeyRef backupLatestVersionsPrefix = LiteralStringRef("\xff\x02/sharedLogRangesConfig/backupLatestVersions/");
477
478 // Returns the encoded key comprised of begin key and log uid
logRangesEncodeKey(KeyRef keyBegin,UID logUid)479 Key logRangesEncodeKey(KeyRef keyBegin, UID logUid) {
480 return keyBegin.withPrefix(uidPrefixKey(logRangesRange.begin, logUid));
481 }
482
483 // Returns the start key and optionally the logRange Uid
logRangesDecodeKey(KeyRef key,UID * logUid)484 KeyRef logRangesDecodeKey(KeyRef key, UID* logUid) {
485 if (key.size() < logRangesRange.begin.size() + sizeof(UID)) {
486 TraceEvent(SevError, "InvalidDecodeKey").detail("Key", key);
487 ASSERT(false);
488 }
489
490 if (logUid) {
491 *logUid = BinaryReader::fromStringRef<UID>(key.removePrefix(logRangesRange.begin), Unversioned());
492 }
493
494 return key.substr(logRangesRange.begin.size() + sizeof(UID));
495 }
496
497 // Returns the encoded key value comprised of the end key and destination path
logRangesEncodeValue(KeyRef keyEnd,KeyRef destPath)498 Key logRangesEncodeValue(KeyRef keyEnd, KeyRef destPath) {
499 BinaryWriter wr(IncludeVersion());
500 wr << std::make_pair(keyEnd, destPath);
501 return wr.toValue();
502 }
503
504 // \xff/logRanges/[16-byte UID][begin key] := serialize( make_pair([end key], [destination key prefix]), IncludeVersion() )
logRangesDecodeValue(KeyRef keyValue,Key * destKeyPrefix)505 Key logRangesDecodeValue(KeyRef keyValue, Key* destKeyPrefix) {
506 std::pair<KeyRef,KeyRef> endPrefixCombo;
507
508 BinaryReader rd( keyValue, IncludeVersion() );
509 rd >> endPrefixCombo;
510
511 if (destKeyPrefix) {
512 *destKeyPrefix = endPrefixCombo.second;
513 }
514
515 return endPrefixCombo.first;
516 }
517
518 // Returns a key prefixed with the specified key with
519 // the uid encoded at the end
uidPrefixKey(KeyRef keyPrefix,UID logUid)520 Key uidPrefixKey(KeyRef keyPrefix, UID logUid) {
521 BinaryWriter bw(Unversioned());
522 bw.serializeBytes(keyPrefix);
523 bw << logUid;
524 return bw.toValue();
525 }
526
527 // Apply mutations constant variables
528 // \xff/applyMutationsEnd/[16-byte UID] := serialize( endVersion, Unversioned() )
529 const KeyRangeRef applyMutationsEndRange(LiteralStringRef("\xff/applyMutationsEnd/"), LiteralStringRef("\xff/applyMutationsEnd0"));
530
531 // \xff/applyMutationsBegin/[16-byte UID] := serialize( beginVersion, Unversioned() )
532 const KeyRangeRef applyMutationsBeginRange(LiteralStringRef("\xff/applyMutationsBegin/"), LiteralStringRef("\xff/applyMutationsBegin0"));
533
534 // \xff/applyMutationsAddPrefix/[16-byte UID] := addPrefix
535 const KeyRangeRef applyMutationsAddPrefixRange(LiteralStringRef("\xff/applyMutationsAddPrefix/"), LiteralStringRef("\xff/applyMutationsAddPrefix0"));
536
537 // \xff/applyMutationsRemovePrefix/[16-byte UID] := removePrefix
538 const KeyRangeRef applyMutationsRemovePrefixRange(LiteralStringRef("\xff/applyMutationsRemovePrefix/"), LiteralStringRef("\xff/applyMutationsRemovePrefix0"));
539
540 const KeyRangeRef applyMutationsKeyVersionMapRange(LiteralStringRef("\xff/applyMutationsKeyVersionMap/"), LiteralStringRef("\xff/applyMutationsKeyVersionMap0"));
541 const KeyRangeRef applyMutationsKeyVersionCountRange(LiteralStringRef("\xff\x02/applyMutationsKeyVersionCount/"), LiteralStringRef("\xff\x02/applyMutationsKeyVersionCount0"));
542
543 const KeyRef systemTuplesPrefix = LiteralStringRef("\xff/a/");
544 const KeyRef metricConfChangeKey = LiteralStringRef("\x01TDMetricConfChanges\x00");
545
546 const KeyRangeRef metricConfKeys( LiteralStringRef("\x01TDMetricConf\x00\x01"), LiteralStringRef("\x01TDMetricConf\x00\x02") );
547 const KeyRef metricConfPrefix = metricConfKeys.begin;
548
549 /*
550 const Key metricConfKey( KeyRef const& prefix, MetricNameRef const& name, KeyRef const& key ) {
551 BinaryWriter wr(Unversioned());
552 wr.serializeBytes( prefix );
553 wr.serializeBytes( metricConfPrefix );
554 wr.serializeBytes( name.type );
555 wr.serializeBytes( LiteralStringRef("\x00\x01") );
556 wr.serializeBytes( name.name );
557 wr.serializeBytes( LiteralStringRef("\x00\x01") );
558 wr.serializeBytes( name.address );
559 wr.serializeBytes( LiteralStringRef("\x00\x01") );
560 wr.serializeBytes( name.id );
561 wr.serializeBytes( LiteralStringRef("\x00\x01") );
562 wr.serializeBytes( key );
563 wr.serializeBytes( LiteralStringRef("\x00") );
564 return wr.toValue();
565 }
566
567 std::pair<MetricNameRef, KeyRef> decodeMetricConfKey( KeyRef const& prefix, KeyRef const& key ) {
568 MetricNameRef result;
569 KeyRef withoutPrefix = key.removePrefix( prefix );
570 withoutPrefix = withoutPrefix.removePrefix( metricConfPrefix );
571 int pos = std::find(withoutPrefix.begin(), withoutPrefix.end(), '\x00') - withoutPrefix.begin();
572 result.type = withoutPrefix.substr(0,pos);
573 withoutPrefix = withoutPrefix.substr(pos+2);
574 pos = std::find(withoutPrefix.begin(), withoutPrefix.end(), '\x00') - withoutPrefix.begin();
575 result.name = withoutPrefix.substr(0,pos);
576 withoutPrefix = withoutPrefix.substr(pos+2);
577 pos = std::find(withoutPrefix.begin(), withoutPrefix.end(), '\x00') - withoutPrefix.begin();
578 result.address = withoutPrefix.substr(0,pos);
579 withoutPrefix = withoutPrefix.substr(pos+2);
580 pos = std::find(withoutPrefix.begin(), withoutPrefix.end(), '\x00') - withoutPrefix.begin();
581 result.id = withoutPrefix.substr(0,pos);
582 return std::make_pair( result, withoutPrefix.substr(pos+2,withoutPrefix.size()-pos-3) );
583 }
584 */
585
586 const KeyRef maxUIDKey = LiteralStringRef("\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff");
587
588 const KeyRef databaseLockedKey = LiteralStringRef("\xff/dbLocked");
589 const KeyRef metadataVersionKey = LiteralStringRef("\xff/metadataVersion");
590 const KeyRef metadataVersionRequiredValue = LiteralStringRef("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00");
591 const KeyRef mustContainSystemMutationsKey = LiteralStringRef("\xff/mustContainSystemMutations");
592
593 const KeyRangeRef monitorConfKeys(
594 LiteralStringRef("\xff\x02/monitorConf/"),
595 LiteralStringRef("\xff\x02/monitorConf0")
596 );
597
598 const KeyRef restoreLeaderKey = LiteralStringRef("\xff\x02/restoreLeader");
599 const KeyRangeRef restoreWorkersKeys(
600 LiteralStringRef("\xff\x02/restoreWorkers/"),
601 LiteralStringRef("\xff\x02/restoreWorkers0")
602 );
603
restoreWorkerKeyFor(UID const & agentID)604 const Key restoreWorkerKeyFor( UID const& agentID ) {
605 BinaryWriter wr(Unversioned());
606 wr.serializeBytes( restoreWorkersKeys.begin );
607 wr << agentID;
608 return wr.toValue();
609 }
610
611 const KeyRef healthyZoneKey = LiteralStringRef("\xff\x02/healthyZone");
612
healthyZoneValue(StringRef const & zoneId,Version version)613 const Value healthyZoneValue( StringRef const& zoneId, Version version ) {
614 BinaryWriter wr(IncludeVersion());
615 wr << zoneId;
616 wr << version;
617 return wr.toValue();
618 }
decodeHealthyZoneValue(ValueRef const & value)619 std::pair<Key,Version> decodeHealthyZoneValue( ValueRef const& value) {
620 Key zoneId;
621 Version version;
622 BinaryReader reader( value, IncludeVersion() );
623 reader >> zoneId;
624 reader >> version;
625 return std::make_pair(zoneId, version);
626 }
627