wbtiger
/
foundationdb
mirror of https://github.com/apple/foundationdb.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add tenant name to tenant map entry and remove the encrypted field

This commit is contained in:
A.J. Beamon 2022-12-05 12:26:01 -08:00
parent 8ef9bab9a4
commit 7cc79ccf68
14 changed files with 60 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
fdbcli/tests/fdbcli_tests.py
View File

@ -828,7 +828,10 @@ def tenant_get(logger):
assert(json_output['type'] == 'success')
assert(len(json_output['tenant']) == 4)
assert('id' in json_output['tenant'])
assert('encrypted' in json_output['tenant'])
assert('name' in json_output['tenant'])
assert(len(json_output['tenant']['name']) == 2)
assert('base64' in json_output['tenant']['name'])
assert('printable' in json_output['tenant']['name'])
assert('prefix' in json_output['tenant'])
assert(len(json_output['tenant']['prefix']) == 2)
assert('base64' in json_output['tenant']['prefix'])
@ -850,7 +853,10 @@ def tenant_get(logger):
assert(json_output['type'] == 'success')
assert(len(json_output['tenant']) == 5)
assert('id' in json_output['tenant'])
assert('encrypted' in json_output['tenant'])
assert('name' in json_output['tenant'])
assert(len(json_output['tenant']['name']) == 2)
assert('base64' in json_output['tenant']['name'])
assert('printable' in json_output['tenant']['name'])
assert('prefix' in json_output['tenant'])
assert(json_output['tenant']['tenant_state'] == 'ready')
assert('tenant_group' in json_output['tenant'])

55
fdbclient/Tenant.cpp
View File

@ -116,16 +116,28 @@ TenantLockState TenantMapEntry::stringToTenantLockState(std::string stateStr) {
UNREACHABLE();
}
json_spirit::mObject binaryToJson(StringRef bytes) {
json_spirit::mObject obj;
std::string encodedBytes = base64::encoder::from_string(bytes.toString());
// Remove trailing newline
encodedBytes.resize(encodedBytes.size() - 1);
obj["base64"] = encodedBytes;
obj["printable"] = printable(bytes);
return obj;
}
TenantMapEntry::TenantMapEntry() {}
TenantMapEntry::TenantMapEntry(int64_t id, TenantState tenantState, bool encrypted)
: tenantState(tenantState), encrypted(encrypted) {
TenantMapEntry::TenantMapEntry(int64_t id, TenantName tenantName, TenantState tenantState)
: tenantName(tenantName), tenantState(tenantState) {
setId(id);
}
TenantMapEntry::TenantMapEntry(int64_t id,
TenantName tenantName,
TenantState tenantState,
Optional<TenantGroupName> tenantGroup,
bool encrypted)
: tenantState(tenantState), tenantGroup(tenantGroup), encrypted(encrypted) {
Optional<TenantGroupName> tenantGroup)
: tenantName(tenantName), tenantState(tenantState), tenantGroup(tenantGroup) {
setId(id);
}
@ -138,37 +150,22 @@ void TenantMapEntry::setId(int64_t id) {
std::string TenantMapEntry::toJson() const {
json_spirit::mObject tenantEntry;
tenantEntry["id"] = id;
tenantEntry["encrypted"] = encrypted;
json_spirit::mObject prefixObject;
std::string encodedPrefix = base64::encoder::from_string(prefix.toString());
// Remove trailing newline
encodedPrefix.resize(encodedPrefix.size() - 1);
prefixObject["base64"] = encodedPrefix;
prefixObject["printable"] = printable(prefix);
tenantEntry["prefix"] = prefixObject;
tenantEntry["name"] = binaryToJson(tenantName);
tenantEntry["prefix"] = binaryToJson(prefix);
tenantEntry["tenant_state"] = TenantMapEntry::tenantStateToString(tenantState);
if (assignedCluster.present()) {
tenantEntry["assigned_cluster"] = assignedCluster.get().toString();
tenantEntry["assigned_cluster"] = binaryToJson(assignedCluster.get());
}
if (tenantGroup.present()) {
json_spirit::mObject tenantGroupObject;
std::string encodedTenantGroup = base64::encoder::from_string(tenantGroup.get().toString());
// Remove trailing newline
encodedTenantGroup.resize(encodedTenantGroup.size() - 1);
tenantGroupObject["base64"] = encodedTenantGroup;
tenantGroupObject["printable"] = printable(tenantGroup.get());
tenantEntry["tenant_group"] = tenantGroupObject;
tenantEntry["tenant_group"] = binaryToJson(tenantGroup.get());
}
return json_spirit::write_string(json_spirit::mValue(tenantEntry));
}
bool TenantMapEntry::matchesConfiguration(TenantMapEntry const& other) const {
return tenantGroup == other.tenantGroup && encrypted == other.encrypted;
return tenantGroup == other.tenantGroup;
}
void TenantMapEntry::configure(Standalone<StringRef> parameter, Optional<Value> value) {
@ -185,7 +182,7 @@ void TenantMapEntry::configure(Standalone<StringRef> parameter, Optional<Value>
json_spirit::mObject TenantGroupEntry::toJson() const {
json_spirit::mObject tenantGroupEntry;
if (assignedCluster.present()) {
tenantGroupEntry["assigned_cluster"] = assignedCluster.get().toString();
tenantGroupEntry["assigned_cluster"] = binaryToJson(assignedCluster.get());
}
return tenantGroupEntry;
@ -220,12 +217,12 @@ TEST_CASE("/fdbclient/libb64/base64decoder") {
}
TEST_CASE("/fdbclient/TenantMapEntry/Serialization") {
TenantMapEntry entry1(1, TenantState::READY, false);
TenantMapEntry entry1(1, "name"_sr, TenantState::READY);
ASSERT(entry1.prefix == "\x00\x00\x00\x00\x00\x00\x00\x01"_sr);
TenantMapEntry entry2 = TenantMapEntry::decode(entry1.encode());
ASSERT(entry1.id == entry2.id && entry1.prefix == entry2.prefix);
TenantMapEntry entry3(std::numeric_limits<int64_t>::max(), TenantState::READY, false);
TenantMapEntry entry3(std::numeric_limits<int64_t>::max(), "name"_sr, TenantState::READY);
ASSERT(entry3.prefix == "\x7f\xff\xff\xff\xff\xff\xff\xff"_sr);
TenantMapEntry entry4 = TenantMapEntry::decode(entry3.encode());
ASSERT(entry3.id == entry4.id && entry3.prefix == entry4.prefix);
@ -236,7 +233,7 @@ TEST_CASE("/fdbclient/TenantMapEntry/Serialization") {
int64_t maxPlusOne = std::min<uint64_t>(UINT64_C(1) << bits, std::numeric_limits<int64_t>::max());
int64_t id = deterministicRandom()->randomInt64(min, maxPlusOne);
TenantMapEntry entry(id, TenantState::READY, false);
TenantMapEntry entry(id, "name"_sr, TenantState::READY);
int64_t bigEndianId = bigEndian64(id);
ASSERT(entry.id == id && entry.prefix == StringRef(reinterpret_cast<uint8_t*>(&bigEndianId), 8));

8
fdbclient/include/fdbclient/Tenant.h
View File

@ -81,10 +81,10 @@ struct TenantMapEntry {
int64_t id = -1;
Key prefix;
TenantName tenantName;
TenantState tenantState = TenantState::READY;
TenantLockState tenantLockState = TenantLockState::UNLOCKED;
Optional<TenantGroupName> tenantGroup;
bool encrypted = false;
Optional<ClusterName> assignedCluster;
int64_t configurationSequenceNum = 0;
Optional<TenantName> renamePair;
@ -95,8 +95,8 @@ struct TenantMapEntry {
constexpr static int PREFIX_SIZE = sizeof(id);
TenantMapEntry();
TenantMapEntry(int64_t id, TenantState tenantState, bool encrypted);
TenantMapEntry(int64_t id, TenantState tenantState, Optional<TenantGroupName> tenantGroup, bool encrypted);
TenantMapEntry(int64_t id, TenantName tenantName, TenantState tenantState);
TenantMapEntry(int64_t id, TenantName tenantName, TenantState tenantState, Optional<TenantGroupName> tenantGroup);
void setId(int64_t id);
std::string toJson() const;
@ -113,10 +113,10 @@ struct TenantMapEntry {
void serialize(Ar& ar) {
serializer(ar,
id,
tenantName,
tenantState,
tenantLockState,
tenantGroup,
encrypted,
assignedCluster,
configurationSequenceNum,
renamePair,

1
fdbclient/include/fdbclient/TenantSpecialKeys.actor.h
View File

@ -112,7 +112,6 @@ private:
std::map<TenantGroupName, int>* tenantGroupNetTenantDelta) {
state TenantMapEntry tenantEntry;
tenantEntry.setId(tenantId);
tenantEntry.encrypted = ryw->getTransactionState()->cx->clientInfo->get().isEncryptionEnabled;
for (auto const& [name, value] : configMutations) {
tenantEntry.configure(name, value);

6
fdbserver/TenantCache.actor.cpp
View File

@ -360,7 +360,7 @@ public:
for (uint16_t i = 0; i < tenantCount; i++) {
TenantName tenantName(format("%s_%08d", "ddtc_test_tenant", tenantNumber + i));
TenantMapEntry tenant(tenantNumber + i, TenantState::READY, SERVER_KNOBS->ENABLE_ENCRYPTION);
TenantMapEntry tenant(tenantNumber + i, tenantName, TenantState::READY);
tenantCache.insert(tenantName, tenant);
}
@ -388,7 +388,7 @@ public:
for (uint16_t i = 0; i < tenantCount; i++) {
TenantName tenantName(format("%s_%08d", "ddtc_test_tenant", tenantNumber + i));
TenantMapEntry tenant(tenantNumber + i, TenantState::READY, SERVER_KNOBS->ENABLE_ENCRYPTION);
TenantMapEntry tenant(tenantNumber + i, tenantName, TenantState::READY);
tenantCache.insert(tenantName, tenant);
}
@ -402,7 +402,7 @@ public:
if (tenantOrdinal % staleTenantFraction != 0) {
TenantName tenantName(format("%s_%08d", "ddtc_test_tenant", tenantOrdinal));
TenantMapEntry tenant(tenantOrdinal, TenantState::READY, SERVER_KNOBS->ENABLE_ENCRYPTION);
TenantMapEntry tenant(tenantOrdinal, tenantName, TenantState::READY);
bool newTenant = tenantCache.update(tenantName, tenant);
ASSERT(!newTenant);
keepCount++;

1
fdbserver/include/fdbserver/workloads/MetaclusterConsistency.actor.h
View File

@ -309,7 +309,6 @@ private:
TenantMapEntry const& metaclusterEntry = self->managementMetadata.tenantMap[name];
ASSERT(!entry.assignedCluster.present());
ASSERT(entry.id == metaclusterEntry.id);
ASSERT(entry.encrypted == metaclusterEntry.encrypted);
ASSERT(entry.tenantState == TenantState::READY);
ASSERT(self->allowPartialMetaclusterOperations || metaclusterEntry.tenantState == TenantState::READY);

1
fdbserver/include/fdbserver/workloads/TenantConsistency.actor.h
View File

@ -171,7 +171,6 @@ private:
auto pairMapEntry = metadata.tenantMap[tenantMapEntry.renamePair.get()];
ASSERT(pairMapEntry.id == tenantMapEntry.id);
ASSERT(pairMapEntry.prefix == tenantMapEntry.prefix);
ASSERT(pairMapEntry.encrypted == tenantMapEntry.encrypted);
ASSERT(pairMapEntry.configurationSequenceNum == tenantMapEntry.configurationSequenceNum);
ASSERT(pairMapEntry.assignedCluster.present());
ASSERT(pairMapEntry.assignedCluster.get() == tenantMapEntry.assignedCluster.get());

10
fdbserver/storageserver.actor.cpp
View File

@ -4936,11 +4936,11 @@ bool rangeIntersectsAnyTenant(TenantPrefixIndex& prefixIndex, KeyRangeRef range,
TEST_CASE("/fdbserver/storageserver/rangeIntersectsAnyTenant") {
std::map<TenantName, TenantMapEntry> entries = {
std::make_pair("tenant0"_sr, TenantMapEntry(0, TenantState::READY, SERVER_KNOBS->ENABLE_ENCRYPTION)),
std::make_pair("tenant2"_sr, TenantMapEntry(2, TenantState::READY, SERVER_KNOBS->ENABLE_ENCRYPTION)),
std::make_pair("tenant3"_sr, TenantMapEntry(3, TenantState::READY, SERVER_KNOBS->ENABLE_ENCRYPTION)),
std::make_pair("tenant4"_sr, TenantMapEntry(4, TenantState::READY, SERVER_KNOBS->ENABLE_ENCRYPTION)),
std::make_pair("tenant6"_sr, TenantMapEntry(6, TenantState::READY, SERVER_KNOBS->ENABLE_ENCRYPTION))
std::make_pair("tenant0"_sr, TenantMapEntry(0, "tenant0"_sr, TenantState::READY)),
std::make_pair("tenant2"_sr, TenantMapEntry(2, "tenant2"_sr, TenantState::READY)),
std::make_pair("tenant3"_sr, TenantMapEntry(3, "tenant3"_sr, TenantState::READY)),
std::make_pair("tenant4"_sr, TenantMapEntry(4, "tenant4"_sr, TenantState::READY)),
std::make_pair("tenant6"_sr, TenantMapEntry(6, "tenant6"_sr, TenantState::READY))
};
TenantPrefixIndex index;
index.createNewVersion(1);

1
fdbserver/tester.actor.cpp
View File

@ -1837,7 +1837,6 @@ ACTOR Future<Void> runTests(Reference<AsyncVar<Optional<struct ClusterController
if (deterministicRandom()->coinflip()) {
entry.tenantGroup = "TestTenantGroup"_sr;
}
entry.encrypted = SERVER_KNOBS->ENABLE_ENCRYPTION;
TraceEvent("CreatingTenant").detail("Tenant", tenant).detail("TenantGroup", entry.tenantGroup);
tenantFutures.push_back(success(TenantAPI::createTenant(cx.getReference(), tenant, entry)));
}

1
fdbserver/workloads/BulkLoadWithTenants.actor.cpp
View File

@ -64,7 +64,6 @@ struct BulkSetupWorkload : TestWorkload {
std::vector<Future<Void>> tenantFutures;
for (int i = 0; i < numTenantsToCreate; i++) {
TenantMapEntry entry;
entry.encrypted = SERVER_KNOBS->ENABLE_ENCRYPTION;
workload->tenantNames.push_back(TenantName(format("BulkSetupTenant_%04d", i)));
TraceEvent("CreatingTenant")
.detail("Tenant", workload->tenantNames.back())

1
fdbserver/workloads/CreateTenant.actor.cpp
View File

@ -55,7 +55,6 @@ struct CreateTenantWorkload : TestWorkload {
TenantMapEntry givenEntry;
if (self->tenantGroup.present()) {
givenEntry.tenantGroup = self->tenantGroup.get();
givenEntry.encrypted = SERVER_KNOBS->ENABLE_ENCRYPTION;
}
Optional<TenantMapEntry> entry = wait(TenantAPI::createTenant(db.getReference(), self->tenant, givenEntry));
ASSERT(entry.present());

1
fdbserver/workloads/FuzzApiCorrectness.actor.cpp
View File

@ -240,7 +240,6 @@ struct FuzzApiCorrectnessWorkload : TestWorkload {
if (i < self->numTenants) {
TenantMapEntry entry;
entry.tenantGroup = self->getTenantGroup(i);
entry.encrypted = SERVER_KNOBS->ENABLE_ENCRYPTION;
tenantFutures.push_back(::success(TenantAPI::createTenant(cx.getReference(), tenantName, entry)));
self->createdTenants.insert(tenantName);
}

2
fdbserver/workloads/TenantEntryCacheWorkload.actor.cpp
View File

@ -91,7 +91,7 @@ struct TenantEntryCacheWorkload : TestWorkload {
// Ensure associated counter values gets updated
ASSERT_EQ(cache->numRefreshByInit(), 1);
state TenantMapEntry dummy(std::numeric_limits<int64_t>::max(), TenantState::READY, true /* encrypted */);
state TenantMapEntry dummy(std::numeric_limits<int64_t>::max(), "name"_sr, TenantState::READY);
Optional<TenantEntryCachePayload<int64_t>> value = wait(cache->getById(dummy.id));
ASSERT(!value.present());

26
fdbserver/workloads/TenantManagementWorkload.actor.cpp
View File

@ -53,11 +53,10 @@ struct TenantManagementWorkload : TestWorkload {
int64_t id;
Optional<TenantGroupName> tenantGroup;
bool empty;
bool encrypted;
TenantData() : id(-1), empty(true) {}
TenantData(int64_t id, Optional<TenantGroupName> tenantGroup, bool empty, bool encrypted)
: id(id), tenantGroup(tenantGroup), empty(empty), encrypted(encrypted) {}
TenantData(int64_t id, Optional<TenantGroupName> tenantGroup, bool empty)
: id(id), tenantGroup(tenantGroup), empty(empty) {}
};
struct TenantGroupData {
@ -400,11 +399,6 @@ struct TenantManagementWorkload : TestWorkload {
TenantMapEntry entry;
entry.tenantGroup = self->chooseTenantGroup(true);
if (operationType == OperationType::SPECIAL_KEYS) {
entry.encrypted = SERVER_KNOBS->ENABLE_ENCRYPTION;
} else {
entry.encrypted = deterministicRandom()->coinflip();
}
if (self->createdTenants.count(tenant)) {
alreadyExists = true;
@ -534,7 +528,7 @@ struct TenantManagementWorkload : TestWorkload {
// Update our local tenant state to include the newly created one
self->maxId = entry.get().id;
self->createdTenants[tenantItr->first] =
TenantData(entry.get().id, tenantItr->second.tenantGroup, true, tenantItr->second.encrypted);
TenantData(entry.get().id, tenantItr->second.tenantGroup, true);
// If this tenant has a tenant group, create or update the entry for it
if (tenantItr->second.tenantGroup.present()) {
@ -953,19 +947,26 @@ struct TenantManagementWorkload : TestWorkload {
int64_t id;
std::string name;
std::string base64Name;
std::string printableName;
std::string prefix;
std::string base64Prefix;
std::string printablePrefix;
std::string tenantStateStr;
std::string base64TenantGroup;
std::string printableTenantGroup;
bool encrypted;
std::string assignedClusterStr;
jsonDoc.get("id", id);
jsonDoc.get("name.base64", base64Name);
jsonDoc.get("name.printable", printableName);
name = base64::decoder::from_string(base64Name);
ASSERT(name == unprintable(printableName));
jsonDoc.get("prefix.base64", base64Prefix);
jsonDoc.get("prefix.printable", printablePrefix);
jsonDoc.get("prefix.encrypted", encrypted);
prefix = base64::decoder::from_string(base64Prefix);
ASSERT(prefix == unprintable(printablePrefix));
@ -985,7 +986,7 @@ struct TenantManagementWorkload : TestWorkload {
assignedCluster = ClusterNameRef(assignedClusterStr);
}
TenantMapEntry entry(id, TenantMapEntry::stringToTenantState(tenantStateStr), tenantGroup, encrypted);
TenantMapEntry entry(id, TenantNameRef(name), TenantMapEntry::stringToTenantState(tenantStateStr), tenantGroup);
ASSERT(entry.prefix == prefix);
return entry;
}
@ -1687,7 +1688,6 @@ struct TenantManagementWorkload : TestWorkload {
ASSERT(localItr != self->createdTenants.end());
ASSERT(dataItr->first == localItr->first);
ASSERT(dataItr->second.tenantGroup == localItr->second.tenantGroup);
ASSERT(dataItr->second.encrypted == localItr->second.encrypted);
checkTenants.push_back(checkTenantContents(self, dataItr->first, localItr->second));
lastTenant = dataItr->first;