Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

more vocbase clean up (#10247)

This commit is contained in:
Jan Christoph Uhde 2019-10-15 12:05:02 +02:00 committed by Jan
parent 999ad2c0e1
commit 99a5749ab7
21 changed files with 93 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
arangod/Cluster/ClusterInfo.cpp
View File

@ -628,7 +628,7 @@ void ClusterInfo::loadPlan() {
TRI_vocbase_t* vocbase = databaseFeature.lookupDatabase(name);
if (vocbase == nullptr) {
// database does not yet exist, create it now
// create a local database object...
arangodb::CreateDatabaseInfo info(_server);
Result res = info.load(database.value, VPackSlice::emptyArraySlice());
@ -637,7 +637,7 @@ void ClusterInfo::loadPlan() {
<< "validating data for local database '" << name
<< "' failed: " << res.errorMessage();
} else {
res = databaseFeature.createDatabase(info, vocbase);
res = databaseFeature.createDatabase(std::move(info), vocbase);
if (res.fail()) {
LOG_TOPIC("91870", ERR, arangodb::Logger::AGENCY)

7
arangod/Cluster/HeartbeatThread.cpp
View File

@ -1151,16 +1151,17 @@ bool HeartbeatThread::handlePlanChangeCoordinator(uint64_t currentPlanVersion) {
// known plan IDs
ids.push_back(info.getId());
TRI_vocbase_t* vocbase = databaseFeature.useDatabase(info.getName());
auto dbName = info.getName();
TRI_vocbase_t* vocbase = databaseFeature.useDatabase(dbName);
if (vocbase == nullptr) {
// database does not yet exist, create it now
// create a local database object...
Result res = databaseFeature.createDatabase(info, vocbase);
Result res = databaseFeature.createDatabase(std::move(info), vocbase);
if (res.fail()) {
LOG_TOPIC("ca877", ERR, arangodb::Logger::HEARTBEAT)
<< "creating local database '" << info.getName()
<< "creating local database '" << dbName
<< "' failed: " << res.errorMessage();
} else {
HasRunOnce.store(true, std::memory_order_release);

38
arangod/ClusterEngine/ClusterEngine.cpp
View File

@ -204,28 +204,19 @@ VPackBuilder ClusterEngine::getReplicationApplierConfiguration(int& status) {
// database, collection and index management
// -----------------------------------------
std::unique_ptr<TRI_vocbase_t> ClusterEngine::openDatabase(arangodb::velocypack::Slice const& args,
bool isUpgrade, int& status) {
VPackSlice idSlice = args.get("id");
TRI_voc_tick_t id =
static_cast<TRI_voc_tick_t>(basics::StringUtils::uint64(idSlice.copyString()));
std::unique_ptr<TRI_vocbase_t> ClusterEngine::openDatabase(arangodb::CreateDatabaseInfo&& info,
bool isUpgrade) {
status = TRI_ERROR_NO_ERROR;
return std::make_unique<TRI_vocbase_t>(TRI_VOCBASE_TYPE_COORDINATOR, std::move(info));
return openExistingDatabase(id, args, true, isUpgrade);
}
std::unique_ptr<TRI_vocbase_t> ClusterEngine::createDatabase(
TRI_voc_tick_t id, arangodb::velocypack::Slice const& args, int& status) {
std::unique_ptr<TRI_vocbase_t> ClusterEngine::createDatabase(arangodb::CreateDatabaseInfo&& info,
int& status) {
//error lol
status = TRI_ERROR_INTERNAL;
arangodb::CreateDatabaseInfo info(server());
auto res = info.load(id, args, VPackSlice::emptyArraySlice());
if (res.fail()) {
THROW_ARANGO_EXCEPTION(res);
}
auto rv = std::make_unique<TRI_vocbase_t>(TRI_VOCBASE_TYPE_COORDINATOR, info);
auto rv = std::make_unique<TRI_vocbase_t>(TRI_VOCBASE_TYPE_COORDINATOR, std::move(info));
status = TRI_ERROR_NO_ERROR;
return rv;
}
@ -363,21 +354,6 @@ void ClusterEngine::waitForEstimatorSync(std::chrono::milliseconds maxWaitTime)
std::this_thread::sleep_for(std::chrono::seconds(5));
}
/// @brief open an existing database. internal function
std::unique_ptr<TRI_vocbase_t> ClusterEngine::openExistingDatabase(
TRI_voc_tick_t id, VPackSlice args , bool wasCleanShutdown, bool isUpgrade) {
arangodb::CreateDatabaseInfo info(server());
TRI_ASSERT(args.get("name").isString());
info.allowSystemDB(TRI_vocbase_t::IsSystemName(args.get("name").copyString()));
auto res = info.load(id, args, VPackSlice::emptyArraySlice());
if (res.fail()) {
THROW_ARANGO_EXCEPTION(res);
}
return std::make_unique<TRI_vocbase_t>(TRI_VOCBASE_TYPE_COORDINATOR, info);
}
// -----------------------------------------------------------------------------
// --SECTION-- END-OF-FILE
// -----------------------------------------------------------------------------

13
arangod/ClusterEngine/ClusterEngine.h
View File

@ -168,10 +168,9 @@ class ClusterEngine final : public StorageEngine {
}
void waitForEstimatorSync(std::chrono::milliseconds maxWaitTime) override;
virtual std::unique_ptr<TRI_vocbase_t> openDatabase(velocypack::Slice const& parameters,
bool isUpgrade, int& status) override;
std::unique_ptr<TRI_vocbase_t> createDatabase(TRI_voc_tick_t id,
velocypack::Slice const& args,
virtual std::unique_ptr<TRI_vocbase_t> openDatabase(arangodb::CreateDatabaseInfo&& info,
bool isUpgrade) override;
std::unique_ptr<TRI_vocbase_t> createDatabase(arangodb::CreateDatabaseInfo&& info,
int& status) override;
int writeCreateDatabaseMarker(TRI_voc_tick_t id, velocypack::Slice const& slice) override;
void prepareDropDatabase(TRI_vocbase_t& vocbase, bool useWriteMarker, int& status) override;
@ -243,12 +242,6 @@ class ClusterEngine final : public StorageEngine {
// noop
}
private:
/// @brief open an existing database. internal function
std::unique_ptr<TRI_vocbase_t> openExistingDatabase(TRI_voc_tick_t id,
VPackSlice args,
bool wasCleanShutdown, bool isUpgrade);
public:
static std::string const EngineName;
static std::string const FeatureName;

32
arangod/MMFiles/MMFilesEngine.cpp
View File

@ -816,32 +816,25 @@ Result MMFilesEngine::flushWal(bool waitForSync, bool waitForCollector, bool wri
writeShutdownFile);
}
std::unique_ptr<TRI_vocbase_t> MMFilesEngine::openDatabase(arangodb::velocypack::Slice const& args,
bool isUpgrade, int& status) {
VPackSlice idSlice = args.get("id");
TRI_voc_tick_t id =
static_cast<TRI_voc_tick_t>(basics::StringUtils::uint64(idSlice.copyString()));
std::unique_ptr<TRI_vocbase_t> MMFilesEngine::openDatabase(arangodb::CreateDatabaseInfo&& info,
bool isUpgrade) {
bool const wasCleanShutdown = MMFilesLogfileManager::hasFoundLastTick();
status = TRI_ERROR_NO_ERROR;
return openExistingDatabase(id, args, wasCleanShutdown, isUpgrade);
return openExistingDatabase(std::move(info), wasCleanShutdown, isUpgrade);
}
std::unique_ptr<TRI_vocbase_t> MMFilesEngine::createDatabaseMMFiles(
TRI_voc_tick_t id, arangodb::velocypack::Slice const& data) {
std::unique_ptr<TRI_vocbase_t> MMFilesEngine::createDatabaseMMFiles(arangodb::CreateDatabaseInfo&& info) {
int res = 0;
waitUntilDeletion(id, true, res);
waitUntilDeletion(info.getId(), true, res);
std::string const name = data.get("name").copyString();
res = createDatabaseDirectory(id, name);
res = createDatabaseDirectory(info.getId(), info.getName());
if (res != TRI_ERROR_NO_ERROR) {
THROW_ARANGO_EXCEPTION(res);
}
return openExistingDatabase(id, data, true, false);
return openExistingDatabase(std::move(info), true, false);
}
void MMFilesEngine::prepareDropDatabase(TRI_vocbase_t& vocbase,
@ -2016,16 +2009,9 @@ std::string MMFilesEngine::indexFilename(TRI_idx_iid_t id) const {
/// @brief open an existing database. internal function
std::unique_ptr<TRI_vocbase_t> MMFilesEngine::openExistingDatabase(
TRI_voc_tick_t id, VPackSlice args, bool wasCleanShutdown, bool isUpgrade) {
arangodb::CreateDatabaseInfo info(server());
TRI_ASSERT(args.get("name").isString());
info.allowSystemDB(TRI_vocbase_t::IsSystemName(args.get("name").copyString()));
auto rv = info.load(id, args, VPackSlice::emptyArraySlice());
if (rv.fail()) {
THROW_ARANGO_EXCEPTION(rv);
}
arangodb::CreateDatabaseInfo&& info, bool wasCleanShutdown, bool isUpgrade) {
auto vocbase = std::make_unique<TRI_vocbase_t>(TRI_VOCBASE_TYPE_NORMAL, info);
auto vocbase = std::make_unique<TRI_vocbase_t>(TRI_VOCBASE_TYPE_NORMAL, std::move(info));
// scan the database path for views
try {

18
arangod/MMFiles/MMFilesEngine.h
View File

@ -171,13 +171,13 @@ class MMFilesEngine final : public StorageEngine {
void waitForEstimatorSync(std::chrono::milliseconds maxWaitTime) override {}
virtual std::unique_ptr<TRI_vocbase_t> openDatabase(arangodb::velocypack::Slice const& parameters,
bool isUpgrade, int&) override;
std::unique_ptr<TRI_vocbase_t> createDatabase(TRI_voc_tick_t id,
velocypack::Slice const& args,
virtual std::unique_ptr<TRI_vocbase_t> openDatabase(arangodb::CreateDatabaseInfo&& ,
bool isUpgrade) override;
std::unique_ptr<TRI_vocbase_t> createDatabase(arangodb::CreateDatabaseInfo&& info,
int& status) override {
status = TRI_ERROR_NO_ERROR;
return createDatabaseMMFiles(id, args);
status = TRI_ERROR_NO_ERROR; //lol
return createDatabaseMMFiles(std::move(info));
}
int writeCreateDatabaseMarker(TRI_voc_tick_t id, VPackSlice const& slice) override;
@ -206,8 +206,7 @@ class MMFilesEngine final : public StorageEngine {
private:
int dropDatabaseMMFiles(TRI_vocbase_t* vocbase);
std::unique_ptr<TRI_vocbase_t> createDatabaseMMFiles(TRI_voc_tick_t id,
velocypack::Slice const& data);
std::unique_ptr<TRI_vocbase_t> createDatabaseMMFiles(arangodb::CreateDatabaseInfo&&);
public:
// asks the storage engine to create a collection as specified in the VPack
@ -412,8 +411,7 @@ class MMFilesEngine final : public StorageEngine {
std::string indexFilename(TRI_idx_iid_t indexId) const;
/// @brief open an existing database. internal function
std::unique_ptr<TRI_vocbase_t> openExistingDatabase(TRI_voc_tick_t id,
VPackSlice args,
std::unique_ptr<TRI_vocbase_t> openExistingDatabase(arangodb::CreateDatabaseInfo&&,
bool wasCleanShutdown, bool isUpgrade);
/// @brief note the maximum local tick

2
arangod/MMFiles/MMFilesWalRecoverState.cpp
View File

@ -1226,7 +1226,7 @@ bool MMFilesWalRecoverState::ReplayMarker(MMFilesMarker const* marker,
THROW_ARANGO_EXCEPTION(res);
}
res = state->databaseFeature.createDatabase(info, vocbase);
res = state->databaseFeature.createDatabase(std::move(info), vocbase);
if (res.fail()) {
LOG_TOPIC("9c045", WARN, arangodb::Logger::ENGINES)

2
arangod/RestHandler/RestAdminServerHandler.cpp
View File

@ -215,7 +215,7 @@ void RestAdminServerHandler::handleDatabaseDefaults() {
auto defaults = getVocbaseOptions(server(), VPackSlice::emptyObjectSlice());
VPackBuilder builder;
builder.openObject();
addVocbaseReplicationOptionsToOpenObject(builder, defaults);
addClusterOptions(builder, defaults);
builder.close();
generateResult(rest::ResponseCode::OK, builder.slice());
}

32
arangod/RestServer/DatabaseFeature.cpp
View File

@ -595,9 +595,15 @@ Result DatabaseFeature::registerPostRecoveryCallback(std::function<Result()>&& c
}
/// @brief create a new database
Result DatabaseFeature::createDatabase(CreateDatabaseInfo const& info, TRI_vocbase_t*& result){
Result DatabaseFeature::createDatabase(CreateDatabaseInfo&& info, TRI_vocbase_t*& result){
std::string name = info.getName();
auto dbId = info.getId();
VPackBuilder markerBuilder;
{
VPackObjectBuilder guard(&markerBuilder);
info.toVelocyPack(markerBuilder); // can we improve this
}
result = nullptr;
if (!TRI_vocbase_t::IsAllowedName(false, arangodb::velocypack::StringRef(name))) {
@ -606,8 +612,6 @@ Result DatabaseFeature::createDatabase(CreateDatabaseInfo const& info, TRI_vocba
}
std::unique_ptr<TRI_vocbase_t> vocbase;
// a new builder is created to prevent blind copying of options
VPackBuilder builder;
// create database in storage engine
StorageEngine* engine = EngineSelectorFeature::ENGINE;
@ -632,14 +636,7 @@ Result DatabaseFeature::createDatabase(CreateDatabaseInfo const& info, TRI_vocba
// createDatabase must return a valid database or throw
int status = TRI_ERROR_NO_ERROR;
// TODO -- use info directly
{
VPackObjectBuilder guard(&builder);
info.toVelocyPack(builder);
}
TRI_ASSERT(builder.slice().isObject());
vocbase = engine->createDatabase(info.getId(), builder.slice(), status);
vocbase = engine->createDatabase(std::move(info), status);
TRI_ASSERT(status == TRI_ERROR_NO_ERROR);
TRI_ASSERT(vocbase != nullptr);
@ -715,7 +712,7 @@ Result DatabaseFeature::createDatabase(CreateDatabaseInfo const& info, TRI_vocba
int res = TRI_ERROR_NO_ERROR;
if (!engine->inRecovery()) {
res = engine->writeCreateDatabaseMarker(info.getId(), builder.slice());
res = engine->writeCreateDatabaseMarker(dbId, markerBuilder.slice());
}
result = vocbase.release();
@ -1269,7 +1266,13 @@ int DatabaseFeature::iterateDatabases(VPackSlice const& databases) {
// open the database and scan collections in it
// try to open this database
auto* database = engine->openDatabase(it, _upgrade).release();
arangodb::CreateDatabaseInfo info(server());
info.allowSystemDB(true);
auto res = info.load(it, VPackSlice::emptyArraySlice());
if(res.fail()){
THROW_ARANGO_EXCEPTION(res);
}
auto database = engine->openDatabase(std::move(info), _upgrade);
if (!ServerState::isCoordinator(role) && !ServerState::isAgent(role)) {
try {
@ -1282,7 +1285,8 @@ int DatabaseFeature::iterateDatabases(VPackSlice const& databases) {
}
}
newLists->_databases.insert(std::make_pair(database->name(), database));
newLists->_databases.insert(std::make_pair(database->name(), database.get()));
database.release();
}
} catch (std::exception const& ex) {
delete newLists;

2
arangod/RestServer/DatabaseFeature.h
View File

@ -113,7 +113,7 @@ class DatabaseFeature : public application_features::ApplicationFeature {
std::vector<std::string> getDatabaseNames();
std::vector<std::string> getDatabaseNamesForUser(std::string const& user);
Result createDatabase(arangodb::CreateDatabaseInfo const& , TRI_vocbase_t*& result);
Result createDatabase(arangodb::CreateDatabaseInfo&& , TRI_vocbase_t*& result);
int dropDatabase(std::string const& name, bool waitForDeletion, bool removeAppsDirectory);
int dropDatabase(TRI_voc_tick_t id, bool waitForDeletion, bool removeAppsDirectory);

35
arangod/RocksDBEngine/RocksDBEngine.cpp
View File

@ -1148,29 +1148,16 @@ int RocksDBEngine::saveReplicationApplierConfiguration(RocksDBKey const& key,
// database, collection and index management
// -----------------------------------------
std::unique_ptr<TRI_vocbase_t> RocksDBEngine::openDatabase(arangodb::velocypack::Slice const& args,
bool isUpgrade, int& status) {
VPackSlice idSlice = args.get("id");
TRI_voc_tick_t id =
static_cast<TRI_voc_tick_t>(basics::StringUtils::uint64(idSlice.copyString()));
status = TRI_ERROR_NO_ERROR;
return openExistingDatabase(id, args, true, isUpgrade);
std::unique_ptr<TRI_vocbase_t> RocksDBEngine::openDatabase(arangodb::CreateDatabaseInfo && info,
bool isUpgrade) {
return openExistingDatabase(std::move(info), true, isUpgrade);
}
// TODO -- should take info
std::unique_ptr<TRI_vocbase_t> RocksDBEngine::createDatabase(
TRI_voc_tick_t id, arangodb::velocypack::Slice const& args, int& status) {
status = TRI_ERROR_INTERNAL;
arangodb::CreateDatabaseInfo info(server());
auto rv = info.load(id, args, VPackSlice::emptyArraySlice());
if (rv.fail()) {
THROW_ARANGO_EXCEPTION(rv);
}
arangodb::CreateDatabaseInfo&& info, int& status) {
status = TRI_ERROR_NO_ERROR;
return std::make_unique<TRI_vocbase_t>(TRI_VOCBASE_TYPE_NORMAL, info);
return std::make_unique<TRI_vocbase_t>(TRI_VOCBASE_TYPE_NORMAL, std::move(info));
}
int RocksDBEngine::writeCreateDatabaseMarker(TRI_voc_tick_t id, VPackSlice const& slice) {
@ -2068,17 +2055,9 @@ void RocksDBEngine::addSystemDatabase() {
/// @brief open an existing database. internal function
std::unique_ptr<TRI_vocbase_t> RocksDBEngine::openExistingDatabase(
TRI_voc_tick_t id, VPackSlice args, bool wasCleanShutdown, bool isUpgrade) {
arangodb::CreateDatabaseInfo info(server());
TRI_ASSERT(args.get("name").isString());
// when loading we allow system database names
info.allowSystemDB(TRI_vocbase_t::IsSystemName(args.get("name").copyString()));
auto res = info.load(id, args, VPackSlice::emptyArraySlice());
if (res.fail()) {
THROW_ARANGO_EXCEPTION(res);
}
arangodb::CreateDatabaseInfo&& info, bool wasCleanShutdown, bool isUpgrade) {
auto vocbase = std::make_unique<TRI_vocbase_t>(TRI_VOCBASE_TYPE_NORMAL, info);
auto vocbase = std::make_unique<TRI_vocbase_t>(TRI_VOCBASE_TYPE_NORMAL, std::move(info));
// scan the database path for views
try {

10
arangod/RocksDBEngine/RocksDBEngine.h
View File

@ -221,10 +221,9 @@ class RocksDBEngine final : public StorageEngine {
Result flushWal(bool waitForSync, bool waitForCollector, bool writeShutdownFile) override;
void waitForEstimatorSync(std::chrono::milliseconds maxWaitTime) override;
virtual std::unique_ptr<TRI_vocbase_t> openDatabase(velocypack::Slice const& args,
bool isUpgrade, int& status) override;
std::unique_ptr<TRI_vocbase_t> createDatabase(TRI_voc_tick_t id,
velocypack::Slice const& args,
virtual std::unique_ptr<TRI_vocbase_t> openDatabase(arangodb::CreateDatabaseInfo&& info,
bool isUpgrade) override;
std::unique_ptr<TRI_vocbase_t> createDatabase(arangodb::CreateDatabaseInfo&&,
int& status) override;
int writeCreateDatabaseMarker(TRI_voc_tick_t id, velocypack::Slice const& slice) override;
void prepareDropDatabase(TRI_vocbase_t& vocbase, bool useWriteMarker, int& status) override;
@ -338,8 +337,7 @@ class RocksDBEngine final : public StorageEngine {
bool systemDatabaseExists();
void addSystemDatabase();
/// @brief open an existing database. internal function
std::unique_ptr<TRI_vocbase_t> openExistingDatabase(TRI_voc_tick_t id,
VPackSlice args,
std::unique_ptr<TRI_vocbase_t> openExistingDatabase(arangodb::CreateDatabaseInfo&& info,
bool wasCleanShutdown, bool isUpgrade);
std::string getCompressionSupport() const;

20
arangod/StorageEngine/StorageEngine.h
View File

@ -186,15 +186,8 @@ class StorageEngine : public application_features::ApplicationFeature {
//// operations on databases
/// @brief opens a database
virtual std::unique_ptr<TRI_vocbase_t> openDatabase(arangodb::velocypack::Slice const& args,
bool isUpgrade, int& status) = 0;
std::unique_ptr<TRI_vocbase_t> openDatabase(velocypack::Slice const& args, bool isUpgrade) {
int status;
auto rv = openDatabase(args, isUpgrade, status);
TRI_ASSERT(status == TRI_ERROR_NO_ERROR);
TRI_ASSERT(rv != nullptr);
return rv;
}
virtual std::unique_ptr<TRI_vocbase_t> openDatabase(arangodb::CreateDatabaseInfo&& info,
bool isUpgrade) = 0;
// asks the storage engine to create a database as specified in the VPack
// Slice object and persist the creation info. It is guaranteed by the server
@ -204,8 +197,7 @@ class StorageEngine : public application_features::ApplicationFeature {
// then, so that subsequent database creation requests will not fail. the WAL
// entry for the database creation will be written *after* the call to
// "createDatabase" returns no way to acquire id within this function?!
virtual std::unique_ptr<TRI_vocbase_t> createDatabase(TRI_voc_tick_t id,
velocypack::Slice const& args,
virtual std::unique_ptr<TRI_vocbase_t> createDatabase(arangodb::CreateDatabaseInfo&&,
int& status) = 0;
// @brief write create marker for database
@ -397,13 +389,13 @@ class StorageEngine : public application_features::ApplicationFeature {
builder.add("name", velocypack::Value(typeName()));
builder.add("supports", velocypack::Value(VPackValueType::Object));
builder.add("dfdb", velocypack::Value(supportsDfdb()));
builder.add("indexes", velocypack::Value(VPackValueType::Array));
for (auto const& it : indexFactory().supportedIndexes()) {
builder.add(velocypack::Value(it));
}
builder.close(); // indexes
builder.add("aliases", velocypack::Value(VPackValueType::Object));
builder.add("indexes", velocypack::Value(VPackValueType::Object));
for (auto const& it : indexFactory().indexAliases()) {
@ -411,7 +403,7 @@ class StorageEngine : public application_features::ApplicationFeature {
}
builder.close(); // indexes
builder.close(); // aliases
builder.close(); // supports
builder.close(); // object
}

6
arangod/VocBase/Methods/Databases.cpp
View File

@ -216,7 +216,8 @@ Result Databases::createCoordinator(CreateDatabaseInfo const& info) {
// This vocbase is needed for the call to methods::Upgrade::createDB, but
// is just a placeholder
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, info);
CreateDatabaseInfo tmp_info = info;
TRI_vocbase_t vocbase(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, std::move(tmp_info));
// Now create *all* system collections for the database,
// if any of these fail, database creation is considered unsuccessful
@ -255,7 +256,8 @@ Result Databases::createOther(CreateDatabaseInfo const& info) {
DatabaseFeature& databaseFeature = info.server().getFeature<DatabaseFeature>();
TRI_vocbase_t* vocbase = nullptr;
Result createResult = databaseFeature.createDatabase(info, vocbase);
auto tmp_info = info;
Result createResult = databaseFeature.createDatabase(std::move(tmp_info), vocbase);
if (createResult.fail()) {
return createResult;
}

8
arangod/VocBase/VocbaseInfo.cpp
View File

@ -137,7 +137,7 @@ void CreateDatabaseInfo::toVelocyPack(VPackBuilder& builder, bool withUsers) con
builder.add(StaticStrings::DataSourceSystem, VPackValue(_isSystemDB));
if (ServerState::instance()->isCoordinator()) {
addVocbaseReplicationOptionsToOpenObject(builder, _sharding, _replicationFactor, _writeConcern);
addClusterOptions(builder, _sharding, _replicationFactor, _writeConcern);
}
if (withUsers) {
@ -364,7 +364,7 @@ VocbaseOptions getVocbaseOptions(application_features::ApplicationServer& server
return vocbaseOptions;
}
void addVocbaseReplicationOptionsToOpenObject(VPackBuilder& builder, std::string const& sharding,
void addClusterOptions(VPackBuilder& builder, std::string const& sharding,
std::uint32_t replicationFactor,
std::uint32_t writeConcern) {
TRI_ASSERT(builder.isOpenObject());
@ -377,8 +377,8 @@ void addVocbaseReplicationOptionsToOpenObject(VPackBuilder& builder, std::string
builder.add(StaticStrings::MinReplicationFactor, VPackValue(writeConcern));
}
void addVocbaseReplicationOptionsToOpenObject(VPackBuilder& builder, VocbaseOptions const& opt) {
addVocbaseReplicationOptionsToOpenObject(builder, opt.sharding, opt.replicationFactor,
void addClusterOptions(VPackBuilder& builder, VocbaseOptions const& opt) {
addClusterOptions(builder, opt.sharding, opt.replicationFactor,
opt.writeConcern);
}
} // namespace arangodb

4
arangod/VocBase/VocbaseInfo.h
View File

@ -152,10 +152,10 @@ struct VocbaseOptions {
VocbaseOptions getVocbaseOptions(application_features::ApplicationServer&, velocypack::Slice const&);
void addVocbaseReplicationOptionsToOpenObject(velocypack::Builder& builder, std::string const& sharding,
void addClusterOptions(velocypack::Builder& builder, std::string const& sharding,
std::uint32_t replicationFactor,
std::uint32_t writeConcern);
void addVocbaseReplicationOptionsToOpenObject(velocypack::Builder&, VocbaseOptions const&);
void addClusterOptions(velocypack::Builder&, VocbaseOptions const&);
} // namespace arangodb
#endif

26
arangod/VocBase/vocbase.cpp
View File

@ -1703,32 +1703,6 @@ arangodb::Result TRI_vocbase_t::dropView(TRI_voc_cid_t cid, bool allowDropSystem
return TRI_ERROR_NO_ERROR;
}
/// todo add tick od
/// @brief create a vocbase object
TRI_vocbase_t::TRI_vocbase_t(TRI_vocbase_type_e type,
arangodb::CreateDatabaseInfo const& info)
: _server(info.server()),
_info(info),
_type(type),
_refCount(0),
_state(TRI_vocbase_t::State::NORMAL),
_isOwnAppsDirectory(true),
_deadlockDetector(false),
_userStructures(nullptr) {
QueryRegistryFeature& feature = info.server().getFeature<QueryRegistryFeature>();
_queries.reset(new arangodb::aql::QueryList(feature, this));
_cursorRepository.reset(new arangodb::CursorRepository(*this));
_collectionKeys.reset(new arangodb::CollectionKeysRepository());
_replicationClients.reset(new arangodb::ReplicationClientsProgressTracker());
// init collections
_collections.reserve(32);
_deadCollections.reserve(32);
TRI_CreateUserStructuresVocBase(this);
}
TRI_vocbase_t::TRI_vocbase_t(TRI_vocbase_type_e type,
arangodb::CreateDatabaseInfo&& info)
: _server(info.server()),

1
arangod/VocBase/vocbase.h
View File

@ -138,7 +138,6 @@ struct TRI_vocbase_t {
/// @brief database state
enum class State { NORMAL = 0, SHUTDOWN_COMPACTOR = 1, SHUTDOWN_CLEANUP = 2 };
TRI_vocbase_t(TRI_vocbase_type_e type, arangodb::CreateDatabaseInfo const&);
TRI_vocbase_t(TRI_vocbase_type_e type, arangodb::CreateDatabaseInfo&&);
TEST_VIRTUAL ~TRI_vocbase_t();

2
tests/IResearch/IResearchView-test.cpp
View File

@ -999,7 +999,7 @@ TEST_F(IResearchViewTest, test_drop_database) {
TRI_vocbase_t* vocbase; // will be owned by DatabaseFeature
arangodb::CreateDatabaseInfo testDBInfo(server.server());
testDBInfo.load("testDatabase" TOSTRING(__LINE__), 3);
ASSERT_TRUE(databaseFeature.createDatabase(testDBInfo, vocbase).ok());
ASSERT_TRUE(databaseFeature.createDatabase(std::move(testDBInfo), vocbase).ok());
ASSERT_TRUE((nullptr != vocbase));
beforeCount = 0; // reset before call to StorageEngine::createView(...)

35
tests/Mocks/StorageEngineMock.cpp
View File

@ -997,20 +997,12 @@ std::string StorageEngineMock::createCollection(TRI_vocbase_t& vocbase,
}
std::unique_ptr<TRI_vocbase_t> StorageEngineMock::createDatabase(
TRI_voc_tick_t id, arangodb::velocypack::Slice const& args, int& status) {
if (!args.get("name").isString()) {
status = TRI_ERROR_BAD_PARAMETER;
}
status = TRI_ERROR_NO_ERROR;
arangodb::CreateDatabaseInfo info(server());
info.load(id, args, VPackSlice::emptyArraySlice());
arangodb::CreateDatabaseInfo&& info, int& status) {
if (arangodb::ServerState::instance()->isCoordinator()) {
return std::make_unique<TRI_vocbase_t>(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_COORDINATOR, info);
return std::make_unique<TRI_vocbase_t>(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_COORDINATOR, std::move(info));
}
return std::make_unique<TRI_vocbase_t>(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, info);
return std::make_unique<TRI_vocbase_t>(TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL, std::move(info));
}
arangodb::Result StorageEngineMock::createLoggerState(TRI_vocbase_t*, VPackBuilder&) {
@ -1216,28 +1208,15 @@ arangodb::Result StorageEngineMock::lastLogger(
}
std::unique_ptr<TRI_vocbase_t> StorageEngineMock::openDatabase(
arangodb::velocypack::Slice const& args, bool isUpgrade, int& status) {
arangodb::CreateDatabaseInfo&& info, bool isUpgrade) {
before();
if (!args.isObject() || !args.hasKey("name") || !args.get("name").isString()) {
status = TRI_ERROR_ARANGO_DATABASE_NAME_INVALID;
return nullptr;
}
status = TRI_ERROR_NO_ERROR;
arangodb::CreateDatabaseInfo info(server());
info.allowSystemDB(true);
auto rv = info.load(++vocbaseCount, args, VPackSlice::emptyArraySlice());
if(rv.fail()) {
THROW_ARANGO_EXCEPTION(rv);
}
auto new_info = info;
new_info.setId(++vocbaseCount);
return std::make_unique<TRI_vocbase_t>(
TRI_vocbase_type_e::TRI_VOCBASE_TYPE_NORMAL,
info
std::move(new_info)
);
}

9
tests/Mocks/StorageEngineMock.h
View File

@ -75,7 +75,7 @@ class PhysicalCollectionMock: public arangodb::PhysicalCollection {
arangodb::OperationOptions& options, bool lock,
arangodb::KeyLockInfo* /*keyLockInfo*/,
std::function<void()> const& callbackDuringLock) override;
virtual arangodb::LocalDocumentId lookupKey(arangodb::transaction::Methods*,
arangodb::velocypack::Slice const&) const override;
virtual size_t memory() const override;
@ -180,8 +180,7 @@ class StorageEngineMock: public arangodb::StorageEngine {
virtual std::string collectionPath(TRI_vocbase_t const& vocbase, TRI_voc_cid_t id) const override;
virtual std::string createCollection(TRI_vocbase_t& vocbase,
arangodb::LogicalCollection const& collection) override;
virtual std::unique_ptr<TRI_vocbase_t> createDatabase(TRI_voc_tick_t id,
arangodb::velocypack::Slice const& args,
virtual std::unique_ptr<TRI_vocbase_t> createDatabase(arangodb::CreateDatabaseInfo&&,
int& status) override;
virtual arangodb::Result createLoggerState(TRI_vocbase_t*, VPackBuilder&) override;
virtual std::unique_ptr<arangodb::PhysicalCollection> createPhysicalCollection(
@ -237,8 +236,8 @@ class StorageEngineMock: public arangodb::StorageEngine {
std::shared_ptr<arangodb::transaction::Context> transactionContext,
uint64_t tickStart, uint64_t tickEnd,
std::shared_ptr<VPackBuilder>& builderSPtr) override;
virtual std::unique_ptr<TRI_vocbase_t> openDatabase(arangodb::velocypack::Slice const& args,
bool isUpgrade, int& status) override;
virtual std::unique_ptr<TRI_vocbase_t> openDatabase(arangodb::CreateDatabaseInfo && ,
bool isUpgrade) override;
virtual arangodb::Result persistCollection(TRI_vocbase_t& vocbase,
arangodb::LogicalCollection const& collection) override;
virtual void prepareDropDatabase(TRI_vocbase_t& vocbase, bool useWriteMarker,