2020-04-09 05:50:55 +08:00
|
|
|
/*
|
|
|
|
* SpecialKeySpace.actor.cpp
|
|
|
|
*
|
|
|
|
* This source file is part of the FoundationDB open source project
|
|
|
|
*
|
|
|
|
* Copyright 2013-2020 Apple Inc. and the FoundationDB project authors
|
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
2021-02-18 17:27:14 +08:00
|
|
|
#include "boost/lexical_cast.hpp"
|
2021-02-20 06:29:08 +08:00
|
|
|
#include "boost/algorithm/string.hpp"
|
2021-02-05 16:55:34 +08:00
|
|
|
|
2021-02-13 10:55:01 +08:00
|
|
|
#include "fdbclient/GlobalConfig.actor.h"
|
2020-03-04 10:35:24 +08:00
|
|
|
#include "fdbclient/SpecialKeySpace.actor.h"
|
2021-02-20 04:22:00 +08:00
|
|
|
#include "flow/Arena.h"
|
2020-03-04 10:35:24 +08:00
|
|
|
#include "flow/UnitTest.h"
|
2020-07-07 02:02:48 +08:00
|
|
|
#include "fdbclient/ManagementAPI.actor.h"
|
|
|
|
#include "fdbclient/StatusClient.h"
|
2020-03-04 10:35:24 +08:00
|
|
|
#include "flow/actorcompiler.h" // This must be the last #include.
|
|
|
|
|
2020-12-04 06:06:11 +08:00
|
|
|
namespace {
|
|
|
|
const std::string kTracingTransactionIdKey = "transaction_id";
|
|
|
|
const std::string kTracingTokenKey = "token";
|
2021-02-26 05:02:56 +08:00
|
|
|
// Max version we can set for minRequiredCommitVersionKey,
|
|
|
|
// making sure the cluster can still be alive for 1000 years after the recovery
|
|
|
|
const Version maxAllowedVerion =
|
|
|
|
std::numeric_limits<int64_t>::max() - 1 - CLIENT_KNOBS->VERSIONS_PER_SECOND * 3600 * 24 * 365 * 1000;
|
2021-01-30 03:45:52 +08:00
|
|
|
|
|
|
|
static bool isAlphaNumeric(const std::string& key) {
|
|
|
|
// [A-Za-z0-9_]+
|
2021-03-11 02:06:03 +08:00
|
|
|
if (!key.size())
|
|
|
|
return false;
|
2021-01-30 03:45:52 +08:00
|
|
|
for (const char& c : key) {
|
2021-03-11 02:06:03 +08:00
|
|
|
if (!((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_'))
|
|
|
|
return false;
|
2021-01-30 03:45:52 +08:00
|
|
|
}
|
|
|
|
return true;
|
2020-12-04 06:06:11 +08:00
|
|
|
}
|
2021-01-30 03:45:52 +08:00
|
|
|
} // namespace
|
2020-12-04 06:06:11 +08:00
|
|
|
|
2020-06-30 06:37:46 +08:00
|
|
|
std::unordered_map<SpecialKeySpace::MODULE, KeyRange> SpecialKeySpace::moduleToBoundary = {
|
2020-05-13 17:28:04 +08:00
|
|
|
{ SpecialKeySpace::MODULE::TRANSACTION,
|
|
|
|
KeyRangeRef(LiteralStringRef("\xff\xff/transaction/"), LiteralStringRef("\xff\xff/transaction0")) },
|
|
|
|
{ SpecialKeySpace::MODULE::WORKERINTERFACE,
|
|
|
|
KeyRangeRef(LiteralStringRef("\xff\xff/worker_interfaces/"), LiteralStringRef("\xff\xff/worker_interfaces0")) },
|
|
|
|
{ SpecialKeySpace::MODULE::STATUSJSON, singleKeyRange(LiteralStringRef("\xff\xff/status/json")) },
|
|
|
|
{ SpecialKeySpace::MODULE::CONNECTIONSTRING, singleKeyRange(LiteralStringRef("\xff\xff/connection_string")) },
|
2020-05-19 01:38:23 +08:00
|
|
|
{ SpecialKeySpace::MODULE::CLUSTERFILEPATH, singleKeyRange(LiteralStringRef("\xff\xff/cluster_file_path")) },
|
2020-05-19 05:23:17 +08:00
|
|
|
{ SpecialKeySpace::MODULE::METRICS,
|
2020-06-15 13:29:44 +08:00
|
|
|
KeyRangeRef(LiteralStringRef("\xff\xff/metrics/"), LiteralStringRef("\xff\xff/metrics0")) },
|
2020-07-18 06:16:28 +08:00
|
|
|
{ SpecialKeySpace::MODULE::MANAGEMENT,
|
2020-07-31 17:18:49 +08:00
|
|
|
KeyRangeRef(LiteralStringRef("\xff\xff/management/"), LiteralStringRef("\xff\xff/management0")) },
|
2020-08-14 16:01:08 +08:00
|
|
|
{ SpecialKeySpace::MODULE::ERRORMSG, singleKeyRange(LiteralStringRef("\xff\xff/error_message")) },
|
|
|
|
{ SpecialKeySpace::MODULE::CONFIGURATION,
|
2020-12-01 06:57:17 +08:00
|
|
|
KeyRangeRef(LiteralStringRef("\xff\xff/configuration/"), LiteralStringRef("\xff\xff/configuration0")) },
|
2021-02-13 10:55:01 +08:00
|
|
|
{ SpecialKeySpace::MODULE::GLOBALCONFIG,
|
|
|
|
KeyRangeRef(LiteralStringRef("\xff\xff/global_config/"), LiteralStringRef("\xff\xff/global_config0")) },
|
2020-12-01 06:57:17 +08:00
|
|
|
{ SpecialKeySpace::MODULE::TRACING,
|
2021-05-11 11:26:12 +08:00
|
|
|
KeyRangeRef(LiteralStringRef("\xff\xff/tracing/"), LiteralStringRef("\xff\xff/tracing0")) }
|
2020-05-13 17:28:04 +08:00
|
|
|
};
|
|
|
|
|
2020-07-18 02:56:27 +08:00
|
|
|
std::unordered_map<std::string, KeyRange> SpecialKeySpace::managementApiCommandToRange = {
|
2021-03-11 02:06:03 +08:00
|
|
|
{ "exclude",
|
|
|
|
KeyRangeRef(LiteralStringRef("excluded/"), LiteralStringRef("excluded0"))
|
|
|
|
.withPrefix(moduleToBoundary[MODULE::MANAGEMENT].begin) },
|
|
|
|
{ "failed",
|
|
|
|
KeyRangeRef(LiteralStringRef("failed/"), LiteralStringRef("failed0"))
|
|
|
|
.withPrefix(moduleToBoundary[MODULE::MANAGEMENT].begin) },
|
2020-10-23 02:35:39 +08:00
|
|
|
{ "lock", singleKeyRange(LiteralStringRef("db_locked")).withPrefix(moduleToBoundary[MODULE::MANAGEMENT].begin) },
|
2021-03-11 02:06:03 +08:00
|
|
|
{ "consistencycheck",
|
|
|
|
singleKeyRange(LiteralStringRef("consistency_check_suspended"))
|
|
|
|
.withPrefix(moduleToBoundary[MODULE::MANAGEMENT].begin) },
|
|
|
|
{ "coordinators",
|
|
|
|
KeyRangeRef(LiteralStringRef("coordinators/"), LiteralStringRef("coordinators0"))
|
2021-03-12 04:53:46 +08:00
|
|
|
.withPrefix(moduleToBoundary[MODULE::CONFIGURATION].begin) },
|
|
|
|
{ "advanceversion",
|
|
|
|
singleKeyRange(LiteralStringRef("min_required_commit_version"))
|
|
|
|
.withPrefix(moduleToBoundary[MODULE::MANAGEMENT].begin) },
|
|
|
|
{ "profile",
|
|
|
|
KeyRangeRef(LiteralStringRef("profiling/"), LiteralStringRef("profiling0"))
|
2021-03-27 03:24:45 +08:00
|
|
|
.withPrefix(moduleToBoundary[MODULE::MANAGEMENT].begin) },
|
|
|
|
{ "maintenance",
|
|
|
|
KeyRangeRef(LiteralStringRef("maintenance/"), LiteralStringRef("maintenance0"))
|
|
|
|
.withPrefix(moduleToBoundary[MODULE::MANAGEMENT].begin) },
|
|
|
|
{ "datadistribution",
|
|
|
|
KeyRangeRef(LiteralStringRef("data_distribution/"), LiteralStringRef("data_distribution0"))
|
2021-03-12 04:53:46 +08:00
|
|
|
.withPrefix(moduleToBoundary[MODULE::MANAGEMENT].begin) }
|
2020-07-15 01:31:19 +08:00
|
|
|
};
|
|
|
|
|
2021-02-17 05:46:45 +08:00
|
|
|
std::set<std::string> SpecialKeySpace::options = { "excluded/force", "failed/force" };
|
2020-07-18 03:32:42 +08:00
|
|
|
|
2020-12-05 03:21:39 +08:00
|
|
|
std::set<std::string> SpecialKeySpace::tracingOptions = { kTracingTransactionIdKey, kTracingTokenKey };
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult rywGetRange(ReadYourWritesTransaction* ryw, const KeyRangeRef& kr, const RangeResult& res);
|
2020-09-09 02:08:48 +08:00
|
|
|
|
2020-05-12 15:42:43 +08:00
|
|
|
// This function will move the given KeySelector as far as possible to the standard form:
|
2020-03-04 10:35:24 +08:00
|
|
|
// orEqual == false && offset == 1 (Standard form)
|
2020-05-12 15:42:43 +08:00
|
|
|
// If the corresponding key is not in the underlying key range, it will move over the range
|
2020-06-16 06:31:55 +08:00
|
|
|
// The cache object is used to cache the first read result from the rpc call during the key resolution,
|
|
|
|
// then when we need to do key resolution or result filtering,
|
|
|
|
// we, instead of rpc call, read from this cache object have consistent results
|
2021-03-11 02:06:03 +08:00
|
|
|
ACTOR Future<Void> moveKeySelectorOverRangeActor(const SpecialKeyRangeReadImpl* skrImpl,
|
|
|
|
ReadYourWritesTransaction* ryw,
|
|
|
|
KeySelector* ks,
|
2021-05-04 04:14:16 +08:00
|
|
|
Optional<RangeResult>* cache) {
|
2020-03-04 10:35:24 +08:00
|
|
|
ASSERT(!ks->orEqual); // should be removed before calling
|
|
|
|
ASSERT(ks->offset != 1); // never being called if KeySelector is already normalized
|
|
|
|
|
2020-05-12 15:42:43 +08:00
|
|
|
state Key startKey(skrImpl->getKeyRange().begin);
|
|
|
|
state Key endKey(skrImpl->getKeyRange().end);
|
2021-05-04 04:14:16 +08:00
|
|
|
state RangeResult result;
|
2020-03-04 10:35:24 +08:00
|
|
|
|
|
|
|
if (ks->offset < 1) {
|
|
|
|
// less than the given key
|
2021-03-11 02:06:03 +08:00
|
|
|
if (skrImpl->getKeyRange().contains(ks->getKey()))
|
|
|
|
endKey = ks->getKey();
|
2020-03-04 10:35:24 +08:00
|
|
|
} else {
|
|
|
|
// greater than the given key
|
2021-03-11 02:06:03 +08:00
|
|
|
if (skrImpl->getKeyRange().contains(ks->getKey()))
|
|
|
|
startKey = ks->getKey();
|
2020-03-04 10:35:24 +08:00
|
|
|
}
|
2020-05-15 17:04:15 +08:00
|
|
|
ASSERT(startKey < endKey); // Note : startKey never equals endKey here
|
2020-03-04 10:35:24 +08:00
|
|
|
|
2020-04-08 03:49:46 +08:00
|
|
|
TraceEvent(SevDebug, "NormalizeKeySelector")
|
2020-03-04 10:35:24 +08:00
|
|
|
.detail("OriginalKey", ks->getKey())
|
|
|
|
.detail("OriginalOffset", ks->offset)
|
2020-05-12 15:42:43 +08:00
|
|
|
.detail("SpecialKeyRangeStart", skrImpl->getKeyRange().begin)
|
|
|
|
.detail("SpecialKeyRangeEnd", skrImpl->getKeyRange().end);
|
2020-03-04 10:35:24 +08:00
|
|
|
|
2020-06-12 03:22:19 +08:00
|
|
|
if (skrImpl->isAsync()) {
|
|
|
|
const SpecialKeyRangeAsyncImpl* ptr = dynamic_cast<const SpecialKeyRangeAsyncImpl*>(skrImpl);
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult result_ = wait(ptr->getRange(ryw, KeyRangeRef(startKey, endKey), cache));
|
2020-06-12 03:22:19 +08:00
|
|
|
result = result_;
|
|
|
|
} else {
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult result_ = wait(skrImpl->getRange(ryw, KeyRangeRef(startKey, endKey)));
|
2020-06-12 03:22:19 +08:00
|
|
|
result = result_;
|
|
|
|
}
|
|
|
|
|
2020-03-24 14:55:56 +08:00
|
|
|
if (result.size() == 0) {
|
2020-05-15 08:30:48 +08:00
|
|
|
TraceEvent(SevDebug, "ZeroElementsIntheRange").detail("Start", startKey).detail("End", endKey);
|
2020-03-24 14:55:56 +08:00
|
|
|
return Void();
|
|
|
|
}
|
2020-04-01 00:33:25 +08:00
|
|
|
// Note : KeySelector::setKey has byte limit according to the knobs, customize it if needed
|
2020-03-04 10:35:24 +08:00
|
|
|
if (ks->offset < 1) {
|
|
|
|
if (result.size() >= 1 - ks->offset) {
|
|
|
|
ks->setKey(KeyRef(ks->arena(), result[result.size() - (1 - ks->offset)].key));
|
|
|
|
ks->offset = 1;
|
|
|
|
} else {
|
|
|
|
ks->setKey(KeyRef(ks->arena(), result[0].key));
|
|
|
|
ks->offset += result.size();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (result.size() >= ks->offset) {
|
|
|
|
ks->setKey(KeyRef(ks->arena(), result[ks->offset - 1].key));
|
|
|
|
ks->offset = 1;
|
|
|
|
} else {
|
2020-06-28 03:22:32 +08:00
|
|
|
ks->setKey(KeyRef(
|
|
|
|
ks->arena(),
|
|
|
|
keyAfter(result[result.size() - 1].key))); // TODO : the keyAfter will just return if key == \xff\xff
|
2020-03-04 10:35:24 +08:00
|
|
|
ks->offset -= result.size();
|
|
|
|
}
|
|
|
|
}
|
2020-04-08 03:49:46 +08:00
|
|
|
TraceEvent(SevDebug, "NormalizeKeySelector")
|
2020-03-04 10:35:24 +08:00
|
|
|
.detail("NormalizedKey", ks->getKey())
|
|
|
|
.detail("NormalizedOffset", ks->offset)
|
2020-05-12 15:42:43 +08:00
|
|
|
.detail("SpecialKeyRangeStart", skrImpl->getKeyRange().begin)
|
|
|
|
.detail("SpecialKeyRangeEnd", skrImpl->getKeyRange().end);
|
2020-03-04 10:35:24 +08:00
|
|
|
return Void();
|
|
|
|
}
|
|
|
|
|
2020-05-12 15:42:43 +08:00
|
|
|
// This function will normalize the given KeySelector to a standard KeySelector:
|
|
|
|
// orEqual == false && offset == 1 (Standard form)
|
|
|
|
// If the corresponding key is outside the whole space, it will move to the begin or the end
|
|
|
|
// It does have overhead here since we query all keys twice in the worst case.
|
|
|
|
// However, moving the KeySelector while handling other parameters like limits makes the code much more complex and hard
|
|
|
|
// to maintain; Thus, separate each part to make the code easy to understand and more compact
|
2020-06-18 02:28:52 +08:00
|
|
|
// Boundary is the range of the legal key space, which, by default is the range of the module
|
2020-06-18 03:47:54 +08:00
|
|
|
// And (\xff\xff, \xff\xff\xff) if SPECIAL_KEY_SPACE_RELAXED is turned on
|
2021-03-11 02:06:03 +08:00
|
|
|
ACTOR Future<Void> normalizeKeySelectorActor(SpecialKeySpace* sks,
|
|
|
|
ReadYourWritesTransaction* ryw,
|
|
|
|
KeySelector* ks,
|
|
|
|
KeyRangeRef boundary,
|
|
|
|
int* actualOffset,
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult* result,
|
|
|
|
Optional<RangeResult>* cache) {
|
2020-12-05 06:58:40 +08:00
|
|
|
// If offset < 1, where we need to move left, iter points to the range containing at least one smaller key
|
2020-12-07 06:04:16 +08:00
|
|
|
// (It's a wasting of time to walk through the range whose begin key is same as ks->key)
|
2020-12-05 06:58:40 +08:00
|
|
|
// (rangeContainingKeyBefore itself handles the case where ks->key == Key())
|
|
|
|
// Otherwise, we only need to move right if offset > 1, iter points to the range containing the key
|
|
|
|
// Since boundary.end is always a key in the RangeMap, it is always safe to move right
|
2020-07-15 01:36:47 +08:00
|
|
|
state RangeMap<Key, SpecialKeyRangeReadImpl*, KeyRangeRef>::iterator iter =
|
2020-06-16 03:47:27 +08:00
|
|
|
ks->offset < 1 ? sks->getReadImpls().rangeContainingKeyBefore(ks->getKey())
|
|
|
|
: sks->getReadImpls().rangeContaining(ks->getKey());
|
2020-12-05 06:58:40 +08:00
|
|
|
while ((ks->offset < 1 && iter->begin() >= boundary.begin) || (ks->offset > 1 && iter->begin() < boundary.end)) {
|
2020-05-12 15:42:43 +08:00
|
|
|
if (iter->value() != nullptr) {
|
2020-06-12 03:22:19 +08:00
|
|
|
wait(moveKeySelectorOverRangeActor(iter->value(), ryw, ks, cache));
|
2020-05-12 15:42:43 +08:00
|
|
|
}
|
2020-12-05 06:58:40 +08:00
|
|
|
// Check if we can still move the iterator left
|
|
|
|
if (ks->offset < 1) {
|
2020-12-08 06:26:11 +08:00
|
|
|
if (iter == sks->getReadImpls().ranges().begin()) {
|
2020-12-05 06:58:40 +08:00
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
--iter;
|
|
|
|
}
|
|
|
|
} else if (ks->offset > 1) {
|
|
|
|
// Always safe to move right
|
|
|
|
++iter;
|
|
|
|
}
|
2020-05-12 15:42:43 +08:00
|
|
|
}
|
|
|
|
*actualOffset = ks->offset;
|
|
|
|
|
|
|
|
if (!ks->isFirstGreaterOrEqual()) {
|
2020-10-16 04:55:31 +08:00
|
|
|
TraceEvent(SevDebug, "ReadToBoundary")
|
2020-05-12 15:42:43 +08:00
|
|
|
.detail("TerminateKey", ks->getKey())
|
|
|
|
.detail("TerminateOffset", ks->offset);
|
2021-01-30 03:45:52 +08:00
|
|
|
// If still not normalized after moving to the boundary,
|
2020-12-05 06:58:40 +08:00
|
|
|
// let key selector clamp up to the boundary
|
|
|
|
if (ks->offset < 1) {
|
2020-05-12 15:42:43 +08:00
|
|
|
result->readToBegin = true;
|
2020-12-05 06:58:40 +08:00
|
|
|
ks->setKey(boundary.begin);
|
2021-01-30 03:45:52 +08:00
|
|
|
} else {
|
2020-05-12 15:42:43 +08:00
|
|
|
result->readThroughEnd = true;
|
2020-12-05 06:58:40 +08:00
|
|
|
ks->setKey(boundary.end);
|
|
|
|
}
|
2020-05-12 15:42:43 +08:00
|
|
|
ks->offset = 1;
|
|
|
|
}
|
|
|
|
return Void();
|
|
|
|
}
|
|
|
|
|
2020-07-07 05:02:22 +08:00
|
|
|
SpecialKeySpace::SpecialKeySpace(KeyRef spaceStartKey, KeyRef spaceEndKey, bool testOnly)
|
|
|
|
: range(KeyRangeRef(spaceStartKey, spaceEndKey)), readImpls(nullptr, spaceEndKey), writeImpls(nullptr, spaceEndKey),
|
|
|
|
modules(testOnly ? SpecialKeySpace::MODULE::TESTONLY : SpecialKeySpace::MODULE::UNKNOWN, spaceEndKey) {
|
|
|
|
// Default begin of KeyRangeMap is Key(), insert the range to update start key
|
|
|
|
readImpls.insert(range, nullptr);
|
|
|
|
writeImpls.insert(range, nullptr);
|
2021-03-11 02:06:03 +08:00
|
|
|
if (!testOnly)
|
|
|
|
modulesBoundaryInit(); // testOnly is used in the correctness workload
|
2020-07-07 05:02:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void SpecialKeySpace::modulesBoundaryInit() {
|
|
|
|
for (const auto& pair : moduleToBoundary) {
|
|
|
|
ASSERT(range.contains(pair.second));
|
|
|
|
// Make sure the module is not overlapping with any registered read modules
|
|
|
|
// Note: same like ranges, one module's end cannot be another module's start, relax the condition if needed
|
|
|
|
ASSERT(modules.rangeContaining(pair.second.begin) == modules.rangeContaining(pair.second.end) &&
|
|
|
|
modules[pair.second.begin] == SpecialKeySpace::MODULE::UNKNOWN);
|
|
|
|
modules.insert(pair.second, pair.first);
|
|
|
|
// Note: Due to underlying implementation, the insertion here is important to make cross_module_read being
|
|
|
|
// handled correctly
|
|
|
|
readImpls.insert(pair.second, nullptr);
|
|
|
|
writeImpls.insert(pair.second, nullptr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR Future<RangeResult> SpecialKeySpace::checkRYWValid(SpecialKeySpace* sks,
|
|
|
|
ReadYourWritesTransaction* ryw,
|
|
|
|
KeySelector begin,
|
|
|
|
KeySelector end,
|
|
|
|
GetRangeLimits limits,
|
|
|
|
bool reverse) {
|
2020-06-18 02:13:55 +08:00
|
|
|
ASSERT(ryw);
|
2020-05-21 04:55:07 +08:00
|
|
|
choose {
|
2021-05-04 04:14:16 +08:00
|
|
|
when(RangeResult result =
|
2020-05-21 04:55:07 +08:00
|
|
|
wait(SpecialKeySpace::getRangeAggregationActor(sks, ryw, begin, end, limits, reverse))) {
|
2020-06-18 01:33:52 +08:00
|
|
|
return result;
|
2020-05-15 14:49:57 +08:00
|
|
|
}
|
2020-06-18 02:13:55 +08:00
|
|
|
when(wait(ryw->resetFuture())) { throw internal_error(); }
|
2020-05-06 04:07:09 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR Future<RangeResult> SpecialKeySpace::getRangeAggregationActor(SpecialKeySpace* sks,
|
|
|
|
ReadYourWritesTransaction* ryw,
|
|
|
|
KeySelector begin,
|
|
|
|
KeySelector end,
|
|
|
|
GetRangeLimits limits,
|
|
|
|
bool reverse) {
|
2020-03-04 10:35:24 +08:00
|
|
|
// This function handles ranges which cover more than one keyrange and aggregates all results
|
|
|
|
// KeySelector, GetRangeLimits and reverse are all handled here
|
2021-05-04 04:14:16 +08:00
|
|
|
state RangeResult result;
|
|
|
|
state RangeResult pairs;
|
2020-07-15 01:36:47 +08:00
|
|
|
state RangeMap<Key, SpecialKeyRangeReadImpl*, KeyRangeRef>::iterator iter;
|
2020-03-31 14:27:09 +08:00
|
|
|
state int actualBeginOffset;
|
|
|
|
state int actualEndOffset;
|
2020-06-18 01:33:52 +08:00
|
|
|
state KeyRangeRef moduleBoundary;
|
2020-06-12 03:22:19 +08:00
|
|
|
// used to cache result from potential first read
|
2021-05-04 04:14:16 +08:00
|
|
|
state Optional<RangeResult> cache;
|
2020-04-03 15:26:11 +08:00
|
|
|
|
2020-06-18 03:47:54 +08:00
|
|
|
if (ryw->specialKeySpaceRelaxed()) {
|
|
|
|
moduleBoundary = sks->range;
|
|
|
|
} else {
|
2020-06-18 01:33:52 +08:00
|
|
|
auto beginIter = sks->getModules().rangeContaining(begin.getKey());
|
2020-06-18 03:47:54 +08:00
|
|
|
if (beginIter->begin() <= end.getKey() && end.getKey() <= beginIter->end()) {
|
2020-06-18 01:33:52 +08:00
|
|
|
if (beginIter->value() == SpecialKeySpace::MODULE::UNKNOWN)
|
|
|
|
throw special_keys_no_module_found();
|
|
|
|
else
|
|
|
|
moduleBoundary = beginIter->range();
|
|
|
|
} else {
|
|
|
|
TraceEvent(SevInfo, "SpecialKeyCrossModuleRead")
|
|
|
|
.detail("Begin", begin.toString())
|
|
|
|
.detail("End", end.toString())
|
|
|
|
.detail("BoundaryBegin", beginIter->begin())
|
|
|
|
.detail("BoundaryEnd", beginIter->end());
|
|
|
|
throw special_keys_cross_module_read();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
wait(normalizeKeySelectorActor(sks, ryw, &begin, moduleBoundary, &actualBeginOffset, &result, &cache));
|
|
|
|
wait(normalizeKeySelectorActor(sks, ryw, &end, moduleBoundary, &actualEndOffset, &result, &cache));
|
2020-03-31 14:27:09 +08:00
|
|
|
// Handle all corner cases like what RYW does
|
2020-03-04 10:35:24 +08:00
|
|
|
// return if range inverted
|
2020-03-31 14:27:09 +08:00
|
|
|
if (actualBeginOffset >= actualEndOffset && begin.getKey() >= end.getKey()) {
|
2020-11-11 05:01:07 +08:00
|
|
|
TEST(true); // inverted range
|
2020-06-18 01:33:52 +08:00
|
|
|
return RangeResultRef(false, false);
|
2020-03-31 14:27:09 +08:00
|
|
|
}
|
2020-03-31 16:36:07 +08:00
|
|
|
// If touches begin or end, return with readToBegin and readThroughEnd flags
|
2020-06-18 01:33:52 +08:00
|
|
|
if (begin.getKey() == moduleBoundary.end || end.getKey() == moduleBoundary.begin) {
|
2020-11-11 05:01:07 +08:00
|
|
|
TEST(true); // query touches begin or end
|
2020-06-18 01:33:52 +08:00
|
|
|
return result;
|
2020-03-04 10:35:24 +08:00
|
|
|
}
|
2020-06-16 03:47:27 +08:00
|
|
|
state RangeMap<Key, SpecialKeyRangeReadImpl*, KeyRangeRef>::Ranges ranges =
|
2020-06-15 14:11:57 +08:00
|
|
|
sks->getReadImpls().intersectingRanges(KeyRangeRef(begin.getKey(), end.getKey()));
|
2020-03-04 10:35:24 +08:00
|
|
|
// TODO : workaround to write this two together to make the code compact
|
|
|
|
// The issue here is boost::iterator_range<> doest not provide rbegin(), rend()
|
|
|
|
iter = reverse ? ranges.end() : ranges.begin();
|
|
|
|
if (reverse) {
|
|
|
|
while (iter != ranges.begin()) {
|
|
|
|
--iter;
|
2021-03-11 02:06:03 +08:00
|
|
|
if (iter->value() == nullptr)
|
|
|
|
continue;
|
2020-03-04 10:35:24 +08:00
|
|
|
KeyRangeRef kr = iter->range();
|
|
|
|
KeyRef keyStart = kr.contains(begin.getKey()) ? begin.getKey() : kr.begin;
|
|
|
|
KeyRef keyEnd = kr.contains(end.getKey()) ? end.getKey() : kr.end;
|
2020-06-12 03:22:19 +08:00
|
|
|
if (iter->value()->isAsync() && cache.present()) {
|
|
|
|
const SpecialKeyRangeAsyncImpl* ptr = dynamic_cast<const SpecialKeyRangeAsyncImpl*>(iter->value());
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult pairs_ = wait(ptr->getRange(ryw, KeyRangeRef(keyStart, keyEnd), &cache));
|
2020-06-12 03:22:19 +08:00
|
|
|
pairs = pairs_;
|
|
|
|
} else {
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult pairs_ = wait(iter->value()->getRange(ryw, KeyRangeRef(keyStart, keyEnd)));
|
2020-06-12 03:22:19 +08:00
|
|
|
pairs = pairs_;
|
|
|
|
}
|
2020-04-07 15:08:47 +08:00
|
|
|
result.arena().dependsOn(pairs.arena());
|
2020-03-04 10:35:24 +08:00
|
|
|
// limits handler
|
|
|
|
for (int i = pairs.size() - 1; i >= 0; --i) {
|
2020-07-31 09:58:09 +08:00
|
|
|
ASSERT(iter->range().contains(pairs[i].key));
|
2020-04-09 03:43:25 +08:00
|
|
|
result.push_back(result.arena(), pairs[i]);
|
2020-04-09 04:38:12 +08:00
|
|
|
// Note : behavior here is even the last k-v pair makes total bytes larger than specified, it's still
|
|
|
|
// returned. In other words, the total size of the returned value (less the last entry) will be less
|
|
|
|
// than byteLimit
|
2020-04-09 03:43:25 +08:00
|
|
|
limits.decrement(pairs[i]);
|
2020-03-31 14:27:09 +08:00
|
|
|
if (limits.isReached()) {
|
|
|
|
result.more = true;
|
|
|
|
result.readToBegin = false;
|
2020-06-18 01:33:52 +08:00
|
|
|
return result;
|
2020-03-31 14:27:09 +08:00
|
|
|
};
|
2020-03-04 10:35:24 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (iter = ranges.begin(); iter != ranges.end(); ++iter) {
|
2021-03-11 02:06:03 +08:00
|
|
|
if (iter->value() == nullptr)
|
|
|
|
continue;
|
2020-03-04 10:35:24 +08:00
|
|
|
KeyRangeRef kr = iter->range();
|
|
|
|
KeyRef keyStart = kr.contains(begin.getKey()) ? begin.getKey() : kr.begin;
|
|
|
|
KeyRef keyEnd = kr.contains(end.getKey()) ? end.getKey() : kr.end;
|
2020-06-12 03:22:19 +08:00
|
|
|
if (iter->value()->isAsync() && cache.present()) {
|
|
|
|
const SpecialKeyRangeAsyncImpl* ptr = dynamic_cast<const SpecialKeyRangeAsyncImpl*>(iter->value());
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult pairs_ = wait(ptr->getRange(ryw, KeyRangeRef(keyStart, keyEnd), &cache));
|
2020-06-12 03:22:19 +08:00
|
|
|
pairs = pairs_;
|
|
|
|
} else {
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult pairs_ = wait(iter->value()->getRange(ryw, KeyRangeRef(keyStart, keyEnd)));
|
2020-06-12 03:22:19 +08:00
|
|
|
pairs = pairs_;
|
|
|
|
}
|
2020-04-07 15:08:47 +08:00
|
|
|
result.arena().dependsOn(pairs.arena());
|
2020-03-04 10:35:24 +08:00
|
|
|
// limits handler
|
2020-03-31 14:27:09 +08:00
|
|
|
for (int i = 0; i < pairs.size(); ++i) {
|
2020-07-31 09:58:09 +08:00
|
|
|
ASSERT(iter->range().contains(pairs[i].key));
|
2020-04-09 03:43:25 +08:00
|
|
|
result.push_back(result.arena(), pairs[i]);
|
2020-04-09 04:38:12 +08:00
|
|
|
// Note : behavior here is even the last k-v pair makes total bytes larger than specified, it's still
|
|
|
|
// returned. In other words, the total size of the returned value (less the last entry) will be less
|
|
|
|
// than byteLimit
|
2020-04-09 03:43:25 +08:00
|
|
|
limits.decrement(pairs[i]);
|
2020-03-31 14:27:09 +08:00
|
|
|
if (limits.isReached()) {
|
|
|
|
result.more = true;
|
|
|
|
result.readThroughEnd = false;
|
2020-06-18 01:33:52 +08:00
|
|
|
return result;
|
2020-03-31 14:27:09 +08:00
|
|
|
};
|
2020-03-04 10:35:24 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-06-18 01:33:52 +08:00
|
|
|
return result;
|
2020-03-04 10:35:24 +08:00
|
|
|
}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> SpecialKeySpace::getRange(ReadYourWritesTransaction* ryw,
|
|
|
|
KeySelector begin,
|
|
|
|
KeySelector end,
|
|
|
|
GetRangeLimits limits,
|
|
|
|
bool reverse) {
|
2020-03-04 10:35:24 +08:00
|
|
|
// validate limits here
|
2021-03-11 02:06:03 +08:00
|
|
|
if (!limits.isValid())
|
|
|
|
return range_limits_invalid();
|
2020-03-04 10:35:24 +08:00
|
|
|
if (limits.isReached()) {
|
|
|
|
TEST(true); // read limit 0
|
2021-05-04 04:14:16 +08:00
|
|
|
return RangeResult();
|
2020-03-04 10:35:24 +08:00
|
|
|
}
|
2020-03-31 16:44:02 +08:00
|
|
|
// make sure orEqual == false
|
|
|
|
begin.removeOrEqual(begin.arena());
|
|
|
|
end.removeOrEqual(end.arena());
|
2020-04-07 13:09:17 +08:00
|
|
|
|
2020-05-15 17:04:15 +08:00
|
|
|
if (begin.offset >= end.offset && begin.getKey() >= end.getKey()) {
|
2020-05-15 14:49:57 +08:00
|
|
|
TEST(true); // range inverted
|
2021-05-04 04:14:16 +08:00
|
|
|
return RangeResult();
|
2020-05-15 14:49:57 +08:00
|
|
|
}
|
2020-05-15 08:30:48 +08:00
|
|
|
|
2020-06-18 02:13:55 +08:00
|
|
|
return checkRYWValid(this, ryw, begin, end, limits, reverse);
|
2020-03-04 10:35:24 +08:00
|
|
|
}
|
|
|
|
|
2021-03-11 02:06:03 +08:00
|
|
|
ACTOR Future<Optional<Value>> SpecialKeySpace::getActor(SpecialKeySpace* sks,
|
|
|
|
ReadYourWritesTransaction* ryw,
|
2020-04-09 04:38:12 +08:00
|
|
|
KeyRef key) {
|
2020-03-04 10:35:24 +08:00
|
|
|
// use getRange to workaround this
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult result = wait(sks->getRange(ryw,
|
|
|
|
KeySelector(firstGreaterOrEqual(key)),
|
|
|
|
KeySelector(firstGreaterOrEqual(keyAfter(key))),
|
|
|
|
GetRangeLimits(CLIENT_KNOBS->TOO_MANY),
|
|
|
|
false));
|
2020-03-04 10:35:24 +08:00
|
|
|
ASSERT(result.size() <= 1);
|
|
|
|
if (result.size()) {
|
|
|
|
return Optional<Value>(result[0].value);
|
|
|
|
} else {
|
|
|
|
return Optional<Value>();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-21 04:55:07 +08:00
|
|
|
Future<Optional<Value>> SpecialKeySpace::get(ReadYourWritesTransaction* ryw, const Key& key) {
|
2020-04-09 04:38:12 +08:00
|
|
|
return getActor(this, ryw, key);
|
2020-03-04 10:35:24 +08:00
|
|
|
}
|
|
|
|
|
2020-07-07 05:02:22 +08:00
|
|
|
void SpecialKeySpace::set(ReadYourWritesTransaction* ryw, const KeyRef& key, const ValueRef& value) {
|
2021-03-11 02:06:03 +08:00
|
|
|
if (!ryw->specialKeySpaceChangeConfiguration())
|
|
|
|
throw special_keys_write_disabled();
|
2020-07-07 05:02:22 +08:00
|
|
|
auto impl = writeImpls[key];
|
2020-07-18 03:36:50 +08:00
|
|
|
if (impl == nullptr) {
|
|
|
|
TraceEvent(SevDebug, "SpecialKeySpaceNoWriteModuleFound")
|
2020-07-18 06:16:28 +08:00
|
|
|
.detail("Key", key.toString())
|
|
|
|
.detail("Value", value.toString());
|
2020-07-18 03:36:50 +08:00
|
|
|
throw special_keys_no_write_module_found();
|
|
|
|
}
|
2020-07-07 05:02:22 +08:00
|
|
|
return impl->set(ryw, key, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SpecialKeySpace::clear(ReadYourWritesTransaction* ryw, const KeyRangeRef& range) {
|
2021-03-11 02:06:03 +08:00
|
|
|
if (!ryw->specialKeySpaceChangeConfiguration())
|
|
|
|
throw special_keys_write_disabled();
|
|
|
|
if (range.empty())
|
|
|
|
return;
|
2020-07-07 05:02:22 +08:00
|
|
|
auto begin = writeImpls[range.begin];
|
2020-07-15 02:56:40 +08:00
|
|
|
auto end = writeImpls.rangeContainingKeyBefore(range.end)->value();
|
|
|
|
if (begin != end) {
|
|
|
|
TraceEvent(SevDebug, "SpecialKeySpaceCrossModuleClear").detail("Range", range.toString());
|
2020-07-07 05:02:22 +08:00
|
|
|
throw special_keys_cross_module_clear(); // ban cross module clear
|
2020-07-16 07:15:43 +08:00
|
|
|
} else if (begin == nullptr) {
|
2020-07-15 02:56:40 +08:00
|
|
|
TraceEvent(SevDebug, "SpecialKeySpaceNoWriteModuleFound").detail("Range", range.toString());
|
2020-07-07 05:02:22 +08:00
|
|
|
throw special_keys_no_write_module_found();
|
2020-07-15 02:56:40 +08:00
|
|
|
}
|
2020-07-07 05:02:22 +08:00
|
|
|
return begin->clear(ryw, range);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SpecialKeySpace::clear(ReadYourWritesTransaction* ryw, const KeyRef& key) {
|
2021-03-11 02:06:03 +08:00
|
|
|
if (!ryw->specialKeySpaceChangeConfiguration())
|
|
|
|
throw special_keys_write_disabled();
|
2020-07-07 05:02:22 +08:00
|
|
|
auto impl = writeImpls[key];
|
2021-03-11 02:06:03 +08:00
|
|
|
if (impl == nullptr)
|
|
|
|
throw special_keys_no_write_module_found();
|
2020-07-07 05:02:22 +08:00
|
|
|
return impl->clear(ryw, key);
|
|
|
|
}
|
|
|
|
|
2020-10-23 09:25:51 +08:00
|
|
|
bool validateSnakeCaseNaming(const KeyRef& k) {
|
|
|
|
KeyRef key(k);
|
|
|
|
// Remove prefix \xff\xff
|
|
|
|
ASSERT(key.startsWith(specialKeys.begin));
|
|
|
|
key = key.removePrefix(specialKeys.begin);
|
|
|
|
// Suffix can be \xff\xff or \x00 in single key range
|
|
|
|
if (key.endsWith(specialKeys.begin))
|
|
|
|
key = key.removeSuffix(specialKeys.end);
|
|
|
|
else if (key.endsWith(LiteralStringRef("\x00")))
|
|
|
|
key = key.removeSuffix(LiteralStringRef("\x00"));
|
|
|
|
for (const char& c : key.toString()) {
|
|
|
|
// only small letters, numbers, '/', '_' is allowed
|
|
|
|
ASSERT((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '/' || c == '_');
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-03-11 02:06:03 +08:00
|
|
|
void SpecialKeySpace::registerKeyRange(SpecialKeySpace::MODULE module,
|
|
|
|
SpecialKeySpace::IMPLTYPE type,
|
|
|
|
const KeyRangeRef& kr,
|
|
|
|
SpecialKeyRangeReadImpl* impl) {
|
2020-07-07 05:02:22 +08:00
|
|
|
// module boundary check
|
2020-10-23 09:25:51 +08:00
|
|
|
if (module == SpecialKeySpace::MODULE::TESTONLY) {
|
2020-07-07 07:42:42 +08:00
|
|
|
ASSERT(normalKeys.contains(kr));
|
2020-10-23 09:27:58 +08:00
|
|
|
} else {
|
2020-07-07 05:02:22 +08:00
|
|
|
ASSERT(moduleToBoundary.at(module).contains(kr));
|
2020-10-23 09:25:51 +08:00
|
|
|
ASSERT(validateSnakeCaseNaming(kr.begin) &&
|
|
|
|
validateSnakeCaseNaming(kr.end)); // validate keys follow snake case naming style
|
|
|
|
}
|
2020-07-07 05:02:22 +08:00
|
|
|
// make sure the registered range is not overlapping with existing ones
|
|
|
|
// Note: kr.end should not be the same as another range's begin, although it should work even they are the same
|
|
|
|
for (auto iter = readImpls.rangeContaining(kr.begin); true; ++iter) {
|
|
|
|
ASSERT(iter->value() == nullptr);
|
|
|
|
if (iter == readImpls.rangeContaining(kr.end))
|
|
|
|
break; // Note: relax the condition that the end can be another range's start, if needed
|
|
|
|
}
|
|
|
|
readImpls.insert(kr, impl);
|
|
|
|
// if rw, it means the module can do both read and write
|
2020-07-28 03:29:03 +08:00
|
|
|
if (type == SpecialKeySpace::IMPLTYPE::READWRITE) {
|
2020-07-07 05:02:22 +08:00
|
|
|
// since write impls are always subset of read impls,
|
|
|
|
// no need to check overlapped registration
|
|
|
|
auto rwImpl = dynamic_cast<SpecialKeyRangeRWImpl*>(impl);
|
|
|
|
ASSERT(rwImpl);
|
|
|
|
writeImpls.insert(kr, rwImpl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-18 06:16:28 +08:00
|
|
|
Key SpecialKeySpace::decode(const KeyRef& key) {
|
|
|
|
auto impl = writeImpls[key];
|
|
|
|
ASSERT(impl != nullptr);
|
|
|
|
return impl->decode(key);
|
|
|
|
}
|
|
|
|
|
|
|
|
KeyRange SpecialKeySpace::decode(const KeyRangeRef& kr) {
|
|
|
|
// Only allow to decode key range in the same underlying impl range
|
|
|
|
auto begin = writeImpls.rangeContaining(kr.begin);
|
|
|
|
ASSERT(begin->value() != nullptr);
|
|
|
|
auto end = writeImpls.rangeContainingKeyBefore(kr.end);
|
|
|
|
ASSERT(begin == end);
|
|
|
|
return KeyRangeRef(begin->value()->decode(kr.begin), begin->value()->decode(kr.end));
|
|
|
|
}
|
|
|
|
|
2020-06-24 02:21:03 +08:00
|
|
|
ACTOR Future<Void> commitActor(SpecialKeySpace* sks, ReadYourWritesTransaction* ryw) {
|
2020-06-28 03:22:32 +08:00
|
|
|
state RangeMap<Key, std::pair<bool, Optional<Value>>, KeyRangeRef>::Ranges ranges =
|
|
|
|
ryw->getSpecialKeySpaceWriteMap().containedRanges(specialKeys);
|
2020-07-15 01:36:47 +08:00
|
|
|
state RangeMap<Key, std::pair<bool, Optional<Value>>, KeyRangeRef>::iterator iter = ranges.begin();
|
2021-05-04 08:22:34 +08:00
|
|
|
state std::vector<SpecialKeyRangeRWImpl*> writeModulePtrs;
|
2021-05-04 23:24:31 +08:00
|
|
|
std::unordered_set<SpecialKeyRangeRWImpl*> deduplicate;
|
2020-06-24 02:21:03 +08:00
|
|
|
while (iter != ranges.end()) {
|
|
|
|
std::pair<bool, Optional<Value>> entry = iter->value();
|
|
|
|
if (entry.first) {
|
2020-07-17 09:15:35 +08:00
|
|
|
auto modulePtr = sks->getRWImpls().rangeContaining(iter->begin())->value();
|
2021-05-04 23:24:31 +08:00
|
|
|
auto [_, inserted] = deduplicate.insert(modulePtr);
|
|
|
|
if (inserted) {
|
|
|
|
writeModulePtrs.push_back(modulePtr);
|
|
|
|
}
|
2020-06-24 02:21:03 +08:00
|
|
|
}
|
2020-07-07 02:02:48 +08:00
|
|
|
++iter;
|
2020-06-24 02:21:03 +08:00
|
|
|
}
|
2021-05-04 08:22:34 +08:00
|
|
|
state std::vector<SpecialKeyRangeRWImpl*>::const_iterator it;
|
2020-06-28 03:22:32 +08:00
|
|
|
for (it = writeModulePtrs.begin(); it != writeModulePtrs.end(); ++it) {
|
|
|
|
Optional<std::string> msg = wait((*it)->commit(ryw));
|
|
|
|
if (msg.present()) {
|
|
|
|
ryw->setSpecialKeySpaceErrorMsg(msg.get());
|
2020-07-17 09:15:35 +08:00
|
|
|
TraceEvent(SevDebug, "SpecialKeySpaceManagemetnAPIError")
|
|
|
|
.detail("Reason", msg.get())
|
|
|
|
.detail("Range", (*it)->getKeyRange().toString());
|
2020-07-31 09:58:09 +08:00
|
|
|
throw special_keys_api_failure();
|
2020-06-28 03:22:32 +08:00
|
|
|
}
|
|
|
|
}
|
2020-06-24 02:21:03 +08:00
|
|
|
return Void();
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<Void> SpecialKeySpace::commit(ReadYourWritesTransaction* ryw) {
|
|
|
|
return commitActor(this, ryw);
|
|
|
|
}
|
|
|
|
|
2020-09-09 02:08:48 +08:00
|
|
|
SKSCTestImpl::SKSCTestImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> SKSCTestImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2020-09-09 02:08:48 +08:00
|
|
|
ASSERT(range.contains(kr));
|
|
|
|
auto resultFuture = ryw->getRange(kr, CLIENT_KNOBS->TOO_MANY);
|
|
|
|
// all keys are written to RYW, since GRV is set, the read should happen locally
|
|
|
|
ASSERT(resultFuture.isReady());
|
|
|
|
auto result = resultFuture.getValue();
|
|
|
|
ASSERT(!result.more && result.size() < CLIENT_KNOBS->TOO_MANY);
|
|
|
|
auto kvs = resultFuture.getValue();
|
|
|
|
return rywGetRange(ryw, kr, kvs);
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<Optional<std::string>> SKSCTestImpl::commit(ReadYourWritesTransaction* ryw) {
|
|
|
|
ASSERT(false);
|
|
|
|
return Optional<std::string>();
|
|
|
|
}
|
|
|
|
|
2020-06-16 03:47:27 +08:00
|
|
|
ReadConflictRangeImpl::ReadConflictRangeImpl(KeyRangeRef kr) : SpecialKeyRangeReadImpl(kr) {}
|
2020-04-29 00:00:06 +08:00
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR static Future<RangeResult> getReadConflictRangeImpl(ReadYourWritesTransaction* ryw, KeyRange kr) {
|
2020-04-29 03:44:34 +08:00
|
|
|
wait(ryw->pendingReads());
|
2020-04-30 05:43:37 +08:00
|
|
|
return ryw->getReadConflictRangeIntersecting(kr);
|
2020-04-29 00:00:06 +08:00
|
|
|
}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> ReadConflictRangeImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2020-04-29 00:00:06 +08:00
|
|
|
return getReadConflictRangeImpl(ryw, kr);
|
|
|
|
}
|
|
|
|
|
2020-06-16 03:47:27 +08:00
|
|
|
WriteConflictRangeImpl::WriteConflictRangeImpl(KeyRangeRef kr) : SpecialKeyRangeReadImpl(kr) {}
|
2020-04-29 01:34:10 +08:00
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> WriteConflictRangeImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2020-04-30 05:43:37 +08:00
|
|
|
return ryw->getWriteConflictRangeIntersecting(kr);
|
2020-04-29 01:34:10 +08:00
|
|
|
}
|
|
|
|
|
2020-06-16 03:47:27 +08:00
|
|
|
ConflictingKeysImpl::ConflictingKeysImpl(KeyRangeRef kr) : SpecialKeyRangeReadImpl(kr) {}
|
2020-04-07 04:23:41 +08:00
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> ConflictingKeysImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
|
|
|
RangeResult result;
|
2020-04-07 04:38:18 +08:00
|
|
|
if (ryw->getTransactionInfo().conflictingKeys) {
|
|
|
|
auto krMapPtr = ryw->getTransactionInfo().conflictingKeys.get();
|
|
|
|
auto beginIter = krMapPtr->rangeContaining(kr.begin);
|
2021-03-11 02:06:03 +08:00
|
|
|
if (beginIter->begin() != kr.begin)
|
|
|
|
++beginIter;
|
2020-04-07 04:38:18 +08:00
|
|
|
auto endIter = krMapPtr->rangeContaining(kr.end);
|
2020-04-07 04:23:41 +08:00
|
|
|
for (auto it = beginIter; it != endIter; ++it) {
|
2020-07-25 07:31:16 +08:00
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(it->begin(), it->value()));
|
2020-04-07 04:23:41 +08:00
|
|
|
}
|
|
|
|
if (endIter->begin() != kr.end)
|
2020-07-25 07:31:16 +08:00
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(endIter->begin(), endIter->value()));
|
2020-04-07 04:23:41 +08:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR Future<RangeResult> ddMetricsGetRangeActor(ReadYourWritesTransaction* ryw, KeyRangeRef kr) {
|
2020-10-20 09:16:09 +08:00
|
|
|
loop {
|
|
|
|
try {
|
|
|
|
auto keys = kr.removePrefix(ddStatsRange.begin);
|
|
|
|
Standalone<VectorRef<DDMetricsRef>> resultWithoutPrefix = wait(
|
|
|
|
waitDataDistributionMetricsList(ryw->getDatabase(), keys, CLIENT_KNOBS->STORAGE_METRICS_SHARD_LIMIT));
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult result;
|
2020-10-20 09:16:09 +08:00
|
|
|
for (const auto& ddMetricsRef : resultWithoutPrefix) {
|
|
|
|
// each begin key is the previous end key, thus we only encode the begin key in the result
|
|
|
|
KeyRef beginKey = ddMetricsRef.beginKey.withPrefix(ddStatsRange.begin, result.arena());
|
|
|
|
// Use json string encoded in utf-8 to encode the values, easy for adding more fields in the future
|
|
|
|
json_spirit::mObject statsObj;
|
|
|
|
statsObj["shard_bytes"] = ddMetricsRef.shardBytes;
|
|
|
|
std::string statsString =
|
|
|
|
json_spirit::write_string(json_spirit::mValue(statsObj), json_spirit::Output_options::raw_utf8);
|
|
|
|
ValueRef bytes(result.arena(), statsString);
|
|
|
|
result.push_back(result.arena(), KeyValueRef(beginKey, bytes));
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
} catch (Error& e) {
|
2020-10-22 07:58:23 +08:00
|
|
|
state Error err(e);
|
2020-11-20 05:17:38 +08:00
|
|
|
if (e.code() == error_code_dd_not_found) {
|
2020-10-20 09:16:09 +08:00
|
|
|
TraceEvent(SevWarnAlways, "DataDistributorNotPresent")
|
|
|
|
.detail("Operation", "DDMetricsReqestThroughSpecialKeys");
|
2020-10-22 07:58:23 +08:00
|
|
|
wait(delayJittered(FLOW_KNOBS->PREVENT_FAST_SPIN_DELAY));
|
2020-10-20 09:16:09 +08:00
|
|
|
continue;
|
|
|
|
}
|
2020-10-22 07:58:23 +08:00
|
|
|
throw err;
|
2020-05-19 01:38:23 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-12 03:22:19 +08:00
|
|
|
DDStatsRangeImpl::DDStatsRangeImpl(KeyRangeRef kr) : SpecialKeyRangeAsyncImpl(kr) {}
|
2020-05-19 01:38:23 +08:00
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> DDStatsRangeImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2020-06-12 03:22:19 +08:00
|
|
|
return ddMetricsGetRangeActor(ryw, kr);
|
2020-05-19 01:38:23 +08:00
|
|
|
}
|
2020-06-15 13:29:44 +08:00
|
|
|
|
2020-07-18 03:32:42 +08:00
|
|
|
Key SpecialKeySpace::getManagementApiCommandOptionSpecialKey(const std::string& command, const std::string& option) {
|
2020-07-18 06:16:28 +08:00
|
|
|
Key prefix = LiteralStringRef("options/").withPrefix(moduleToBoundary[MODULE::MANAGEMENT].begin);
|
2020-07-18 03:32:42 +08:00
|
|
|
auto pair = command + "/" + option;
|
|
|
|
ASSERT(options.find(pair) != options.end());
|
|
|
|
return prefix.withSuffix(pair);
|
|
|
|
}
|
2020-07-17 09:15:35 +08:00
|
|
|
|
|
|
|
ManagementCommandsOptionsImpl::ManagementCommandsOptionsImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> ManagementCommandsOptionsImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
|
|
|
RangeResult result;
|
2020-07-17 09:15:35 +08:00
|
|
|
// Since we only have limit number of options, a brute force loop here is enough
|
2020-07-29 02:39:29 +08:00
|
|
|
for (const auto& option : SpecialKeySpace::getManagementApiOptionsSet()) {
|
2020-07-17 09:15:35 +08:00
|
|
|
auto key = getKeyRange().begin.withSuffix(option);
|
|
|
|
// ignore all invalid keys
|
|
|
|
auto r = ryw->getSpecialKeySpaceWriteMap()[key];
|
2020-08-06 04:18:39 +08:00
|
|
|
if (kr.contains(key) && r.first && r.second.present()) {
|
2020-07-17 09:15:35 +08:00
|
|
|
result.push_back(result.arena(), KeyValueRef(key, ValueRef()));
|
2020-08-06 04:18:39 +08:00
|
|
|
result.arena().dependsOn(key.arena());
|
|
|
|
}
|
2020-07-17 09:15:35 +08:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ManagementCommandsOptionsImpl::set(ReadYourWritesTransaction* ryw, const KeyRef& key, const ValueRef& value) {
|
|
|
|
std::string option = key.removePrefix(getKeyRange().begin).toString();
|
|
|
|
// ignore all invalid keys
|
2020-07-29 02:39:29 +08:00
|
|
|
if (SpecialKeySpace::getManagementApiOptionsSet().find(option) !=
|
|
|
|
SpecialKeySpace::getManagementApiOptionsSet().end()) {
|
2020-07-18 03:32:42 +08:00
|
|
|
TraceEvent(SevDebug, "ManagementApiOption").detail("Option", option).detail("Key", key);
|
2020-07-17 09:15:35 +08:00
|
|
|
ryw->getSpecialKeySpaceWriteMap().insert(key, std::make_pair(true, Optional<Value>(value)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ManagementCommandsOptionsImpl::clear(ReadYourWritesTransaction* ryw, const KeyRangeRef& range) {
|
2020-07-29 04:32:31 +08:00
|
|
|
ryw->getSpecialKeySpaceWriteMap().rawErase(range);
|
2020-07-17 09:15:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void ManagementCommandsOptionsImpl::clear(ReadYourWritesTransaction* ryw, const KeyRef& key) {
|
|
|
|
std::string option = key.removePrefix(getKeyRange().begin).toString();
|
|
|
|
// ignore all invalid keys
|
2020-07-29 02:39:29 +08:00
|
|
|
if (SpecialKeySpace::getManagementApiOptionsSet().find(option) !=
|
|
|
|
SpecialKeySpace::getManagementApiOptionsSet().end()) {
|
2020-07-17 09:15:35 +08:00
|
|
|
ryw->getSpecialKeySpaceWriteMap().rawErase(singleKeyRange(key));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<Optional<std::string>> ManagementCommandsOptionsImpl::commit(ReadYourWritesTransaction* ryw) {
|
|
|
|
// Nothing to do, keys should be used by other impls' commit callback
|
|
|
|
return Optional<std::string>();
|
|
|
|
}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult rywGetRange(ReadYourWritesTransaction* ryw, const KeyRangeRef& kr, const RangeResult& res) {
|
2020-09-05 05:54:32 +08:00
|
|
|
// "res" is the read result regardless of your writes, if ryw disabled, return immediately
|
2021-03-11 02:06:03 +08:00
|
|
|
if (ryw->readYourWritesDisabled())
|
|
|
|
return res;
|
2020-09-05 05:54:32 +08:00
|
|
|
// If ryw enabled, we update it with writes from the transaction
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult result;
|
2020-09-05 05:54:32 +08:00
|
|
|
RangeMap<Key, std::pair<bool, Optional<Value>>, KeyRangeRef>::Ranges ranges =
|
|
|
|
ryw->getSpecialKeySpaceWriteMap().containedRanges(kr);
|
|
|
|
RangeMap<Key, std::pair<bool, Optional<Value>>, KeyRangeRef>::iterator iter = ranges.begin();
|
|
|
|
auto iter2 = res.begin();
|
|
|
|
result.arena().dependsOn(res.arena());
|
|
|
|
while (iter != ranges.end() || iter2 != res.end()) {
|
|
|
|
if (iter == ranges.end()) {
|
|
|
|
result.push_back(result.arena(), KeyValueRef(iter2->key, iter2->value));
|
|
|
|
++iter2;
|
|
|
|
} else if (iter2 == res.end()) {
|
|
|
|
// insert if it is a set entry
|
|
|
|
std::pair<bool, Optional<Value>> entry = iter->value();
|
|
|
|
if (entry.first && entry.second.present()) {
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(iter->begin(), entry.second.get()));
|
2020-06-24 02:21:03 +08:00
|
|
|
}
|
2020-09-05 05:54:32 +08:00
|
|
|
++iter;
|
|
|
|
} else if (iter->range().contains(iter2->key)) {
|
2020-06-28 03:22:32 +08:00
|
|
|
std::pair<bool, Optional<Value>> entry = iter->value();
|
2020-09-05 05:54:32 +08:00
|
|
|
// if this is a valid range either for set or clear, move iter2 outside the range
|
2020-06-24 02:21:03 +08:00
|
|
|
if (entry.first) {
|
2020-09-05 05:54:32 +08:00
|
|
|
// insert if this is a set entry
|
|
|
|
if (entry.second.present())
|
2020-07-31 17:18:49 +08:00
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(iter->begin(), entry.second.get()));
|
2020-09-05 05:54:32 +08:00
|
|
|
// move iter2 outside the range
|
2021-03-11 02:06:03 +08:00
|
|
|
while (iter2 != res.end() && iter->range().contains(iter2->key))
|
|
|
|
++iter2;
|
2020-09-05 05:54:32 +08:00
|
|
|
}
|
|
|
|
++iter;
|
|
|
|
} else if (iter->begin() > iter2->key) {
|
|
|
|
result.push_back(result.arena(), KeyValueRef(iter2->key, iter2->value));
|
|
|
|
++iter2;
|
|
|
|
} else if (iter->end() <= iter2->key) {
|
|
|
|
// insert if it is a set entry
|
|
|
|
std::pair<bool, Optional<Value>> entry = iter->value();
|
|
|
|
if (entry.first && entry.second.present()) {
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(iter->begin(), entry.second.get()));
|
2020-06-24 02:21:03 +08:00
|
|
|
}
|
|
|
|
++iter;
|
|
|
|
}
|
|
|
|
}
|
2020-06-15 13:29:44 +08:00
|
|
|
return result;
|
|
|
|
}
|
2020-06-15 13:39:20 +08:00
|
|
|
|
2020-09-05 05:54:32 +08:00
|
|
|
// read from those readwrite modules in which special keys have one-to-one mapping with real persisted keys
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR Future<RangeResult> rwModuleWithMappingGetRangeActor(ReadYourWritesTransaction* ryw,
|
|
|
|
const SpecialKeyRangeRWImpl* impl,
|
|
|
|
KeyRangeRef kr) {
|
|
|
|
RangeResult resultWithoutPrefix =
|
2020-09-05 05:54:32 +08:00
|
|
|
wait(ryw->getTransaction().getRange(ryw->getDatabase()->specialKeySpace->decode(kr), CLIENT_KNOBS->TOO_MANY));
|
|
|
|
ASSERT(!resultWithoutPrefix.more && resultWithoutPrefix.size() < CLIENT_KNOBS->TOO_MANY);
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult result;
|
2020-09-05 05:54:32 +08:00
|
|
|
for (const KeyValueRef& kv : resultWithoutPrefix)
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(impl->encode(kv.key), kv.value));
|
|
|
|
return rywGetRange(ryw, kr, result);
|
|
|
|
}
|
|
|
|
|
2020-06-24 02:21:03 +08:00
|
|
|
ExcludeServersRangeImpl::ExcludeServersRangeImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
|
2020-06-15 13:39:20 +08:00
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> ExcludeServersRangeImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2020-09-05 05:54:32 +08:00
|
|
|
return rwModuleWithMappingGetRangeActor(ryw, this, kr);
|
2020-06-24 02:21:03 +08:00
|
|
|
}
|
|
|
|
|
2020-09-05 06:21:47 +08:00
|
|
|
void ExcludeServersRangeImpl::set(ReadYourWritesTransaction* ryw, const KeyRef& key, const ValueRef& value) {
|
|
|
|
// ignore value
|
|
|
|
ryw->getSpecialKeySpaceWriteMap().insert(key, std::make_pair(true, Optional<Value>(ValueRef())));
|
|
|
|
}
|
|
|
|
|
2020-07-31 17:18:49 +08:00
|
|
|
Key ExcludeServersRangeImpl::decode(const KeyRef& key) const {
|
|
|
|
return key.removePrefix(SpecialKeySpace::getModuleRange(SpecialKeySpace::MODULE::MANAGEMENT).begin)
|
|
|
|
.withPrefix(LiteralStringRef("\xff/conf/"));
|
|
|
|
}
|
|
|
|
|
|
|
|
Key ExcludeServersRangeImpl::encode(const KeyRef& key) const {
|
|
|
|
return key.removePrefix(LiteralStringRef("\xff/conf/"))
|
|
|
|
.withPrefix(SpecialKeySpace::getModuleRange(SpecialKeySpace::MODULE::MANAGEMENT).begin);
|
|
|
|
}
|
|
|
|
|
2021-03-11 02:06:03 +08:00
|
|
|
bool parseNetWorkAddrFromKeys(ReadYourWritesTransaction* ryw,
|
|
|
|
bool failed,
|
|
|
|
std::vector<AddressExclusion>& addresses,
|
|
|
|
std::set<AddressExclusion>& exclusions,
|
|
|
|
Optional<std::string>& msg) {
|
2020-07-31 17:18:49 +08:00
|
|
|
KeyRangeRef range = failed ? SpecialKeySpace::getManamentApiCommandRange("failed")
|
|
|
|
: SpecialKeySpace::getManamentApiCommandRange("exclude");
|
2020-07-07 02:02:48 +08:00
|
|
|
auto ranges = ryw->getSpecialKeySpaceWriteMap().containedRanges(range);
|
|
|
|
auto iter = ranges.begin();
|
|
|
|
while (iter != ranges.end()) {
|
|
|
|
auto entry = iter->value();
|
|
|
|
// only check for exclude(set) operation, include(clear) are not checked
|
2020-08-21 05:41:17 +08:00
|
|
|
TraceEvent(SevDebug, "ParseNetworkAddress")
|
2020-07-07 02:02:48 +08:00
|
|
|
.detail("Valid", entry.first)
|
|
|
|
.detail("Set", entry.second.present())
|
|
|
|
.detail("Key", iter->begin().toString());
|
|
|
|
if (entry.first && entry.second.present()) {
|
|
|
|
Key address = iter->begin().removePrefix(range.begin);
|
|
|
|
auto a = AddressExclusion::parse(address);
|
|
|
|
if (!a.isValid()) {
|
|
|
|
std::string error = "ERROR: \'" + address.toString() + "\' is not a valid network endpoint address\n";
|
|
|
|
if (address.toString().find(":tls") != std::string::npos)
|
|
|
|
error += " Do not include the `:tls' suffix when naming a process\n";
|
2020-08-01 04:31:36 +08:00
|
|
|
msg = ManagementAPIError::toJsonString(
|
|
|
|
false, entry.second.present() ? (failed ? "exclude failed" : "exclude") : "include", error);
|
2020-07-07 02:02:48 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
addresses.push_back(a);
|
|
|
|
exclusions.insert(a);
|
|
|
|
}
|
|
|
|
++iter;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-03-11 02:06:03 +08:00
|
|
|
ACTOR Future<bool> checkExclusion(Database db,
|
|
|
|
std::vector<AddressExclusion>* addresses,
|
|
|
|
std::set<AddressExclusion>* exclusions,
|
|
|
|
bool markFailed,
|
|
|
|
Optional<std::string>* msg) {
|
2020-07-07 02:02:48 +08:00
|
|
|
|
|
|
|
if (markFailed) {
|
|
|
|
state bool safe;
|
|
|
|
try {
|
|
|
|
bool _safe = wait(checkSafeExclusions(db, *addresses));
|
|
|
|
safe = _safe;
|
|
|
|
} catch (Error& e) {
|
2021-03-11 02:06:03 +08:00
|
|
|
if (e.code() == error_code_actor_cancelled)
|
|
|
|
throw;
|
2020-07-07 02:02:48 +08:00
|
|
|
TraceEvent("CheckSafeExclusionsError").error(e);
|
|
|
|
safe = false;
|
|
|
|
}
|
|
|
|
if (!safe) {
|
2020-07-16 07:15:43 +08:00
|
|
|
std::string temp = "ERROR: It is unsafe to exclude the specified servers at this time.\n"
|
2020-07-17 09:15:35 +08:00
|
|
|
"Please check that this exclusion does not bring down an entire storage team.\n"
|
|
|
|
"Please also ensure that the exclusion will keep a majority of coordinators alive.\n"
|
2020-07-31 13:38:35 +08:00
|
|
|
"You may add more storage processes or coordinators to make the operation safe.\n"
|
2020-08-01 04:31:36 +08:00
|
|
|
"Call set(\"0xff0xff/management/failed/<ADDRESS...>\", ...) to exclude without "
|
2020-07-31 13:38:35 +08:00
|
|
|
"performing safety checks.\n";
|
2020-07-16 07:15:43 +08:00
|
|
|
*msg = ManagementAPIError::toJsonString(false, markFailed ? "exclude failed" : "exclude", temp);
|
2020-07-07 02:02:48 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
StatusObject status = wait(StatusClient::statusFetcher(db));
|
|
|
|
state std::string errorString =
|
|
|
|
"ERROR: Could not calculate the impact of this exclude on the total free space in the cluster.\n"
|
2020-07-31 13:38:35 +08:00
|
|
|
"Please try the exclude again in 30 seconds.\n"
|
2020-08-01 04:31:36 +08:00
|
|
|
"Call set(\"0xff0xff/management/options/exclude/force\", ...) first to exclude without checking free "
|
2020-07-31 13:38:35 +08:00
|
|
|
"space.\n";
|
2020-07-07 02:02:48 +08:00
|
|
|
|
|
|
|
StatusObjectReader statusObj(status);
|
|
|
|
|
|
|
|
StatusObjectReader statusObjCluster;
|
|
|
|
if (!statusObj.get("cluster", statusObjCluster)) {
|
2020-07-16 07:15:43 +08:00
|
|
|
*msg = ManagementAPIError::toJsonString(false, markFailed ? "exclude failed" : "exclude", errorString);
|
2020-07-07 02:02:48 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
StatusObjectReader processesMap;
|
|
|
|
if (!statusObjCluster.get("processes", processesMap)) {
|
2020-07-16 07:15:43 +08:00
|
|
|
*msg = ManagementAPIError::toJsonString(false, markFailed ? "exclude failed" : "exclude", errorString);
|
2020-07-07 02:02:48 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
state int ssTotalCount = 0;
|
|
|
|
state int ssExcludedCount = 0;
|
|
|
|
state double worstFreeSpaceRatio = 1.0;
|
|
|
|
try {
|
|
|
|
for (auto proc : processesMap.obj()) {
|
|
|
|
bool storageServer = false;
|
|
|
|
StatusArray rolesArray = proc.second.get_obj()["roles"].get_array();
|
|
|
|
for (StatusObjectReader role : rolesArray) {
|
|
|
|
if (role["role"].get_str() == "storage") {
|
|
|
|
storageServer = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Skip non-storage servers in free space calculation
|
2021-03-11 02:06:03 +08:00
|
|
|
if (!storageServer)
|
|
|
|
continue;
|
2020-07-07 02:02:48 +08:00
|
|
|
|
|
|
|
StatusObjectReader process(proc.second);
|
|
|
|
std::string addrStr;
|
|
|
|
if (!process.get("address", addrStr)) {
|
2020-07-16 07:15:43 +08:00
|
|
|
*msg = ManagementAPIError::toJsonString(false, markFailed ? "exclude failed" : "exclude", errorString);
|
2020-07-07 02:02:48 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
NetworkAddress addr = NetworkAddress::parse(addrStr);
|
|
|
|
bool excluded =
|
|
|
|
(process.has("excluded") && process.last().get_bool()) || addressExcluded(*exclusions, addr);
|
|
|
|
ssTotalCount++;
|
2021-03-11 02:06:03 +08:00
|
|
|
if (excluded)
|
|
|
|
ssExcludedCount++;
|
2020-07-07 02:02:48 +08:00
|
|
|
|
|
|
|
if (!excluded) {
|
|
|
|
StatusObjectReader disk;
|
|
|
|
if (!process.get("disk", disk)) {
|
2020-07-17 09:15:35 +08:00
|
|
|
*msg =
|
|
|
|
ManagementAPIError::toJsonString(false, markFailed ? "exclude failed" : "exclude", errorString);
|
2020-07-07 02:02:48 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
int64_t total_bytes;
|
|
|
|
if (!disk.get("total_bytes", total_bytes)) {
|
2020-07-17 09:15:35 +08:00
|
|
|
*msg =
|
|
|
|
ManagementAPIError::toJsonString(false, markFailed ? "exclude failed" : "exclude", errorString);
|
2020-07-07 02:02:48 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
int64_t free_bytes;
|
|
|
|
if (!disk.get("free_bytes", free_bytes)) {
|
2020-07-17 09:15:35 +08:00
|
|
|
*msg =
|
|
|
|
ManagementAPIError::toJsonString(false, markFailed ? "exclude failed" : "exclude", errorString);
|
2020-07-07 02:02:48 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
worstFreeSpaceRatio = std::min(worstFreeSpaceRatio, double(free_bytes) / total_bytes);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} catch (...) // std::exception
|
|
|
|
{
|
2020-07-16 07:15:43 +08:00
|
|
|
*msg = ManagementAPIError::toJsonString(false, markFailed ? "exclude failed" : "exclude", errorString);
|
2020-07-07 02:02:48 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ssExcludedCount == ssTotalCount ||
|
|
|
|
(1 - worstFreeSpaceRatio) * ssTotalCount / (ssTotalCount - ssExcludedCount) > 0.9) {
|
2020-07-31 13:38:35 +08:00
|
|
|
std::string temp = "ERROR: This exclude may cause the total free space in the cluster to drop below 10%.\n"
|
2020-08-01 04:31:36 +08:00
|
|
|
"Call set(\"0xff0xff/management/options/exclude/force\", ...) first to exclude without "
|
2020-07-31 13:38:35 +08:00
|
|
|
"checking free space.\n";
|
2020-07-16 07:15:43 +08:00
|
|
|
*msg = ManagementAPIError::toJsonString(false, markFailed ? "exclude failed" : "exclude", temp);
|
2020-07-07 02:02:48 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void includeServers(ReadYourWritesTransaction* ryw) {
|
2020-07-16 07:15:43 +08:00
|
|
|
ryw->setOption(FDBTransactionOptions::PRIORITY_SYSTEM_IMMEDIATE);
|
|
|
|
ryw->setOption(FDBTransactionOptions::LOCK_AWARE);
|
|
|
|
ryw->setOption(FDBTransactionOptions::USE_PROVISIONAL_PROXIES);
|
|
|
|
// includeServers might be used in an emergency transaction, so make sure it is retry-self-conflicting and
|
|
|
|
// CAUSAL_WRITE_RISKY
|
|
|
|
ryw->setOption(FDBTransactionOptions::CAUSAL_WRITE_RISKY);
|
2020-07-07 02:02:48 +08:00
|
|
|
std::string versionKey = deterministicRandom()->randomUniqueID().toString();
|
2020-07-15 01:31:19 +08:00
|
|
|
// for exluded servers
|
2020-07-31 17:18:49 +08:00
|
|
|
auto ranges =
|
|
|
|
ryw->getSpecialKeySpaceWriteMap().containedRanges(SpecialKeySpace::getManamentApiCommandRange("exclude"));
|
2020-07-07 02:02:48 +08:00
|
|
|
auto iter = ranges.begin();
|
|
|
|
Transaction& tr = ryw->getTransaction();
|
|
|
|
while (iter != ranges.end()) {
|
|
|
|
auto entry = iter->value();
|
|
|
|
if (entry.first && !entry.second.present()) {
|
|
|
|
tr.addReadConflictRange(singleKeyRange(excludedServersVersionKey));
|
|
|
|
tr.set(excludedServersVersionKey, versionKey);
|
2020-07-18 06:16:28 +08:00
|
|
|
tr.clear(ryw->getDatabase()->specialKeySpace->decode(iter->range()));
|
2020-07-07 02:02:48 +08:00
|
|
|
}
|
|
|
|
++iter;
|
|
|
|
}
|
2020-07-15 01:31:19 +08:00
|
|
|
// for failed servers
|
2020-07-31 17:18:49 +08:00
|
|
|
ranges = ryw->getSpecialKeySpaceWriteMap().containedRanges(SpecialKeySpace::getManamentApiCommandRange("failed"));
|
2020-07-15 01:31:19 +08:00
|
|
|
iter = ranges.begin();
|
|
|
|
while (iter != ranges.end()) {
|
|
|
|
auto entry = iter->value();
|
|
|
|
if (entry.first && !entry.second.present()) {
|
|
|
|
tr.addReadConflictRange(singleKeyRange(failedServersVersionKey));
|
|
|
|
tr.set(failedServersVersionKey, versionKey);
|
2020-07-18 06:16:28 +08:00
|
|
|
tr.clear(ryw->getDatabase()->specialKeySpace->decode(iter->range()));
|
2020-07-15 01:31:19 +08:00
|
|
|
}
|
|
|
|
++iter;
|
|
|
|
}
|
2020-07-07 02:02:48 +08:00
|
|
|
}
|
|
|
|
|
2020-07-17 09:15:35 +08:00
|
|
|
ACTOR Future<Optional<std::string>> excludeCommitActor(ReadYourWritesTransaction* ryw, bool failed) {
|
2020-07-07 02:02:48 +08:00
|
|
|
// parse network addresses
|
|
|
|
state Optional<std::string> result;
|
|
|
|
state std::vector<AddressExclusion> addresses;
|
|
|
|
state std::set<AddressExclusion> exclusions;
|
2021-03-11 02:06:03 +08:00
|
|
|
if (!parseNetWorkAddrFromKeys(ryw, failed, addresses, exclusions, result))
|
|
|
|
return result;
|
2020-07-17 09:15:35 +08:00
|
|
|
// If force option is not set, we need to do safety check
|
2020-07-18 03:32:42 +08:00
|
|
|
auto force = ryw->getSpecialKeySpaceWriteMap()[SpecialKeySpace::getManagementApiCommandOptionSpecialKey(
|
2020-08-06 04:18:39 +08:00
|
|
|
failed ? "failed" : "excluded", "force")];
|
2020-07-17 09:15:35 +08:00
|
|
|
// only do safety check when we have servers to be excluded and the force option key is not set
|
|
|
|
if (addresses.size() && !(force.first && force.second.present())) {
|
|
|
|
bool safe = wait(checkExclusion(ryw->getDatabase(), &addresses, &exclusions, failed, &result));
|
2021-03-11 02:06:03 +08:00
|
|
|
if (!safe)
|
|
|
|
return result;
|
2020-07-17 09:15:35 +08:00
|
|
|
}
|
|
|
|
excludeServers(ryw->getTransaction(), addresses, failed);
|
2020-07-07 02:02:48 +08:00
|
|
|
includeServers(ryw);
|
|
|
|
|
2020-06-28 03:22:32 +08:00
|
|
|
return result;
|
2020-06-15 13:39:20 +08:00
|
|
|
}
|
2020-07-07 02:02:48 +08:00
|
|
|
|
|
|
|
Future<Optional<std::string>> ExcludeServersRangeImpl::commit(ReadYourWritesTransaction* ryw) {
|
2020-07-17 09:15:35 +08:00
|
|
|
return excludeCommitActor(ryw, false);
|
2020-07-07 02:02:48 +08:00
|
|
|
}
|
2020-07-07 06:40:21 +08:00
|
|
|
|
|
|
|
FailedServersRangeImpl::FailedServersRangeImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> FailedServersRangeImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2020-09-05 05:54:32 +08:00
|
|
|
return rwModuleWithMappingGetRangeActor(ryw, this, kr);
|
2020-07-07 06:40:21 +08:00
|
|
|
}
|
|
|
|
|
2020-09-05 06:21:47 +08:00
|
|
|
void FailedServersRangeImpl::set(ReadYourWritesTransaction* ryw, const KeyRef& key, const ValueRef& value) {
|
|
|
|
// ignore value
|
|
|
|
ryw->getSpecialKeySpaceWriteMap().insert(key, std::make_pair(true, Optional<Value>(ValueRef())));
|
|
|
|
}
|
|
|
|
|
2020-07-31 17:18:49 +08:00
|
|
|
Key FailedServersRangeImpl::decode(const KeyRef& key) const {
|
|
|
|
return key.removePrefix(SpecialKeySpace::getModuleRange(SpecialKeySpace::MODULE::MANAGEMENT).begin)
|
|
|
|
.withPrefix(LiteralStringRef("\xff/conf/"));
|
|
|
|
}
|
|
|
|
|
|
|
|
Key FailedServersRangeImpl::encode(const KeyRef& key) const {
|
|
|
|
return key.removePrefix(LiteralStringRef("\xff/conf/"))
|
|
|
|
.withPrefix(SpecialKeySpace::getModuleRange(SpecialKeySpace::MODULE::MANAGEMENT).begin);
|
|
|
|
}
|
|
|
|
|
2020-07-07 06:40:21 +08:00
|
|
|
Future<Optional<std::string>> FailedServersRangeImpl::commit(ReadYourWritesTransaction* ryw) {
|
2020-07-17 09:15:35 +08:00
|
|
|
return excludeCommitActor(ryw, true);
|
2020-07-14 04:35:25 +08:00
|
|
|
}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR Future<RangeResult> ExclusionInProgressActor(ReadYourWritesTransaction* ryw, KeyRef prefix, KeyRangeRef kr) {
|
|
|
|
state RangeResult result;
|
2020-07-14 04:35:25 +08:00
|
|
|
state Transaction& tr = ryw->getTransaction();
|
2020-07-16 07:15:43 +08:00
|
|
|
tr.setOption(FDBTransactionOptions::READ_SYSTEM_KEYS);
|
|
|
|
tr.setOption(FDBTransactionOptions::PRIORITY_SYSTEM_IMMEDIATE); // necessary?
|
|
|
|
tr.setOption(FDBTransactionOptions::LOCK_AWARE);
|
2020-07-14 04:35:25 +08:00
|
|
|
|
|
|
|
state std::vector<AddressExclusion> excl = wait((getExcludedServers(&tr)));
|
2020-07-16 07:15:43 +08:00
|
|
|
state std::set<AddressExclusion> exclusions(excl.begin(), excl.end());
|
2020-07-14 04:35:25 +08:00
|
|
|
state std::set<NetworkAddress> inProgressExclusion;
|
2020-07-16 07:15:43 +08:00
|
|
|
// Just getting a consistent read version proves that a set of tlogs satisfying the exclusions has completed
|
|
|
|
// recovery Check that there aren't any storage servers with addresses violating the exclusions
|
2021-05-04 04:14:16 +08:00
|
|
|
state RangeResult serverList = wait(tr.getRange(serverListKeys, CLIENT_KNOBS->TOO_MANY));
|
2020-07-16 07:15:43 +08:00
|
|
|
ASSERT(!serverList.more && serverList.size() < CLIENT_KNOBS->TOO_MANY);
|
|
|
|
|
|
|
|
for (auto& s : serverList) {
|
|
|
|
auto addresses = decodeServerListValue(s.value).getKeyValues.getEndpoint().addresses;
|
|
|
|
if (addressExcluded(exclusions, addresses.address)) {
|
2020-07-14 04:35:25 +08:00
|
|
|
inProgressExclusion.insert(addresses.address);
|
|
|
|
}
|
2020-07-16 07:15:43 +08:00
|
|
|
if (addresses.secondaryAddress.present() && addressExcluded(exclusions, addresses.secondaryAddress.get())) {
|
2020-07-14 04:35:25 +08:00
|
|
|
inProgressExclusion.insert(addresses.secondaryAddress.get());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-16 07:15:43 +08:00
|
|
|
Optional<Standalone<StringRef>> value = wait(tr.get(logsKey));
|
2020-07-14 04:35:25 +08:00
|
|
|
ASSERT(value.present());
|
|
|
|
auto logs = decodeLogsValue(value.get());
|
2020-07-16 07:15:43 +08:00
|
|
|
for (auto const& log : logs.first) {
|
2020-07-14 04:35:25 +08:00
|
|
|
if (log.second == NetworkAddress() || addressExcluded(exclusions, log.second)) {
|
|
|
|
inProgressExclusion.insert(log.second);
|
|
|
|
}
|
|
|
|
}
|
2020-07-16 07:15:43 +08:00
|
|
|
for (auto const& log : logs.second) {
|
2020-07-14 04:35:25 +08:00
|
|
|
if (log.second == NetworkAddress() || addressExcluded(exclusions, log.second)) {
|
|
|
|
inProgressExclusion.insert(log.second);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-21 16:20:14 +08:00
|
|
|
// sort and remove :tls
|
|
|
|
std::set<std::string> inProgressAddresses;
|
2020-07-16 07:15:43 +08:00
|
|
|
for (auto const& address : inProgressExclusion) {
|
2020-08-21 16:20:14 +08:00
|
|
|
inProgressAddresses.insert(formatIpPort(address.ip, address.port));
|
|
|
|
}
|
|
|
|
|
|
|
|
for (auto const& address : inProgressAddresses) {
|
|
|
|
Key addrKey = prefix.withSuffix(address);
|
2020-07-31 09:58:09 +08:00
|
|
|
if (kr.contains(addrKey)) {
|
|
|
|
result.push_back(result.arena(), KeyValueRef(addrKey, ValueRef()));
|
|
|
|
result.arena().dependsOn(addrKey.arena());
|
|
|
|
}
|
2020-07-14 04:35:25 +08:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ExclusionInProgressRangeImpl::ExclusionInProgressRangeImpl(KeyRangeRef kr) : SpecialKeyRangeAsyncImpl(kr) {}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> ExclusionInProgressRangeImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2020-07-14 04:35:25 +08:00
|
|
|
return ExclusionInProgressActor(ryw, getKeyRange().begin, kr);
|
2020-07-16 08:30:45 +08:00
|
|
|
}
|
2020-08-14 16:01:08 +08:00
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR Future<RangeResult> getProcessClassActor(ReadYourWritesTransaction* ryw, KeyRef prefix, KeyRangeRef kr) {
|
2020-08-21 04:50:35 +08:00
|
|
|
vector<ProcessData> _workers = wait(getWorkers(&ryw->getTransaction()));
|
|
|
|
auto workers = _workers; // strip const
|
2020-08-26 09:18:32 +08:00
|
|
|
// Note : the sort by string is anti intuition, ex. 1.1.1.1:11 < 1.1.1.1:5
|
2020-08-21 15:56:12 +08:00
|
|
|
std::sort(workers.begin(), workers.end(), [](const ProcessData& lhs, const ProcessData& rhs) {
|
|
|
|
return formatIpPort(lhs.address.ip, lhs.address.port) < formatIpPort(rhs.address.ip, rhs.address.port);
|
|
|
|
});
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult result;
|
2020-08-21 04:50:35 +08:00
|
|
|
for (auto& w : workers) {
|
|
|
|
// exclude :tls in keys even the network addresss is TLS
|
2020-09-03 04:38:24 +08:00
|
|
|
KeyRef k(prefix.withSuffix(formatIpPort(w.address.ip, w.address.port), result.arena()));
|
2020-08-21 04:50:35 +08:00
|
|
|
if (kr.contains(k)) {
|
2020-09-03 04:38:24 +08:00
|
|
|
ValueRef v(result.arena(), w.processClass.toString());
|
2020-08-21 04:50:35 +08:00
|
|
|
result.push_back(result.arena(), KeyValueRef(k, v));
|
2020-08-14 16:01:08 +08:00
|
|
|
}
|
|
|
|
}
|
2020-09-05 05:54:32 +08:00
|
|
|
return rywGetRange(ryw, kr, result);
|
2020-08-14 16:01:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ACTOR Future<Optional<std::string>> processClassCommitActor(ReadYourWritesTransaction* ryw, KeyRangeRef range) {
|
2020-08-20 08:54:38 +08:00
|
|
|
// enable related options
|
|
|
|
ryw->setOption(FDBTransactionOptions::PRIORITY_SYSTEM_IMMEDIATE);
|
|
|
|
ryw->setOption(FDBTransactionOptions::LOCK_AWARE);
|
|
|
|
ryw->setOption(FDBTransactionOptions::USE_PROVISIONAL_PROXIES);
|
|
|
|
vector<ProcessData> workers = wait(
|
|
|
|
getWorkers(&ryw->getTransaction())); // make sure we use the Transaction object to avoid used_during_commit()
|
|
|
|
|
2020-08-14 16:01:08 +08:00
|
|
|
auto ranges = ryw->getSpecialKeySpaceWriteMap().containedRanges(range);
|
|
|
|
auto iter = ranges.begin();
|
|
|
|
while (iter != ranges.end()) {
|
|
|
|
auto entry = iter->value();
|
2020-08-21 15:56:12 +08:00
|
|
|
// only loop through (set) operation, (clear) not exist
|
2020-08-14 16:01:08 +08:00
|
|
|
if (entry.first && entry.second.present()) {
|
2020-08-21 15:56:12 +08:00
|
|
|
// parse network address
|
2020-08-14 16:01:08 +08:00
|
|
|
Key address = iter->begin().removePrefix(range.begin);
|
2020-08-20 08:54:38 +08:00
|
|
|
AddressExclusion addr = AddressExclusion::parse(address);
|
2020-08-21 15:56:12 +08:00
|
|
|
// parse class type
|
2020-08-14 16:01:08 +08:00
|
|
|
ValueRef processClassType = entry.second.get();
|
|
|
|
ProcessClass processClass(processClassType.toString(), ProcessClass::DBSource);
|
2020-08-21 15:56:12 +08:00
|
|
|
// make sure we use the underlying Transaction object to avoid used_during_commit()
|
2020-08-20 08:54:38 +08:00
|
|
|
bool foundChange = false;
|
|
|
|
for (int i = 0; i < workers.size(); i++) {
|
|
|
|
if (addr.excludes(workers[i].address)) {
|
|
|
|
if (processClass.classType() != ProcessClass::InvalidClass)
|
|
|
|
ryw->getTransaction().set(processClassKeyFor(workers[i].locality.processId().get()),
|
|
|
|
processClassValue(processClass));
|
|
|
|
else
|
|
|
|
ryw->getTransaction().clear(processClassKeyFor(workers[i].locality.processId().get()));
|
|
|
|
foundChange = true;
|
|
|
|
}
|
2020-08-14 16:01:08 +08:00
|
|
|
}
|
2020-08-20 08:54:38 +08:00
|
|
|
if (foundChange)
|
|
|
|
ryw->getTransaction().set(processClassChangeKey, deterministicRandom()->randomUniqueID().toString());
|
2020-08-14 16:01:08 +08:00
|
|
|
}
|
|
|
|
++iter;
|
|
|
|
}
|
2020-08-21 15:56:12 +08:00
|
|
|
return Optional<std::string>();
|
2020-08-14 16:01:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ProcessClassRangeImpl::ProcessClassRangeImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> ProcessClassRangeImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2020-08-14 16:01:08 +08:00
|
|
|
return getProcessClassActor(ryw, getKeyRange().begin, kr);
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<Optional<std::string>> ProcessClassRangeImpl::commit(ReadYourWritesTransaction* ryw) {
|
2020-08-21 15:56:12 +08:00
|
|
|
// Validate network address and process class type
|
|
|
|
Optional<std::string> errorMsg;
|
|
|
|
auto ranges = ryw->getSpecialKeySpaceWriteMap().containedRanges(getKeyRange());
|
|
|
|
auto iter = ranges.begin();
|
|
|
|
while (iter != ranges.end()) {
|
|
|
|
auto entry = iter->value();
|
|
|
|
// only check for setclass(set) operation, (clear) are forbidden thus not exist
|
|
|
|
if (entry.first && entry.second.present()) {
|
|
|
|
// validate network address
|
|
|
|
Key address = iter->begin().removePrefix(range.begin);
|
|
|
|
AddressExclusion addr = AddressExclusion::parse(address);
|
|
|
|
if (!addr.isValid()) {
|
|
|
|
std::string error = "ERROR: \'" + address.toString() + "\' is not a valid network endpoint address\n";
|
|
|
|
if (address.toString().find(":tls") != std::string::npos)
|
|
|
|
error += " Do not include the `:tls' suffix when naming a process\n";
|
|
|
|
errorMsg = ManagementAPIError::toJsonString(false, "setclass", error);
|
|
|
|
return errorMsg;
|
|
|
|
}
|
|
|
|
// validate class type
|
|
|
|
ValueRef processClassType = entry.second.get();
|
|
|
|
ProcessClass processClass(processClassType.toString(), ProcessClass::DBSource);
|
|
|
|
if (processClass.classType() == ProcessClass::InvalidClass &&
|
|
|
|
processClassType != LiteralStringRef("default")) {
|
|
|
|
std::string error = "ERROR: \'" + processClassType.toString() + "\' is not a valid process class\n";
|
|
|
|
errorMsg = ManagementAPIError::toJsonString(false, "setclass", error);
|
|
|
|
return errorMsg;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
++iter;
|
|
|
|
}
|
2020-08-14 16:01:08 +08:00
|
|
|
return processClassCommitActor(ryw, getKeyRange());
|
2020-08-20 08:54:38 +08:00
|
|
|
}
|
|
|
|
|
2020-10-09 05:23:02 +08:00
|
|
|
void throwSpecialKeyApiFailure(ReadYourWritesTransaction* ryw, std::string command, std::string message) {
|
|
|
|
auto msg = ManagementAPIError::toJsonString(false, command, message);
|
2020-08-21 05:38:07 +08:00
|
|
|
ryw->setSpecialKeySpaceErrorMsg(msg);
|
2020-08-20 08:54:38 +08:00
|
|
|
throw special_keys_api_failure();
|
|
|
|
}
|
|
|
|
|
2020-08-26 05:59:43 +08:00
|
|
|
void ProcessClassRangeImpl::clear(ReadYourWritesTransaction* ryw, const KeyRangeRef& range) {
|
2020-10-09 05:23:02 +08:00
|
|
|
return throwSpecialKeyApiFailure(ryw, "setclass", "Clear operation is meaningless thus forbidden for setclass");
|
2020-08-21 05:38:07 +08:00
|
|
|
}
|
|
|
|
|
2020-08-26 05:59:43 +08:00
|
|
|
void ProcessClassRangeImpl::clear(ReadYourWritesTransaction* ryw, const KeyRef& key) {
|
2021-03-11 02:06:03 +08:00
|
|
|
return throwSpecialKeyApiFailure(
|
|
|
|
ryw, "setclass", "Clear range operation is meaningless thus forbidden for setclass");
|
2020-08-21 05:51:41 +08:00
|
|
|
}
|
2020-08-26 09:18:32 +08:00
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR Future<RangeResult> getProcessClassSourceActor(ReadYourWritesTransaction* ryw, KeyRef prefix, KeyRangeRef kr) {
|
2020-08-26 09:18:32 +08:00
|
|
|
vector<ProcessData> _workers = wait(getWorkers(&ryw->getTransaction()));
|
|
|
|
auto workers = _workers; // strip const
|
|
|
|
// Note : the sort by string is anti intuition, ex. 1.1.1.1:11 < 1.1.1.1:5
|
|
|
|
std::sort(workers.begin(), workers.end(), [](const ProcessData& lhs, const ProcessData& rhs) {
|
|
|
|
return formatIpPort(lhs.address.ip, lhs.address.port) < formatIpPort(rhs.address.ip, rhs.address.port);
|
|
|
|
});
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult result;
|
2020-08-26 09:18:32 +08:00
|
|
|
for (auto& w : workers) {
|
|
|
|
// exclude :tls in keys even the network addresss is TLS
|
|
|
|
Key k(prefix.withSuffix(formatIpPort(w.address.ip, w.address.port)));
|
|
|
|
if (kr.contains(k)) {
|
|
|
|
Value v(w.processClass.sourceString());
|
|
|
|
result.push_back(result.arena(), KeyValueRef(k, v));
|
|
|
|
result.arena().dependsOn(k.arena());
|
|
|
|
result.arena().dependsOn(v.arena());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ProcessClassSourceRangeImpl::ProcessClassSourceRangeImpl(KeyRangeRef kr) : SpecialKeyRangeReadImpl(kr) {}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> ProcessClassSourceRangeImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2020-08-26 09:18:32 +08:00
|
|
|
return getProcessClassSourceActor(ryw, getKeyRange().begin, kr);
|
2020-10-09 05:23:02 +08:00
|
|
|
}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR Future<RangeResult> getLockedKeyActor(ReadYourWritesTransaction* ryw, KeyRangeRef kr) {
|
2020-10-09 05:23:02 +08:00
|
|
|
ryw->getTransaction().setOption(FDBTransactionOptions::LOCK_AWARE);
|
|
|
|
Optional<Value> val = wait(ryw->getTransaction().get(databaseLockedKey));
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult result;
|
2020-10-09 05:23:02 +08:00
|
|
|
if (val.present()) {
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(kr.begin, val.get()));
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
LockDatabaseImpl::LockDatabaseImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> LockDatabaseImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2020-10-23 06:36:10 +08:00
|
|
|
// single key range, the queried range should always be the same as the underlying range
|
2020-10-09 05:23:02 +08:00
|
|
|
ASSERT(kr == getKeyRange());
|
|
|
|
auto lockEntry = ryw->getSpecialKeySpaceWriteMap()[SpecialKeySpace::getManagementApiCommandPrefix("lock")];
|
|
|
|
if (!ryw->readYourWritesDisabled() && lockEntry.first) {
|
|
|
|
// ryw enabled and we have written to the special key
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult result;
|
2020-10-09 05:23:02 +08:00
|
|
|
if (lockEntry.second.present()) {
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(kr.begin, lockEntry.second.get()));
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
} else {
|
|
|
|
return getLockedKeyActor(ryw, kr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ACTOR Future<Optional<std::string>> lockDatabaseCommitActor(ReadYourWritesTransaction* ryw) {
|
|
|
|
state Optional<std::string> msg;
|
|
|
|
ryw->getTransaction().setOption(FDBTransactionOptions::LOCK_AWARE);
|
|
|
|
Optional<Value> val = wait(ryw->getTransaction().get(databaseLockedKey));
|
|
|
|
UID uid = deterministicRandom()->randomUniqueID();
|
|
|
|
|
|
|
|
if (val.present() && BinaryReader::fromStringRef<UID>(val.get().substr(10), Unversioned()) != uid) {
|
|
|
|
// check database not locked
|
|
|
|
// if locked already, throw error
|
|
|
|
msg = ManagementAPIError::toJsonString(false, "lock", "Database has already been locked");
|
|
|
|
} else if (!val.present()) {
|
|
|
|
// lock database
|
|
|
|
ryw->getTransaction().atomicOp(databaseLockedKey,
|
|
|
|
BinaryWriter::toValue(uid, Unversioned())
|
|
|
|
.withPrefix(LiteralStringRef("0123456789"))
|
|
|
|
.withSuffix(LiteralStringRef("\x00\x00\x00\x00")),
|
|
|
|
MutationRef::SetVersionstampedValue);
|
|
|
|
ryw->getTransaction().addWriteConflictRange(normalKeys);
|
|
|
|
}
|
|
|
|
|
|
|
|
return msg;
|
|
|
|
}
|
|
|
|
|
|
|
|
ACTOR Future<Optional<std::string>> unlockDatabaseCommitActor(ReadYourWritesTransaction* ryw) {
|
|
|
|
ryw->getTransaction().setOption(FDBTransactionOptions::LOCK_AWARE);
|
|
|
|
Optional<Value> val = wait(ryw->getTransaction().get(databaseLockedKey));
|
|
|
|
if (val.present()) {
|
|
|
|
ryw->getTransaction().clear(singleKeyRange(databaseLockedKey));
|
|
|
|
}
|
|
|
|
return Optional<std::string>();
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<Optional<std::string>> LockDatabaseImpl::commit(ReadYourWritesTransaction* ryw) {
|
|
|
|
auto lockId = ryw->getSpecialKeySpaceWriteMap()[SpecialKeySpace::getManagementApiCommandPrefix("lock")].second;
|
|
|
|
if (lockId.present()) {
|
|
|
|
return lockDatabaseCommitActor(ryw);
|
|
|
|
} else {
|
|
|
|
return unlockDatabaseCommitActor(ryw);
|
|
|
|
}
|
|
|
|
}
|
2020-10-23 02:08:54 +08:00
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR Future<RangeResult> getConsistencyCheckKeyActor(ReadYourWritesTransaction* ryw, KeyRangeRef kr) {
|
2020-10-23 02:08:54 +08:00
|
|
|
ryw->getTransaction().setOption(FDBTransactionOptions::LOCK_AWARE);
|
|
|
|
ryw->getTransaction().setOption(FDBTransactionOptions::PRIORITY_SYSTEM_IMMEDIATE);
|
|
|
|
Optional<Value> val = wait(ryw->getTransaction().get(fdbShouldConsistencyCheckBeSuspended));
|
|
|
|
bool ccSuspendSetting = val.present() ? BinaryReader::fromStringRef<bool>(val.get(), Unversioned()) : false;
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult result;
|
2020-10-23 02:08:54 +08:00
|
|
|
if (ccSuspendSetting) {
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(kr.begin, ValueRef()));
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
ConsistencyCheckImpl::ConsistencyCheckImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> ConsistencyCheckImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2020-10-23 06:36:10 +08:00
|
|
|
// single key range, the queried range should always be the same as the underlying range
|
2020-10-23 02:08:54 +08:00
|
|
|
ASSERT(kr == getKeyRange());
|
|
|
|
auto entry = ryw->getSpecialKeySpaceWriteMap()[SpecialKeySpace::getManagementApiCommandPrefix("consistencycheck")];
|
|
|
|
if (!ryw->readYourWritesDisabled() && entry.first) {
|
|
|
|
// ryw enabled and we have written to the special key
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult result;
|
2020-10-23 02:08:54 +08:00
|
|
|
if (entry.second.present()) {
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(kr.begin, entry.second.get()));
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
} else {
|
|
|
|
return getConsistencyCheckKeyActor(ryw, kr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<Optional<std::string>> ConsistencyCheckImpl::commit(ReadYourWritesTransaction* ryw) {
|
|
|
|
auto entry =
|
|
|
|
ryw->getSpecialKeySpaceWriteMap()[SpecialKeySpace::getManagementApiCommandPrefix("consistencycheck")].second;
|
|
|
|
ryw->getTransaction().setOption(FDBTransactionOptions::PRIORITY_SYSTEM_IMMEDIATE);
|
|
|
|
ryw->getTransaction().setOption(FDBTransactionOptions::LOCK_AWARE);
|
|
|
|
ryw->getTransaction().set(fdbShouldConsistencyCheckBeSuspended,
|
|
|
|
BinaryWriter::toValue(entry.present(), Unversioned()));
|
|
|
|
return Optional<std::string>();
|
|
|
|
}
|
2020-12-01 06:57:17 +08:00
|
|
|
|
2021-02-13 10:55:01 +08:00
|
|
|
GlobalConfigImpl::GlobalConfigImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
|
|
|
|
|
2021-03-20 08:37:01 +08:00
|
|
|
// Returns key-value pairs for each value stored in the global configuration
|
|
|
|
// framework within the range specified. The special-key-space getrange
|
|
|
|
// function should only be used for informational purposes. All values are
|
|
|
|
// returned as strings regardless of their true type.
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> GlobalConfigImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
|
|
|
RangeResult result;
|
2021-02-13 10:55:01 +08:00
|
|
|
|
|
|
|
auto& globalConfig = GlobalConfig::globalConfig();
|
2021-03-17 08:20:25 +08:00
|
|
|
KeyRangeRef modified =
|
|
|
|
KeyRangeRef(kr.begin.removePrefix(getKeyRange().begin), kr.end.removePrefix(getKeyRange().begin));
|
2021-03-20 04:28:03 +08:00
|
|
|
std::map<KeyRef, Reference<ConfigValue>> values = globalConfig.get(modified);
|
2021-02-25 10:29:53 +08:00
|
|
|
for (const auto& [key, config] : values) {
|
2021-02-20 06:00:07 +08:00
|
|
|
Key prefixedKey = key.withPrefix(getKeyRange().begin);
|
2021-03-20 04:28:03 +08:00
|
|
|
if (config.isValid() && config->value.has_value()) {
|
|
|
|
if (config->value.type() == typeid(StringRef)) {
|
2021-03-17 08:20:25 +08:00
|
|
|
result.push_back_deep(result.arena(),
|
2021-03-20 04:28:03 +08:00
|
|
|
KeyValueRef(prefixedKey, std::any_cast<StringRef>(config->value).toString()));
|
|
|
|
} else if (config->value.type() == typeid(int64_t)) {
|
2021-03-17 08:20:25 +08:00
|
|
|
result.push_back_deep(result.arena(),
|
2021-03-20 04:28:03 +08:00
|
|
|
KeyValueRef(prefixedKey, std::to_string(std::any_cast<int64_t>(config->value))));
|
|
|
|
} else if (config->value.type() == typeid(float)) {
|
2021-03-17 08:20:25 +08:00
|
|
|
result.push_back_deep(result.arena(),
|
2021-03-20 04:28:03 +08:00
|
|
|
KeyValueRef(prefixedKey, std::to_string(std::any_cast<float>(config->value))));
|
|
|
|
} else if (config->value.type() == typeid(double)) {
|
2021-03-17 08:20:25 +08:00
|
|
|
result.push_back_deep(result.arena(),
|
2021-03-20 04:28:03 +08:00
|
|
|
KeyValueRef(prefixedKey, std::to_string(std::any_cast<double>(config->value))));
|
2021-02-20 06:00:07 +08:00
|
|
|
} else {
|
|
|
|
ASSERT(false);
|
|
|
|
}
|
2021-02-13 10:55:01 +08:00
|
|
|
}
|
|
|
|
}
|
2021-02-20 06:00:07 +08:00
|
|
|
|
2021-02-13 10:55:01 +08:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2021-03-20 08:37:01 +08:00
|
|
|
// Marks the key for insertion into global configuration.
|
2021-02-13 10:55:01 +08:00
|
|
|
void GlobalConfigImpl::set(ReadYourWritesTransaction* ryw, const KeyRef& key, const ValueRef& value) {
|
|
|
|
ryw->getSpecialKeySpaceWriteMap().insert(key, std::make_pair(true, Optional<Value>(value)));
|
|
|
|
}
|
|
|
|
|
2021-03-20 08:37:01 +08:00
|
|
|
// Writes global configuration changes to durable memory. Also writes the
|
|
|
|
// changes made in the transaction to a recent history set, and updates the
|
|
|
|
// latest version which the global configuration was updated at.
|
2021-04-14 03:50:18 +08:00
|
|
|
ACTOR Future<Optional<std::string>> globalConfigCommitActor(GlobalConfigImpl* globalConfig,
|
|
|
|
ReadYourWritesTransaction* ryw) {
|
2021-02-13 10:55:01 +08:00
|
|
|
state Transaction& tr = ryw->getTransaction();
|
|
|
|
|
|
|
|
// History should only contain three most recent updates. If it currently
|
|
|
|
// has three items, remove the oldest to make room for a new item.
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult history = wait(tr.getRange(globalConfigHistoryKeys, CLIENT_KNOBS->TOO_MANY));
|
2021-02-13 10:55:01 +08:00
|
|
|
constexpr int kGlobalConfigMaxHistorySize = 3;
|
|
|
|
if (history.size() > kGlobalConfigMaxHistorySize - 1) {
|
2021-03-16 09:03:54 +08:00
|
|
|
for (int i = 0; i < history.size() - (kGlobalConfigMaxHistorySize - 1); ++i) {
|
|
|
|
tr.clear(history[i].key);
|
2021-02-13 10:55:01 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-17 04:47:41 +08:00
|
|
|
VersionHistory vh{ 0 };
|
2021-02-13 10:55:01 +08:00
|
|
|
|
2021-03-16 09:03:54 +08:00
|
|
|
// Transform writes from the special-key-space (\xff\xff/global_config/) to
|
|
|
|
// the system key space (\xff/globalConfig/), and writes mutations to
|
|
|
|
// latest version history.
|
2021-02-13 10:55:01 +08:00
|
|
|
state RangeMap<Key, std::pair<bool, Optional<Value>>, KeyRangeRef>::Ranges ranges =
|
|
|
|
ryw->getSpecialKeySpaceWriteMap().containedRanges(specialKeys);
|
|
|
|
state RangeMap<Key, std::pair<bool, Optional<Value>>, KeyRangeRef>::iterator iter = ranges.begin();
|
|
|
|
while (iter != ranges.end()) {
|
|
|
|
std::pair<bool, Optional<Value>> entry = iter->value();
|
|
|
|
if (entry.first) {
|
2021-03-24 07:22:39 +08:00
|
|
|
if (entry.second.present() && iter->begin().startsWith(globalConfig->getKeyRange().begin)) {
|
2021-02-25 03:49:25 +08:00
|
|
|
Key bareKey = iter->begin().removePrefix(globalConfig->getKeyRange().begin);
|
2021-03-16 09:03:54 +08:00
|
|
|
vh.mutations.emplace_back_deep(vh.mutations.arena(),
|
|
|
|
MutationRef(MutationRef::SetValue, bareKey, entry.second.get()));
|
2021-02-25 03:49:25 +08:00
|
|
|
|
|
|
|
Key systemKey = bareKey.withPrefix(globalConfigKeysPrefix);
|
2021-02-13 10:55:01 +08:00
|
|
|
tr.set(systemKey, entry.second.get());
|
2021-03-24 07:22:39 +08:00
|
|
|
} else if (!entry.second.present() && iter->range().begin.startsWith(globalConfig->getKeyRange().begin) &&
|
|
|
|
iter->range().end.startsWith(globalConfig->getKeyRange().begin)) {
|
2021-02-25 03:49:25 +08:00
|
|
|
KeyRef bareRangeBegin = iter->range().begin.removePrefix(globalConfig->getKeyRange().begin);
|
|
|
|
KeyRef bareRangeEnd = iter->range().end.removePrefix(globalConfig->getKeyRange().begin);
|
2021-03-16 09:03:54 +08:00
|
|
|
vh.mutations.emplace_back_deep(vh.mutations.arena(),
|
|
|
|
MutationRef(MutationRef::ClearRange, bareRangeBegin, bareRangeEnd));
|
2021-02-25 03:49:25 +08:00
|
|
|
|
|
|
|
Key systemRangeBegin = bareRangeBegin.withPrefix(globalConfigKeysPrefix);
|
|
|
|
Key systemRangeEnd = bareRangeEnd.withPrefix(globalConfigKeysPrefix);
|
|
|
|
tr.clear(KeyRangeRef(systemRangeBegin, systemRangeEnd));
|
2021-02-13 10:55:01 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
++iter;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Record the mutations in this commit into the global configuration history.
|
2021-03-16 09:03:54 +08:00
|
|
|
Key historyKey = addVersionStampAtEnd(globalConfigHistoryPrefix);
|
|
|
|
ObjectWriter historyWriter(IncludeVersion());
|
|
|
|
historyWriter.serialize(vh);
|
|
|
|
tr.atomicOp(historyKey, historyWriter.toStringRef(), MutationRef::SetVersionstampedKey);
|
2021-02-19 09:44:42 +08:00
|
|
|
|
|
|
|
// Write version key to trigger update in cluster controller.
|
|
|
|
tr.atomicOp(globalConfigVersionKey,
|
2021-03-16 09:03:54 +08:00
|
|
|
LiteralStringRef("0123456789\x00\x00\x00\x00"), // versionstamp
|
2021-02-19 09:44:42 +08:00
|
|
|
MutationRef::SetVersionstampedValue);
|
2021-02-13 10:55:01 +08:00
|
|
|
|
|
|
|
return Optional<std::string>();
|
|
|
|
}
|
|
|
|
|
2021-03-20 08:37:01 +08:00
|
|
|
// Called when a transaction includes keys in the global configuration special-key-space range.
|
2021-02-13 10:55:01 +08:00
|
|
|
Future<Optional<std::string>> GlobalConfigImpl::commit(ReadYourWritesTransaction* ryw) {
|
|
|
|
return globalConfigCommitActor(this, ryw);
|
2020-12-04 06:06:11 +08:00
|
|
|
}
|
2020-12-01 06:57:17 +08:00
|
|
|
|
2021-03-20 08:37:01 +08:00
|
|
|
// Marks the range for deletion from global configuration.
|
2021-02-13 10:55:01 +08:00
|
|
|
void GlobalConfigImpl::clear(ReadYourWritesTransaction* ryw, const KeyRangeRef& range) {
|
2021-02-25 03:23:29 +08:00
|
|
|
ryw->getSpecialKeySpaceWriteMap().insert(range, std::make_pair(true, Optional<Value>()));
|
2021-02-13 10:55:01 +08:00
|
|
|
}
|
|
|
|
|
2021-03-20 08:37:01 +08:00
|
|
|
// Marks the key for deletion from global configuration.
|
2021-02-13 10:55:01 +08:00
|
|
|
void GlobalConfigImpl::clear(ReadYourWritesTransaction* ryw, const KeyRef& key) {
|
|
|
|
ryw->getSpecialKeySpaceWriteMap().insert(key, std::make_pair(true, Optional<Value>()));
|
2020-12-04 06:06:11 +08:00
|
|
|
}
|
2020-12-01 06:57:17 +08:00
|
|
|
|
2021-02-20 16:43:54 +08:00
|
|
|
TracingOptionsImpl::TracingOptionsImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> TracingOptionsImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
|
|
|
RangeResult result;
|
2020-12-05 03:21:39 +08:00
|
|
|
for (const auto& option : SpecialKeySpace::getTracingOptions()) {
|
|
|
|
auto key = getKeyRange().begin.withSuffix(option);
|
|
|
|
if (!kr.contains(key)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (key.endsWith(kTracingTransactionIdKey)) {
|
2021-01-30 03:45:52 +08:00
|
|
|
result.push_back_deep(result.arena(),
|
|
|
|
KeyValueRef(key, std::to_string(ryw->getTransactionInfo().spanID.first())));
|
2020-12-05 03:21:39 +08:00
|
|
|
} else if (key.endsWith(kTracingTokenKey)) {
|
2021-01-30 03:45:52 +08:00
|
|
|
result.push_back_deep(result.arena(),
|
|
|
|
KeyValueRef(key, std::to_string(ryw->getTransactionInfo().spanID.second())));
|
2020-12-05 03:21:39 +08:00
|
|
|
}
|
2020-12-01 06:57:17 +08:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void TracingOptionsImpl::set(ReadYourWritesTransaction* ryw, const KeyRef& key, const ValueRef& value) {
|
2020-12-04 06:06:11 +08:00
|
|
|
if (ryw->getApproximateSize() > 0) {
|
|
|
|
ryw->setSpecialKeySpaceErrorMsg("tracing options must be set first");
|
2020-12-08 06:43:44 +08:00
|
|
|
ryw->getSpecialKeySpaceWriteMap().insert(key, std::make_pair(true, Optional<Value>()));
|
|
|
|
return;
|
2020-12-04 06:06:11 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (key.endsWith(kTracingTransactionIdKey)) {
|
|
|
|
ryw->setTransactionID(std::stoul(value.toString()));
|
|
|
|
} else if (key.endsWith(kTracingTokenKey)) {
|
|
|
|
if (value.toString() == "true") {
|
|
|
|
ryw->setToken(deterministicRandom()->randomUInt64());
|
|
|
|
} else if (value.toString() == "false") {
|
|
|
|
ryw->setToken(0);
|
|
|
|
} else {
|
|
|
|
ryw->setSpecialKeySpaceErrorMsg("token must be set to true/false");
|
|
|
|
throw special_keys_api_failure();
|
|
|
|
}
|
2020-12-01 06:57:17 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<Optional<std::string>> TracingOptionsImpl::commit(ReadYourWritesTransaction* ryw) {
|
2020-12-08 06:43:44 +08:00
|
|
|
if (ryw->getSpecialKeySpaceWriteMap().size() > 0) {
|
|
|
|
throw special_keys_api_failure();
|
|
|
|
}
|
2020-12-01 06:57:17 +08:00
|
|
|
return Optional<std::string>();
|
|
|
|
}
|
|
|
|
|
|
|
|
void TracingOptionsImpl::clear(ReadYourWritesTransaction* ryw, const KeyRangeRef& range) {
|
2020-12-04 06:06:11 +08:00
|
|
|
ryw->setSpecialKeySpaceErrorMsg("clear range disabled");
|
|
|
|
throw special_keys_api_failure();
|
2020-12-01 06:57:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void TracingOptionsImpl::clear(ReadYourWritesTransaction* ryw, const KeyRef& key) {
|
2020-12-04 06:06:11 +08:00
|
|
|
ryw->setSpecialKeySpaceErrorMsg("clear disabled");
|
|
|
|
throw special_keys_api_failure();
|
2020-12-01 06:57:17 +08:00
|
|
|
}
|
2021-01-30 03:45:52 +08:00
|
|
|
|
|
|
|
CoordinatorsImpl::CoordinatorsImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> CoordinatorsImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
|
|
|
RangeResult result;
|
2021-01-30 03:45:52 +08:00
|
|
|
KeyRef prefix(getKeyRange().begin);
|
|
|
|
// the constructor of ClusterConnectionFile already checks whether the file is valid
|
|
|
|
auto cs = ClusterConnectionFile(ryw->getDatabase()->getConnectionFile()->getFilename()).getConnectionString();
|
|
|
|
auto coordinator_processes = cs.coordinators();
|
|
|
|
Key cluster_decription_key = prefix.withSuffix(LiteralStringRef("cluster_description"));
|
|
|
|
if (kr.contains(cluster_decription_key)) {
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(cluster_decription_key, cs.clusterKeyName()));
|
|
|
|
}
|
|
|
|
// Note : the sort by string is anti intuition, ex. 1.1.1.1:11 < 1.1.1.1:5
|
|
|
|
// include :tls in keys if the network addresss is TLS
|
2021-03-11 02:06:03 +08:00
|
|
|
std::sort(coordinator_processes.begin(),
|
|
|
|
coordinator_processes.end(),
|
2021-02-05 16:55:34 +08:00
|
|
|
[](const NetworkAddress& lhs, const NetworkAddress& rhs) { return lhs.toString() < rhs.toString(); });
|
|
|
|
std::string processes_str;
|
2021-02-19 06:23:51 +08:00
|
|
|
for (const auto& w : coordinator_processes) {
|
2021-03-11 02:06:03 +08:00
|
|
|
if (processes_str.size())
|
|
|
|
processes_str += ",";
|
2021-02-05 16:55:34 +08:00
|
|
|
processes_str += w.toString();
|
|
|
|
}
|
|
|
|
Key processes_key = prefix.withSuffix(LiteralStringRef("processes"));
|
|
|
|
if (kr.contains(processes_key)) {
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(processes_key, Value(processes_str)));
|
2021-01-30 03:45:52 +08:00
|
|
|
}
|
|
|
|
return rywGetRange(ryw, kr, result);
|
|
|
|
}
|
|
|
|
|
|
|
|
ACTOR static Future<Optional<std::string>> coordinatorsCommitActor(ReadYourWritesTransaction* ryw, KeyRangeRef kr) {
|
|
|
|
state Reference<IQuorumChange> change;
|
|
|
|
state std::vector<NetworkAddress> addressesVec;
|
2021-02-05 16:55:34 +08:00
|
|
|
state std::vector<std::string> process_address_strs;
|
2021-01-30 03:45:52 +08:00
|
|
|
state Optional<std::string> msg;
|
2021-02-05 16:55:34 +08:00
|
|
|
state int index;
|
|
|
|
state bool parse_error = false;
|
2021-01-30 03:45:52 +08:00
|
|
|
|
2021-02-05 16:55:34 +08:00
|
|
|
// check update for cluster_description
|
|
|
|
Key processes_key = LiteralStringRef("processes").withPrefix(kr.begin);
|
|
|
|
auto processes_entry = ryw->getSpecialKeySpaceWriteMap()[processes_key];
|
|
|
|
if (processes_entry.first) {
|
|
|
|
ASSERT(processes_entry.second.present()); // no clear should be seen here
|
|
|
|
auto processesStr = processes_entry.second.get().toString();
|
|
|
|
boost::split(process_address_strs, processesStr, [](char c) { return c == ','; });
|
|
|
|
if (!process_address_strs.size()) {
|
|
|
|
return ManagementAPIError::toJsonString(
|
2021-03-11 02:06:03 +08:00
|
|
|
false,
|
|
|
|
"coordinators",
|
2021-02-05 16:55:34 +08:00
|
|
|
"New coordinators\' processes are empty, please specify new processes\' network addresses with format "
|
|
|
|
"\"IP:PORT,IP:PORT,...,IP:PORT\"");
|
|
|
|
}
|
|
|
|
for (index = 0; index < process_address_strs.size(); index++) {
|
|
|
|
try {
|
|
|
|
auto a = NetworkAddress::parse(process_address_strs[index]);
|
|
|
|
if (!a.isValid())
|
|
|
|
parse_error = true;
|
|
|
|
else
|
|
|
|
addressesVec.push_back(a);
|
|
|
|
} catch (Error& e) {
|
2021-02-19 06:23:51 +08:00
|
|
|
TraceEvent(SevDebug, "SpecialKeysNetworkParseError").error(e);
|
2021-02-05 16:55:34 +08:00
|
|
|
parse_error = true;
|
|
|
|
}
|
2021-01-30 03:45:52 +08:00
|
|
|
|
2021-02-05 16:55:34 +08:00
|
|
|
if (parse_error) {
|
2021-02-09 10:52:36 +08:00
|
|
|
std::string error =
|
|
|
|
"ERROR: \'" + process_address_strs[index] + "\' is not a valid network endpoint address\n";
|
2021-02-05 16:55:34 +08:00
|
|
|
if (process_address_strs[index].find(":tls") != std::string::npos)
|
2021-01-30 03:45:52 +08:00
|
|
|
error += " Do not include the `:tls' suffix when naming a process\n";
|
2021-02-05 16:55:34 +08:00
|
|
|
return ManagementAPIError::toJsonString(false, "coordinators", error);
|
2021-01-30 03:45:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-17 05:46:45 +08:00
|
|
|
if (addressesVec.size())
|
|
|
|
change = specifiedQuorumChange(addressesVec);
|
|
|
|
else
|
|
|
|
change = noQuorumChange();
|
2021-01-30 03:45:52 +08:00
|
|
|
|
|
|
|
// check update for cluster_description
|
|
|
|
Key cluster_decription_key = LiteralStringRef("cluster_description").withPrefix(kr.begin);
|
|
|
|
auto entry = ryw->getSpecialKeySpaceWriteMap()[cluster_decription_key];
|
|
|
|
if (entry.first) {
|
|
|
|
// check valid description [a-zA-Z0-9_]+
|
|
|
|
if (entry.second.present() && isAlphaNumeric(entry.second.get().toString())) {
|
|
|
|
// do the name change
|
|
|
|
change = nameQuorumChange(entry.second.get().toString(), change);
|
|
|
|
} else {
|
|
|
|
// throw the error
|
|
|
|
return Optional<std::string>(ManagementAPIError::toJsonString(
|
|
|
|
false, "coordinators", "Cluster description must match [A-Za-z0-9_]+"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ASSERT(change.isValid());
|
|
|
|
|
|
|
|
TraceEvent(SevDebug, "SKSChangeCoordinatorsStart")
|
|
|
|
.detail("NewAddresses", describe(addressesVec))
|
|
|
|
.detail("Description", entry.first ? entry.second.get().toString() : "");
|
|
|
|
|
2021-02-17 05:01:37 +08:00
|
|
|
Optional<CoordinatorsResult> r = wait(changeQuorumChecker(&ryw->getTransaction(), change, &addressesVec));
|
2021-01-30 03:45:52 +08:00
|
|
|
|
|
|
|
TraceEvent(SevDebug, "SKSChangeCoordinatorsFinish")
|
2021-02-17 05:06:25 +08:00
|
|
|
.detail("Result", r.present() ? static_cast<int>(r.get()) : -1); // -1 means success
|
2021-01-30 03:45:52 +08:00
|
|
|
if (r.present()) {
|
|
|
|
auto res = r.get();
|
|
|
|
std::string error_msg;
|
2021-02-17 05:01:37 +08:00
|
|
|
bool retriable = false;
|
2021-01-30 03:45:52 +08:00
|
|
|
if (res == CoordinatorsResult::INVALID_NETWORK_ADDRESSES) {
|
|
|
|
error_msg = "The specified network addresses are invalid";
|
|
|
|
} else if (res == CoordinatorsResult::SAME_NETWORK_ADDRESSES) {
|
|
|
|
error_msg = "No change (existing configuration satisfies request)";
|
|
|
|
} else if (res == CoordinatorsResult::NOT_COORDINATORS) {
|
|
|
|
error_msg = "Coordination servers are not running on the specified network addresses";
|
|
|
|
} else if (res == CoordinatorsResult::DATABASE_UNREACHABLE) {
|
|
|
|
error_msg = "Database unreachable";
|
|
|
|
} else if (res == CoordinatorsResult::BAD_DATABASE_STATE) {
|
|
|
|
error_msg = "The database is in an unexpected state from which changing coordinators might be unsafe";
|
|
|
|
} else if (res == CoordinatorsResult::COORDINATOR_UNREACHABLE) {
|
|
|
|
error_msg = "One of the specified coordinators is unreachable";
|
2021-02-17 05:01:37 +08:00
|
|
|
retriable = true;
|
2021-01-30 03:45:52 +08:00
|
|
|
} else if (res == CoordinatorsResult::NOT_ENOUGH_MACHINES) {
|
|
|
|
error_msg = "Too few fdbserver machines to provide coordination at the current redundancy level";
|
|
|
|
} else if (res == CoordinatorsResult::SUCCESS) {
|
|
|
|
TraceEvent(SevError, "SpecialKeysForCoordinators").detail("UnexpectedSuccessfulResult", "");
|
|
|
|
} else {
|
|
|
|
ASSERT(false);
|
|
|
|
}
|
2021-02-17 05:01:37 +08:00
|
|
|
msg = ManagementAPIError::toJsonString(retriable, "coordinators", error_msg);
|
2021-01-30 03:45:52 +08:00
|
|
|
}
|
|
|
|
return msg;
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<Optional<std::string>> CoordinatorsImpl::commit(ReadYourWritesTransaction* ryw) {
|
|
|
|
return coordinatorsCommitActor(ryw, getKeyRange());
|
|
|
|
}
|
|
|
|
|
|
|
|
void CoordinatorsImpl::clear(ReadYourWritesTransaction* ryw, const KeyRangeRef& range) {
|
|
|
|
return throwSpecialKeyApiFailure(ryw, "coordinators", "Clear range is meaningless thus forbidden for coordinators");
|
|
|
|
}
|
|
|
|
|
|
|
|
void CoordinatorsImpl::clear(ReadYourWritesTransaction* ryw, const KeyRef& key) {
|
2021-03-11 02:06:03 +08:00
|
|
|
return throwSpecialKeyApiFailure(
|
|
|
|
ryw, "coordinators", "Clear operation is meaningless thus forbidden for coordinators");
|
2021-01-30 10:20:09 +08:00
|
|
|
}
|
2021-02-17 15:55:58 +08:00
|
|
|
|
|
|
|
CoordinatorsAutoImpl::CoordinatorsAutoImpl(KeyRangeRef kr) : SpecialKeyRangeReadImpl(kr) {}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR static Future<RangeResult> CoordinatorsAutoImplActor(ReadYourWritesTransaction* ryw, KeyRangeRef kr) {
|
|
|
|
state RangeResult res;
|
2021-02-17 15:55:58 +08:00
|
|
|
state std::string autoCoordinatorsKey;
|
|
|
|
state Transaction& tr = ryw->getTransaction();
|
|
|
|
|
|
|
|
tr.setOption(FDBTransactionOptions::LOCK_AWARE);
|
|
|
|
tr.setOption(FDBTransactionOptions::USE_PROVISIONAL_PROXIES);
|
|
|
|
tr.setOption(FDBTransactionOptions::PRIORITY_SYSTEM_IMMEDIATE);
|
|
|
|
Optional<Value> currentKey = wait(tr.get(coordinatorsKey));
|
|
|
|
|
|
|
|
if (!currentKey.present()) {
|
|
|
|
ryw->setSpecialKeySpaceErrorMsg(
|
|
|
|
ManagementAPIError::toJsonString(false, "auto_coordinators", "The coordinator key does not exist"));
|
|
|
|
throw special_keys_api_failure();
|
|
|
|
}
|
|
|
|
state ClusterConnectionString old(currentKey.get().toString());
|
|
|
|
state CoordinatorsResult result = CoordinatorsResult::SUCCESS;
|
|
|
|
|
|
|
|
std::vector<NetworkAddress> _desiredCoordinators = wait(autoQuorumChange()->getDesiredCoordinators(
|
|
|
|
&tr, old.coordinators(), Reference<ClusterConnectionFile>(new ClusterConnectionFile(old)), result));
|
|
|
|
|
|
|
|
if (result == CoordinatorsResult::NOT_ENOUGH_MACHINES) {
|
|
|
|
// we could get not_enough_machines if we happen to see the database while the cluster controller is updating
|
|
|
|
// the worker list, so make sure it happens twice before returning a failure
|
|
|
|
ryw->setSpecialKeySpaceErrorMsg(ManagementAPIError::toJsonString(
|
|
|
|
true, "auto_coordinators", "The auto change attempt did not get enough machines, please try again"));
|
|
|
|
throw special_keys_api_failure();
|
|
|
|
}
|
|
|
|
|
|
|
|
for (const auto& address : _desiredCoordinators) {
|
|
|
|
autoCoordinatorsKey += autoCoordinatorsKey.size() ? "," : "";
|
|
|
|
autoCoordinatorsKey += address.toString();
|
|
|
|
}
|
|
|
|
res.push_back_deep(res.arena(), KeyValueRef(kr.begin, Value(autoCoordinatorsKey)));
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> CoordinatorsAutoImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2021-02-17 15:55:58 +08:00
|
|
|
// single key range, the queried range should always be the same as the underlying range
|
|
|
|
ASSERT(kr == getKeyRange());
|
|
|
|
return CoordinatorsAutoImplActor(ryw, kr);
|
|
|
|
}
|
2021-02-20 06:29:08 +08:00
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR static Future<RangeResult> getMinCommitVersionActor(ReadYourWritesTransaction* ryw, KeyRangeRef kr) {
|
2021-02-18 17:27:14 +08:00
|
|
|
ryw->getTransaction().setOption(FDBTransactionOptions::LOCK_AWARE);
|
|
|
|
Optional<Value> val = wait(ryw->getTransaction().get(minRequiredCommitVersionKey));
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult result;
|
2021-02-18 17:27:14 +08:00
|
|
|
if (val.present()) {
|
|
|
|
Version minRequiredCommitVersion = BinaryReader::fromStringRef<Version>(val.get(), Unversioned());
|
|
|
|
ValueRef version(result.arena(), boost::lexical_cast<std::string>(minRequiredCommitVersion));
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(kr.begin, version));
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
AdvanceVersionImpl::AdvanceVersionImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> AdvanceVersionImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2021-02-18 17:27:14 +08:00
|
|
|
// single key range, the queried range should always be the same as the underlying range
|
|
|
|
ASSERT(kr == getKeyRange());
|
|
|
|
auto entry = ryw->getSpecialKeySpaceWriteMap()[SpecialKeySpace::getManagementApiCommandPrefix("advanceversion")];
|
|
|
|
if (!ryw->readYourWritesDisabled() && entry.first) {
|
|
|
|
// ryw enabled and we have written to the special key
|
2021-05-04 04:14:16 +08:00
|
|
|
RangeResult result;
|
2021-02-18 17:27:14 +08:00
|
|
|
if (entry.second.present()) {
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(kr.begin, entry.second.get()));
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
} else {
|
|
|
|
return getMinCommitVersionActor(ryw, kr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ACTOR static Future<Optional<std::string>> advanceVersionCommitActor(ReadYourWritesTransaction* ryw, Version v) {
|
|
|
|
ryw->getTransaction().setOption(FDBTransactionOptions::LOCK_AWARE);
|
2021-02-26 05:02:56 +08:00
|
|
|
TraceEvent(SevDebug, "AdvanceVersion").detail("MaxAllowedVersion", maxAllowedVerion);
|
|
|
|
if (v > maxAllowedVerion) {
|
|
|
|
return ManagementAPIError::toJsonString(
|
2021-03-12 04:53:46 +08:00
|
|
|
false,
|
|
|
|
"advanceversion",
|
2021-02-26 05:02:56 +08:00
|
|
|
"The given version is larger than the maximum allowed value(2**63-1-version_per_second*3600*24*365*1000)");
|
|
|
|
}
|
2021-02-18 17:27:14 +08:00
|
|
|
Version rv = wait(ryw->getTransaction().getReadVersion());
|
|
|
|
if (rv <= v) {
|
|
|
|
ryw->getTransaction().set(minRequiredCommitVersionKey, BinaryWriter::toValue(v + 1, Unversioned()));
|
|
|
|
} else {
|
2021-03-12 04:53:46 +08:00
|
|
|
return ManagementAPIError::toJsonString(
|
|
|
|
false, "advanceversion", "Current read version is larger than the given version");
|
2021-02-18 17:27:14 +08:00
|
|
|
}
|
|
|
|
return Optional<std::string>();
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<Optional<std::string>> AdvanceVersionImpl::commit(ReadYourWritesTransaction* ryw) {
|
|
|
|
auto minCommitVersion =
|
|
|
|
ryw->getSpecialKeySpaceWriteMap()[SpecialKeySpace::getManagementApiCommandPrefix("advanceversion")].second;
|
|
|
|
if (minCommitVersion.present()) {
|
|
|
|
try {
|
|
|
|
// Version is int64_t
|
|
|
|
Version v = boost::lexical_cast<int64_t>(minCommitVersion.get().toString());
|
|
|
|
return advanceVersionCommitActor(ryw, v);
|
|
|
|
} catch (boost::bad_lexical_cast& e) {
|
|
|
|
return Optional<std::string>(ManagementAPIError::toJsonString(
|
|
|
|
false, "advanceversion", "Invalid version(int64_t) argument: " + minCommitVersion.get().toString()));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ryw->getTransaction().clear(minRequiredCommitVersionKey);
|
|
|
|
}
|
|
|
|
return Optional<std::string>();
|
2021-02-20 04:22:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ClientProfilingImpl::ClientProfilingImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR static Future<RangeResult> ClientProfilingGetRangeActor(ReadYourWritesTransaction* ryw,
|
|
|
|
KeyRef prefix,
|
|
|
|
KeyRangeRef kr) {
|
|
|
|
state RangeResult result;
|
2021-02-20 04:22:00 +08:00
|
|
|
// client_txn_sample_rate
|
|
|
|
state Key sampleRateKey = LiteralStringRef("client_txn_sample_rate").withPrefix(prefix);
|
|
|
|
if (kr.contains(sampleRateKey)) {
|
|
|
|
auto entry = ryw->getSpecialKeySpaceWriteMap()[sampleRateKey];
|
|
|
|
if (!ryw->readYourWritesDisabled() && entry.first) {
|
2021-02-26 05:13:34 +08:00
|
|
|
ASSERT(entry.second.present()); // clear is forbidden
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(sampleRateKey, entry.second.get()));
|
2021-02-20 04:22:00 +08:00
|
|
|
} else {
|
|
|
|
Optional<Value> f = wait(ryw->getTransaction().get(fdbClientInfoTxnSampleRate));
|
|
|
|
std::string sampleRateStr = "default";
|
|
|
|
if (f.present()) {
|
|
|
|
const double sampleRateDbl = BinaryReader::fromStringRef<double>(f.get(), Unversioned());
|
|
|
|
if (!std::isinf(sampleRateDbl)) {
|
|
|
|
sampleRateStr = boost::lexical_cast<std::string>(sampleRateDbl);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(sampleRateKey, Value(sampleRateStr)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// client_txn_size_limit
|
|
|
|
state Key txnSizeLimitKey = LiteralStringRef("client_txn_size_limit").withPrefix(prefix);
|
|
|
|
if (kr.contains(txnSizeLimitKey)) {
|
|
|
|
auto entry = ryw->getSpecialKeySpaceWriteMap()[txnSizeLimitKey];
|
|
|
|
if (!ryw->readYourWritesDisabled() && entry.first) {
|
2021-02-26 05:13:34 +08:00
|
|
|
ASSERT(entry.second.present()); // clear is forbidden
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(txnSizeLimitKey, entry.second.get()));
|
2021-02-20 04:22:00 +08:00
|
|
|
} else {
|
|
|
|
Optional<Value> f = wait(ryw->getTransaction().get(fdbClientInfoTxnSizeLimit));
|
|
|
|
std::string sizeLimitStr = "default";
|
|
|
|
if (f.present()) {
|
|
|
|
const int64_t sizeLimit = BinaryReader::fromStringRef<int64_t>(f.get(), Unversioned());
|
|
|
|
if (sizeLimit != -1) {
|
|
|
|
sizeLimitStr = boost::lexical_cast<std::string>(sizeLimit);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(txnSizeLimitKey, Value(sizeLimitStr)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2021-03-27 03:19:33 +08:00
|
|
|
// TODO : add limitation on set operation
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> ClientProfilingImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2021-02-20 04:22:00 +08:00
|
|
|
return ClientProfilingGetRangeActor(ryw, getKeyRange().begin, kr);
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<Optional<std::string>> ClientProfilingImpl::commit(ReadYourWritesTransaction* ryw) {
|
|
|
|
// client_txn_sample_rate
|
|
|
|
Key sampleRateKey = LiteralStringRef("client_txn_sample_rate").withPrefix(getKeyRange().begin);
|
|
|
|
auto rateEntry = ryw->getSpecialKeySpaceWriteMap()[sampleRateKey];
|
|
|
|
|
|
|
|
if (rateEntry.first && rateEntry.second.present()) {
|
|
|
|
std::string sampleRateStr = rateEntry.second.get().toString();
|
|
|
|
double sampleRate;
|
|
|
|
if (sampleRateStr == "default")
|
|
|
|
sampleRate = std::numeric_limits<double>::infinity();
|
|
|
|
else {
|
|
|
|
try {
|
|
|
|
sampleRate = boost::lexical_cast<double>(sampleRateStr);
|
|
|
|
} catch (boost::bad_lexical_cast& e) {
|
|
|
|
return Optional<std::string>(ManagementAPIError::toJsonString(
|
|
|
|
false, "profile", "Invalid transaction sample rate(double): " + sampleRateStr));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ryw->getTransaction().set(fdbClientInfoTxnSampleRate, BinaryWriter::toValue(sampleRate, Unversioned()));
|
|
|
|
}
|
|
|
|
// client_txn_size_limit
|
|
|
|
Key txnSizeLimitKey = LiteralStringRef("client_txn_size_limit").withPrefix(getKeyRange().begin);
|
|
|
|
auto sizeLimitEntry = ryw->getSpecialKeySpaceWriteMap()[txnSizeLimitKey];
|
|
|
|
if (sizeLimitEntry.first && sizeLimitEntry.second.present()) {
|
|
|
|
std::string sizeLimitStr = sizeLimitEntry.second.get().toString();
|
|
|
|
int64_t sizeLimit;
|
|
|
|
if (sizeLimitStr == "default")
|
|
|
|
sizeLimit = -1;
|
|
|
|
else {
|
|
|
|
try {
|
|
|
|
sizeLimit = boost::lexical_cast<int64_t>(sizeLimitStr);
|
|
|
|
} catch (boost::bad_lexical_cast& e) {
|
|
|
|
return Optional<std::string>(ManagementAPIError::toJsonString(
|
|
|
|
false, "profile", "Invalid transaction size limit(int64_t): " + sizeLimitStr));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ryw->getTransaction().set(fdbClientInfoTxnSizeLimit, BinaryWriter::toValue(sizeLimit, Unversioned()));
|
|
|
|
}
|
|
|
|
return Optional<std::string>();
|
2021-02-20 06:29:08 +08:00
|
|
|
}
|
2021-02-26 05:02:56 +08:00
|
|
|
|
|
|
|
void ClientProfilingImpl::clear(ReadYourWritesTransaction* ryw, const KeyRangeRef& range) {
|
|
|
|
return throwSpecialKeyApiFailure(
|
|
|
|
ryw, "profile", "Clear range is forbidden for profile client. You can set it to default to disable profiling.");
|
|
|
|
}
|
|
|
|
|
|
|
|
void ClientProfilingImpl::clear(ReadYourWritesTransaction* ryw, const KeyRef& key) {
|
|
|
|
return throwSpecialKeyApiFailure(
|
2021-03-12 04:53:46 +08:00
|
|
|
ryw,
|
|
|
|
"profile",
|
2021-02-26 05:02:56 +08:00
|
|
|
"Clear operation is forbidden for profile client. You can set it to default to disable profiling.");
|
|
|
|
}
|
2021-04-16 04:50:50 +08:00
|
|
|
|
2021-03-27 03:19:33 +08:00
|
|
|
MaintenanceImpl::MaintenanceImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
|
|
|
|
|
2021-04-24 02:13:08 +08:00
|
|
|
// Used to read the healthZoneKey
|
|
|
|
// If the key is persisted and the delayed read version is still larger than current read version,
|
|
|
|
// we will calculate the remaining time(truncated to integer, the same as fdbcli) and return back as the value
|
|
|
|
// If the zoneId is the special one `ignoreSSFailuresZoneString`,
|
|
|
|
// value will be 0 (same as fdbcli)
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR static Future<RangeResult> MaintenanceGetRangeActor(ReadYourWritesTransaction* ryw,
|
|
|
|
KeyRef prefix,
|
|
|
|
KeyRangeRef kr) {
|
|
|
|
state RangeResult result;
|
2021-03-27 03:19:33 +08:00
|
|
|
// zoneId
|
|
|
|
ryw->getTransaction().setOption(FDBTransactionOptions::LOCK_AWARE);
|
|
|
|
Optional<Value> val = wait(ryw->getTransaction().get(healthyZoneKey));
|
|
|
|
if (val.present()) {
|
|
|
|
auto healthyZone = decodeHealthyZoneValue(val.get());
|
|
|
|
if ((healthyZone.first == ignoreSSFailuresZoneString) ||
|
|
|
|
(healthyZone.second > ryw->getTransaction().getReadVersion().get())) {
|
|
|
|
Key zone_key = healthyZone.first.withPrefix(prefix);
|
2021-04-21 05:04:00 +08:00
|
|
|
double seconds = healthyZone.first == ignoreSSFailuresZoneString
|
|
|
|
? 0
|
|
|
|
: (healthyZone.second - ryw->getTransaction().getReadVersion().get()) /
|
|
|
|
CLIENT_KNOBS->CORE_VERSIONSPERSECOND;
|
2021-03-27 03:19:33 +08:00
|
|
|
if (kr.contains(zone_key)) {
|
|
|
|
result.push_back_deep(result.arena(),
|
|
|
|
KeyValueRef(zone_key, Value(boost::lexical_cast<std::string>(seconds))));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rywGetRange(ryw, kr, result);
|
|
|
|
}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> MaintenanceImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2021-03-27 03:19:33 +08:00
|
|
|
return MaintenanceGetRangeActor(ryw, getKeyRange().begin, kr);
|
|
|
|
}
|
|
|
|
|
2021-04-24 02:13:08 +08:00
|
|
|
// Commit the change to healthZoneKey
|
|
|
|
// We do not allow more than one zone to be set in maintenance in one transaction
|
|
|
|
// In addition, if the zoneId now is 'ignoreSSFailuresZoneString',
|
|
|
|
// which means the data distribution is disabled for storage failures.
|
|
|
|
// Only clear this specific key is allowed, any other operations will throw error
|
2021-03-27 03:19:33 +08:00
|
|
|
ACTOR static Future<Optional<std::string>> maintenanceCommitActor(ReadYourWritesTransaction* ryw, KeyRangeRef kr) {
|
|
|
|
// read
|
|
|
|
ryw->getTransaction().setOption(FDBTransactionOptions::LOCK_AWARE);
|
|
|
|
ryw->getTransaction().setOption(FDBTransactionOptions::PRIORITY_SYSTEM_IMMEDIATE);
|
|
|
|
Optional<Value> val = wait(ryw->getTransaction().get(healthyZoneKey));
|
|
|
|
Optional<std::pair<Key, Version>> healthyZone =
|
|
|
|
val.present() ? decodeHealthyZoneValue(val.get()) : Optional<std::pair<Key, Version>>();
|
|
|
|
|
|
|
|
state RangeMap<Key, std::pair<bool, Optional<Value>>, KeyRangeRef>::Ranges ranges =
|
|
|
|
ryw->getSpecialKeySpaceWriteMap().containedRanges(kr);
|
|
|
|
Key zoneId;
|
2021-04-21 05:04:00 +08:00
|
|
|
double seconds;
|
2021-03-27 03:19:33 +08:00
|
|
|
bool isSet = false;
|
|
|
|
// Since maintenance only allows one zone at the same time,
|
|
|
|
// if a transaction has more than one set operation on different zone keys,
|
|
|
|
// the commit will throw an error
|
|
|
|
for (auto iter = ranges.begin(); iter != ranges.end(); ++iter) {
|
2021-03-27 03:24:45 +08:00
|
|
|
if (!iter->value().first)
|
|
|
|
continue;
|
2021-03-27 03:19:33 +08:00
|
|
|
if (iter->value().second.present()) {
|
|
|
|
if (isSet)
|
|
|
|
return Optional<std::string>(ManagementAPIError::toJsonString(
|
|
|
|
false, "maintenance", "Multiple zones given for maintenance, only one allowed at the same time"));
|
|
|
|
isSet = true;
|
|
|
|
zoneId = iter->begin().removePrefix(kr.begin);
|
2021-04-21 05:04:00 +08:00
|
|
|
seconds = boost::lexical_cast<double>(iter->value().second.get().toString());
|
2021-03-27 03:19:33 +08:00
|
|
|
} else {
|
|
|
|
// if we already have set operation, then all clear operations will be meaningless, thus skip
|
|
|
|
if (!isSet && healthyZone.present() && iter.range().contains(healthyZone.get().first.withPrefix(kr.begin)))
|
|
|
|
ryw->getTransaction().clear(healthyZoneKey);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isSet) {
|
|
|
|
if (healthyZone.present() && healthyZone.get().first == ignoreSSFailuresZoneString) {
|
|
|
|
std::string msg = "Maintenance mode cannot be used while data distribution is disabled for storage "
|
|
|
|
"server failures.";
|
|
|
|
return Optional<std::string>(ManagementAPIError::toJsonString(false, "maintenance", msg));
|
2021-04-21 05:09:52 +08:00
|
|
|
} else if (seconds < 0) {
|
|
|
|
std::string msg =
|
|
|
|
"The specified maintenance time " + boost::lexical_cast<std::string>(seconds) + " is a negative value";
|
2021-04-21 05:04:00 +08:00
|
|
|
return Optional<std::string>(ManagementAPIError::toJsonString(false, "maintenance", msg));
|
2021-03-27 03:19:33 +08:00
|
|
|
} else {
|
|
|
|
TraceEvent(SevDebug, "SKSMaintenanceSet").detail("ZoneId", zoneId.toString());
|
|
|
|
ryw->getTransaction().set(healthyZoneKey,
|
2021-03-27 03:24:45 +08:00
|
|
|
healthyZoneValue(zoneId,
|
|
|
|
ryw->getTransaction().getReadVersion().get() +
|
|
|
|
(seconds * CLIENT_KNOBS->CORE_VERSIONSPERSECOND)));
|
2021-03-27 03:19:33 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return Optional<std::string>();
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<Optional<std::string>> MaintenanceImpl::commit(ReadYourWritesTransaction* ryw) {
|
|
|
|
return maintenanceCommitActor(ryw, getKeyRange());
|
|
|
|
}
|
|
|
|
|
|
|
|
DataDistributionImpl::DataDistributionImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
|
|
|
|
|
2021-04-24 02:13:08 +08:00
|
|
|
// Read the system keys dataDistributionModeKey and rebalanceDDIgnoreKey
|
2021-05-04 04:14:16 +08:00
|
|
|
ACTOR static Future<RangeResult> DataDistributionGetRangeActor(ReadYourWritesTransaction* ryw,
|
|
|
|
KeyRef prefix,
|
|
|
|
KeyRangeRef kr) {
|
|
|
|
state RangeResult result;
|
2021-03-27 03:19:33 +08:00
|
|
|
// dataDistributionModeKey
|
|
|
|
state Key modeKey = LiteralStringRef("mode").withPrefix(prefix);
|
|
|
|
if (kr.contains(modeKey)) {
|
|
|
|
auto entry = ryw->getSpecialKeySpaceWriteMap()[modeKey];
|
|
|
|
if (ryw->readYourWritesDisabled() || !entry.first) {
|
|
|
|
Optional<Value> f = wait(ryw->getTransaction().get(dataDistributionModeKey));
|
|
|
|
int mode = -1;
|
|
|
|
if (f.present()) {
|
|
|
|
mode = BinaryReader::fromStringRef<int>(f.get(), Unversioned());
|
|
|
|
}
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(modeKey, Value(boost::lexical_cast<std::string>(mode))));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// rebalanceDDIgnoreKey
|
|
|
|
state Key rebalanceIgnoredKey = LiteralStringRef("rebalance_ignored").withPrefix(prefix);
|
|
|
|
if (kr.contains(rebalanceIgnoredKey)) {
|
|
|
|
auto entry = ryw->getSpecialKeySpaceWriteMap()[rebalanceIgnoredKey];
|
|
|
|
if (ryw->readYourWritesDisabled() || !entry.first) {
|
|
|
|
Optional<Value> f = wait(ryw->getTransaction().get(rebalanceDDIgnoreKey));
|
|
|
|
if (f.present()) {
|
|
|
|
result.push_back_deep(result.arena(), KeyValueRef(rebalanceIgnoredKey, Value()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rywGetRange(ryw, kr, result);
|
|
|
|
}
|
|
|
|
|
2021-05-04 04:14:16 +08:00
|
|
|
Future<RangeResult> DataDistributionImpl::getRange(ReadYourWritesTransaction* ryw, KeyRangeRef kr) const {
|
2021-03-27 03:19:33 +08:00
|
|
|
return DataDistributionGetRangeActor(ryw, getKeyRange().begin, kr);
|
|
|
|
}
|
|
|
|
|
|
|
|
Future<Optional<std::string>> DataDistributionImpl::commit(ReadYourWritesTransaction* ryw) {
|
|
|
|
// there are two valid keys in the range
|
|
|
|
// <prefix>/mode -> dataDistributionModeKey, the value is only allowed to be set as "0"(disable) or "1"(enable)
|
|
|
|
// <prefix>/rebalance_ignored -> rebalanceDDIgnoreKey, value is unused thus empty
|
|
|
|
Optional<std::string> msg;
|
|
|
|
KeyRangeRef kr = getKeyRange();
|
|
|
|
Key modeKey = LiteralStringRef("mode").withPrefix(kr.begin);
|
|
|
|
Key rebalanceIgnoredKey = LiteralStringRef("rebalance_ignored").withPrefix(kr.begin);
|
|
|
|
auto ranges = ryw->getSpecialKeySpaceWriteMap().containedRanges(kr);
|
|
|
|
for (auto iter = ranges.begin(); iter != ranges.end(); ++iter) {
|
2021-03-27 03:24:45 +08:00
|
|
|
if (!iter->value().first)
|
|
|
|
continue;
|
2021-03-27 03:19:33 +08:00
|
|
|
if (iter->value().second.present()) {
|
|
|
|
if (iter->range() == singleKeyRange(modeKey)) {
|
|
|
|
try {
|
|
|
|
int mode = boost::lexical_cast<int>(iter->value().second.get().toString());
|
|
|
|
Value modeVal = BinaryWriter::toValue(mode, Unversioned());
|
|
|
|
if (mode == 0 || mode == 1)
|
|
|
|
ryw->getTransaction().set(dataDistributionModeKey, modeVal);
|
|
|
|
else
|
2021-03-27 03:24:45 +08:00
|
|
|
msg = ManagementAPIError::toJsonString(false,
|
|
|
|
"datadistribution",
|
2021-03-27 03:19:33 +08:00
|
|
|
"Please set the value of the data_distribution/mode to "
|
|
|
|
"0(disable) or 1(enable), other values are not allowed");
|
|
|
|
} catch (boost::bad_lexical_cast& e) {
|
2021-03-27 03:24:45 +08:00
|
|
|
msg = ManagementAPIError::toJsonString(false,
|
|
|
|
"datadistribution",
|
2021-03-27 03:19:33 +08:00
|
|
|
"Invalid datadistribution mode(int): " +
|
|
|
|
iter->value().second.get().toString());
|
|
|
|
}
|
|
|
|
} else if (iter->range() == singleKeyRange(rebalanceIgnoredKey)) {
|
|
|
|
if (iter->value().second.get().size())
|
|
|
|
msg =
|
2021-03-27 03:24:45 +08:00
|
|
|
ManagementAPIError::toJsonString(false,
|
|
|
|
"datadistribution",
|
2021-03-27 03:19:33 +08:00
|
|
|
"Value is unused for the data_distribution/rebalance_ignored "
|
|
|
|
"key, please set it to an empty value");
|
|
|
|
else
|
|
|
|
ryw->getTransaction().set(rebalanceDDIgnoreKey, LiteralStringRef("on"));
|
|
|
|
} else {
|
|
|
|
msg = ManagementAPIError::toJsonString(
|
2021-03-27 03:24:45 +08:00
|
|
|
false,
|
|
|
|
"datadistribution",
|
2021-03-27 03:19:33 +08:00
|
|
|
"Changing invalid keys, please read the documentation to check valid keys in the range");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// clear
|
|
|
|
if (iter->range().contains(modeKey))
|
|
|
|
ryw->getTransaction().clear(dataDistributionModeKey);
|
|
|
|
else if (iter->range().contains(rebalanceIgnoredKey))
|
|
|
|
ryw->getTransaction().clear(rebalanceDDIgnoreKey);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return msg;
|
|
|
|
}
|