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

moved all database management functions into DatabaseFeature

This commit is contained in:
jsteemann 2016-07-25 15:48:37 +02:00
parent 33c94e5041
commit a0f0055b6f
25 changed files with 93 additions and 347 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
arangod/Agency/Agent.h
View File

@ -32,7 +32,6 @@
#include "Agency/State.h"
#include "Agency/Store.h"
struct TRI_server_t;
struct TRI_vocbase_t;
namespace arangodb {
@ -137,9 +136,6 @@ class Agent : public arangodb::Thread {
private:
Agent& operator=(VPackSlice const&);
/// @brief This server (need endpoint)
TRI_server_t* _server;
/// @brief Vocbase for agency persistence
TRI_vocbase_t* _vocbase;

3
arangod/Cluster/ClusterFeature.cpp
View File

@ -398,8 +398,7 @@ void ClusterFeature::start() {
}
// start heartbeat thread
_heartbeatThread = new HeartbeatThread(DatabaseFeature::SERVER,
_agencyCallbackRegistry.get(),
_heartbeatThread = new HeartbeatThread(_agencyCallbackRegistry.get(),
_heartbeatInterval * 1000, 5);
if (!_heartbeatThread->init() || !_heartbeatThread->start()) {

5
arangod/Cluster/HeartbeatThread.cpp
View File

@ -45,7 +45,6 @@
#include "RestServer/DatabaseFeature.h"
#include "V8/v8-globals.h"
#include "VocBase/AuthInfo.h"
#include "VocBase/server.h"
#include "VocBase/vocbase.h"
using namespace arangodb;
@ -56,12 +55,10 @@ std::atomic<bool> HeartbeatThread::HasRunOnce(false);
/// @brief constructs a heartbeat thread
////////////////////////////////////////////////////////////////////////////////
HeartbeatThread::HeartbeatThread(TRI_server_t* server,
AgencyCallbackRegistry* agencyCallbackRegistry,
HeartbeatThread::HeartbeatThread(AgencyCallbackRegistry* agencyCallbackRegistry,
uint64_t interval,
uint64_t maxFailsBeforeWarning)
: Thread("Heartbeat"),
_server(server),
_agencyCallbackRegistry(agencyCallbackRegistry),
_statusLock(),
_agency(),

8
arangod/Cluster/HeartbeatThread.h
View File

@ -32,7 +32,6 @@
#include "Cluster/DBServerAgencySync.h"
#include "Logger/Logger.h"
struct TRI_server_t;
struct TRI_vocbase_t;
namespace arangodb {
@ -56,7 +55,7 @@ class HeartbeatThread : public Thread {
HeartbeatThread& operator=(HeartbeatThread const&) = delete;
public:
HeartbeatThread(TRI_server_t*, AgencyCallbackRegistry*, uint64_t, uint64_t);
HeartbeatThread(AgencyCallbackRegistry*, uint64_t, uint64_t);
~HeartbeatThread();
public:
@ -143,11 +142,6 @@ class HeartbeatThread : public Thread {
bool syncDBServerStatusQuo();
private:
//////////////////////////////////////////////////////////////////////////////
/// @brief server
//////////////////////////////////////////////////////////////////////////////
TRI_server_t* _server;
//////////////////////////////////////////////////////////////////////////////
/// @brief AgencyCallbackRegistry

25
arangod/RestServer/CheckVersionFeature.cpp
View File

@ -73,11 +73,11 @@ void CheckVersionFeature::validateOptions(
ApplicationServer::getFeature<LoggerFeature>("Logger");
logger->disableThreaded();
DatabaseFeature* database =
DatabaseFeature* databaseFeature =
ApplicationServer::getFeature<DatabaseFeature>("Database");
database->disableReplicationApplier();
database->disableCompactor();
database->enableCheckVersion();
databaseFeature->disableReplicationApplier();
databaseFeature->disableCompactor();
databaseFeature->enableCheckVersion();
V8DealerFeature* v8dealer =
ApplicationServer::getFeature<V8DealerFeature>("V8Dealer");
@ -133,17 +133,15 @@ void CheckVersionFeature::checkVersion() {
LOG(DEBUG) << "running database version check";
// can do this without a lock as this is the startup
auto server = DatabaseFeature::SERVER;
auto unuser = server->_databasesProtector.use();
auto theLists = server->_databasesLists.load();
DatabaseFeature* databaseFeature = application_features::ApplicationServer::getFeature<DatabaseFeature>("Database");
for (auto& p : theLists->_databases) {
TRI_vocbase_t* vocbase = p.second;
for (auto& name : databaseFeature->getDatabaseNames()) {
TRI_vocbase_t* vocbase = databaseFeature->lookupDatabase(name);
TRI_ASSERT(vocbase != nullptr);
// special check script to be run just once in first thread (not in
// all)
// but for all databases
// all) but for all databases
int status = TRI_CheckDatabaseVersion(vocbase, localContext);
LOG(DEBUG) << "version check return status " << status;
@ -162,8 +160,7 @@ void CheckVersionFeature::checkVersion() {
}
// issue #391: when invoked with --database.auto-upgrade, the server will
// not always shut
// down
// not always shut down
localContext->Exit();
}
}

75
arangod/RestServer/DatabaseFeature.cpp
View File

@ -62,8 +62,6 @@ using namespace arangodb::application_features;
using namespace arangodb::basics;
using namespace arangodb::options;
TRI_server_t* DatabaseFeature::SERVER = nullptr;
uint32_t const DatabaseFeature::DefaultIndexBuckets = 8;
DatabaseFeature* DatabaseFeature::DATABASE = nullptr;
@ -227,7 +225,6 @@ DatabaseFeature::DatabaseFeature(ApplicationServer* server)
_forceSyncProperties(true),
_ignoreDatafileErrors(false),
_throwCollectionNotLoadedError(false),
_server(),
_vocbase(nullptr),
_queryRegistry(nullptr),
_databaseManager(nullptr),
@ -248,16 +245,6 @@ DatabaseFeature::DatabaseFeature(ApplicationServer* server)
}
DatabaseFeature::~DatabaseFeature() {
delete _databaseManager;
try {
// closeOpenDatabases() can throw, but we're in a dtor
closeOpenDatabases();
} catch (...) {
}
auto p = _databasesLists.load();
delete p;
}
void DatabaseFeature::collectOptions(std::shared_ptr<ProgramOptions> options) {
@ -315,9 +302,6 @@ void DatabaseFeature::validateOptions(std::shared_ptr<ProgramOptions> options) {
}
void DatabaseFeature::prepare() {
// create the server
_server.reset(new TRI_server_t()); // TODO
SERVER = _server.get();
}
void DatabaseFeature::start() {
@ -393,10 +377,53 @@ void DatabaseFeature::unprepare() {
// we're in the shutdown... simply ignore any errors produced here
}
delete _databaseManager;
try {
// closeOpenDatabases() can throw, but we're in a dtor
closeOpenDatabases();
} catch (...) {
}
auto p = _databasesLists.load();
delete p;
// clear singleton
DATABASE = nullptr;
SERVER = nullptr;
_server.reset(nullptr);
}
int DatabaseFeature::recoveryDone() {
auto unuser(_databasesProtector.use());
auto theLists = _databasesLists.load();
for (auto& p : theLists->_databases) {
TRI_vocbase_t* vocbase = p.second;
// iterate over all databases
TRI_ASSERT(vocbase != nullptr);
TRI_ASSERT(vocbase->_type == TRI_VOCBASE_TYPE_NORMAL);
// start the compactor for the database
TRI_StartCompactorVocBase(vocbase);
// start the replication applier
TRI_ASSERT(vocbase->_replicationApplier != nullptr);
if (vocbase->_replicationApplier->_configuration._autoStart) {
if (!_replicationApplier) {
LOG(INFO) << "replication applier explicitly deactivated for database '"
<< vocbase->_name << "'";
} else {
int res = vocbase->_replicationApplier->start(0, false, 0);
if (res != TRI_ERROR_NO_ERROR) {
LOG(WARN) << "unable to start replication applier for database '"
<< vocbase->_name << "': " << TRI_errno_string(res);
}
}
}
}
return TRI_ERROR_NO_ERROR;
}
/// @brief create a new database
@ -905,19 +932,15 @@ void DatabaseFeature::updateContexts() {
auto queryRegistry = QueryRegistryFeature::QUERY_REGISTRY;
TRI_ASSERT(queryRegistry != nullptr);
auto server = DatabaseFeature::SERVER;
TRI_ASSERT(server != nullptr);
auto vocbase = _vocbase;
V8DealerFeature* dealer =
ApplicationServer::getFeature<V8DealerFeature>("V8Dealer");
dealer->defineContextUpdate(
[queryRegistry, server, vocbase](
[queryRegistry, vocbase](
v8::Isolate* isolate, v8::Handle<v8::Context> context, size_t i) {
TRI_InitV8VocBridge(isolate, context, queryRegistry, server, vocbase,
i);
TRI_InitV8VocBridge(isolate, context, queryRegistry, vocbase, i);
TRI_InitV8Queries(isolate, context);
TRI_InitV8Cluster(isolate, context);
},
@ -925,8 +948,8 @@ void DatabaseFeature::updateContexts() {
}
void DatabaseFeature::shutdownCompactor() {
auto unuser = DatabaseFeature::SERVER->_databasesProtector.use();
auto theLists = DatabaseFeature::SERVER->_databasesLists.load();
auto unuser = _databasesProtector.use();
auto theLists = _databasesLists.load();
for (auto& p : theLists->_databases) {
TRI_vocbase_t* vocbase = p.second;

9
arangod/RestServer/DatabaseFeature.h
View File

@ -33,7 +33,6 @@
#include <velocypack/Slice.h>
struct TRI_vocbase_t;
struct TRI_server_t;
namespace arangodb {
class DatabaseManagerThread;
@ -76,6 +75,8 @@ class DatabaseFeature final : public application_features::ApplicationFeature {
void start() override final;
void unprepare() override final;
int recoveryDone();
public:
/// @brief get the ids of all local coordinator databases
std::vector<TRI_voc_tick_t> getDatabaseIdsCoordinator(bool includeSystem);
@ -113,9 +114,6 @@ class DatabaseFeature final : public application_features::ApplicationFeature {
void enableCheckVersion() { _checkVersion = true; }
void enableUpgrade() { _upgrade = true; }
public:
static TRI_server_t* SERVER;
private:
void closeDatabases();
void updateContexts();
@ -154,12 +152,11 @@ class DatabaseFeature final : public application_features::ApplicationFeature {
bool _ignoreDatafileErrors;
bool _throwCollectionNotLoadedError;
std::unique_ptr<TRI_server_t> _server; // TODO
TRI_vocbase_t* _vocbase;
std::atomic<arangodb::aql::QueryRegistry*> _queryRegistry; // TODO
DatabaseManagerThread* _databaseManager;
std::atomic<DatabasesLists*> _databasesLists; // TODO
std::atomic<DatabasesLists*> _databasesLists;
// TODO: Make this again a template once everybody has gcc >= 4.9.2
// arangodb::basics::DataProtector<64>
arangodb::basics::DataProtector _databasesProtector;

5
arangod/RestServer/QueryRegistryFeature.cpp
View File

@ -26,7 +26,6 @@
#include "Aql/QueryRegistry.h"
#include "ProgramOptions/ProgramOptions.h"
#include "ProgramOptions/Section.h"
#include "RestServer/DatabaseFeature.h"
#include "VocBase/server.h"
using namespace arangodb;
@ -93,11 +92,9 @@ void QueryRegistryFeature::prepare() {
}
void QueryRegistryFeature::start() {
DatabaseFeature::SERVER->_queryRegistry = _queryRegistry.get();
}
void QueryRegistryFeature::unprepare() {
// clear the query registery
DatabaseFeature::SERVER->_queryRegistry = nullptr;
// TODO: reset QUERY_REGISTRY as well?
QUERY_REGISTRY = nullptr;
}

11
arangod/RestServer/UpgradeFeature.cpp
View File

@ -31,7 +31,6 @@
#include "V8Server/V8Context.h"
#include "V8Server/V8DealerFeature.h"
#include "V8Server/v8-vocbase.h"
#include "VocBase/server.h"
#include "Wal/LogfileManager.h"
using namespace arangodb;
@ -182,7 +181,7 @@ void UpgradeFeature::changeAdminPassword(std::string const& defaultPassword) {
void UpgradeFeature::upgradeDatabase(std::string const& defaultPassword) {
LOG(TRACE) << "starting database init/upgrade";
auto* server = DatabaseFeature::SERVER;
DatabaseFeature* databaseFeature = application_features::ApplicationServer::getFeature<DatabaseFeature>("Database");
auto* systemVocbase = DatabaseFeature::DATABASE->systemDatabase();
// enter context and isolate
@ -209,11 +208,9 @@ void UpgradeFeature::upgradeDatabase(std::string const& defaultPassword) {
// run upgrade script
LOG(DEBUG) << "running database init/upgrade";
auto unuser(server->_databasesProtector.use());
auto theLists = server->_databasesLists.load();
for (auto& p : theLists->_databases) {
TRI_vocbase_t* vocbase = p.second;
for (auto& name : databaseFeature->getDatabaseNames()) {
TRI_vocbase_t* vocbase = databaseFeature->lookupDatabase(name);
TRI_ASSERT(vocbase != nullptr);
// special check script to be run just once in first thread (not in
// all) but for all databases

14
arangod/Utils/DatabaseGuard.h
View File

@ -27,7 +27,6 @@
#include "ApplicationFeatures/ApplicationServer.h"
#include "Basics/Exceptions.h"
#include "RestServer/DatabaseFeature.h"
#include "VocBase/server.h"
struct TRI_vocbase_t;
@ -42,8 +41,8 @@ class DatabaseGuard {
/// @brief create the guard, using a database id
//////////////////////////////////////////////////////////////////////////////
DatabaseGuard(TRI_server_t* server, TRI_voc_tick_t id)
: _server(server), _database(nullptr) {
explicit DatabaseGuard(TRI_voc_tick_t id)
: _database(nullptr) {
auto databaseFeature = application_features::ApplicationServer::getFeature<DatabaseFeature>("Database");
_database = databaseFeature->useDatabase(id);
@ -57,8 +56,8 @@ class DatabaseGuard {
/// @brief create the guard, using a database name
//////////////////////////////////////////////////////////////////////////////
DatabaseGuard(TRI_server_t* server, char const* name)
: _server(server), _database(nullptr) {
explicit DatabaseGuard(char const* name)
: _database(nullptr) {
auto databaseFeature = application_features::ApplicationServer::getFeature<DatabaseFeature>("Database");
_database = databaseFeature->useDatabase(name);
@ -87,11 +86,6 @@ class DatabaseGuard {
inline TRI_vocbase_t* database() const { return _database; }
private:
//////////////////////////////////////////////////////////////////////////////
/// @brief server
//////////////////////////////////////////////////////////////////////////////
TRI_server_t* _server;
//////////////////////////////////////////////////////////////////////////////
/// @brief pointer to database

2
arangod/V8Server/v8-collection.cpp
View File

@ -3096,7 +3096,7 @@ static void JS_DatafileScanVocbaseCol(
// generate the TRI_vocbase_col_t template
// .............................................................................
void TRI_InitV8collection(v8::Handle<v8::Context> context, TRI_server_t* server,
void TRI_InitV8Collection(v8::Handle<v8::Context> context,
TRI_vocbase_t* vocbase, size_t const threadNumber,
TRI_v8_global_t* v8g, v8::Isolate* isolate,
v8::Handle<v8::ObjectTemplate> ArangoDBNS) {

2
arangod/V8Server/v8-collection.h
View File

@ -57,7 +57,7 @@ bool EqualCollection(arangodb::CollectionNameResolver const* resolver,
v8::Handle<v8::Object> WrapCollection(v8::Isolate* isolate,
TRI_vocbase_col_t const* collection);
void TRI_InitV8collection(v8::Handle<v8::Context> context, TRI_server_t* server,
void TRI_InitV8Collection(v8::Handle<v8::Context> context,
TRI_vocbase_t* vocbase, size_t const threadNumber,
TRI_v8_global_t* v8g, v8::Isolate* isolate,
v8::Handle<v8::ObjectTemplate> ArangoDBNS);

2
arangod/V8Server/v8-replication.cpp
View File

@ -812,7 +812,7 @@ static void JS_ForgetApplierReplication(
void TRI_InitV8Replication(v8::Isolate* isolate,
v8::Handle<v8::Context> context,
TRI_server_t* server, TRI_vocbase_t* vocbase,
TRI_vocbase_t* vocbase,
size_t threadNumber, TRI_v8_global_t* v8g) {
// replication functions. not intended to be used by end users
TRI_AddGlobalFunctionVocbase(isolate, context,

4
arangod/V8Server/v8-replication.h
View File

@ -23,13 +23,13 @@
#ifndef ARANGOD_V8_SERVER_V8_REPLICATION_H
#define ARANGOD_V8_SERVER_V8_REPLICATION_H 1
#include "Basics/Common.h"
#include "v8-vocbase.h"
#include "VocBase/server.h"
void TRI_InitV8Replication(v8::Isolate* isolate,
v8::Handle<v8::Context> context,
TRI_server_t* server, TRI_vocbase_t* vocbase,
TRI_vocbase_t* vocbase,
size_t threadNumber, TRI_v8_global_t* v8g);
#endif

10
arangod/V8Server/v8-vocbase.cpp
View File

@ -2721,7 +2721,7 @@ void TRI_V8ReloadRouting(v8::Isolate* isolate) {
void TRI_InitV8VocBridge(v8::Isolate* isolate, v8::Handle<v8::Context> context,
arangodb::aql::QueryRegistry* queryRegistry,
TRI_server_t* server, TRI_vocbase_t* vocbase,
TRI_vocbase_t* vocbase,
size_t threadNumber) {
v8::HandleScope scope(isolate);
@ -2736,9 +2736,6 @@ void TRI_InitV8VocBridge(v8::Isolate* isolate, v8::Handle<v8::Context> context,
TRI_ASSERT(queryRegistry != nullptr);
v8g->_queryRegistry = queryRegistry;
// register the server
v8g->_server = server;
// register the database
v8g->_vocbase = vocbase;
@ -2785,8 +2782,7 @@ void TRI_InitV8VocBridge(v8::Isolate* isolate, v8::Handle<v8::Context> context,
TRI_InitV8indexArangoDB(isolate, ArangoNS);
TRI_InitV8collection(context, server, vocbase, threadNumber, v8g, isolate,
ArangoNS);
TRI_InitV8Collection(context, vocbase, threadNumber, v8g, isolate, ArangoNS);
v8g->VocbaseTempl.Reset(isolate, ArangoNS);
TRI_AddGlobalFunctionVocbase(isolate, context,
@ -2847,7 +2843,7 @@ void TRI_InitV8VocBridge(v8::Isolate* isolate, v8::Handle<v8::Context> context,
isolate, context, TRI_V8_ASCII_STRING("THROW_COLLECTION_NOT_LOADED"),
JS_ThrowCollectionNotLoaded, true);
TRI_InitV8Replication(isolate, context, server, vocbase, threadNumber, v8g);
TRI_InitV8Replication(isolate, context, vocbase, threadNumber, v8g);
TRI_AddGlobalFunctionVocbase(isolate, context,
TRI_V8_ASCII_STRING("COMPARE_STRING"),

3
arangod/V8Server/v8-vocbase.h
View File

@ -28,7 +28,6 @@
#include "V8/v8-globals.h"
#include "VocBase/document-collection.h"
struct TRI_server_t;
struct TRI_vocbase_t;
namespace arangodb {
@ -70,7 +69,7 @@ void TRI_V8ReloadRouting(v8::Isolate* isolate);
////////////////////////////////////////////////////////////////////////////////
void TRI_InitV8VocBridge(v8::Isolate* isolate, v8::Handle<v8::Context>,
arangodb::aql::QueryRegistry*, TRI_server_t*,
arangodb::aql::QueryRegistry*,
TRI_vocbase_t*, size_t);
#endif

169
arangod/VocBase/server.cpp
View File

@ -27,186 +27,17 @@
#include "Basics/win-utils.h"
#endif
#include "ApplicationFeatures/PageSizeFeature.h"
#include "Aql/QueryCache.h"
#include "Aql/QueryRegistry.h"
#include "Basics/Exceptions.h"
#include "Basics/FileUtils.h"
#include "Basics/MutexLocker.h"
#include "Basics/StringUtils.h"
#include "Basics/VelocyPackHelper.h"
#include "Basics/conversions.h"
#include "Basics/files.h"
#include "Basics/hashes.h"
#include "Basics/memory-map.h"
#include "Basics/tri-strings.h"
#include "Cluster/ServerState.h"
#include "GeneralServer/GeneralServerFeature.h"
#include "Logger/Logger.h"
#include "Random/RandomGenerator.h"
#include "Utils/CursorRepository.h"
#include "V8Server/V8DealerFeature.h"
#include "VocBase/replication-applier.h"
#include "VocBase/vocbase.h"
#include "Wal/LogfileManager.h"
#include "Wal/Marker.h"
#ifdef ARANGODB_ENABLE_ROCKSDB
#include "Indexes/RocksDBIndex.h"
#endif
using namespace arangodb;
using namespace arangodb::application_features;
using namespace arangodb::basics;
////////////////////////////////////////////////////////////////////////////////
/// @brief interval for database manager activity
////////////////////////////////////////////////////////////////////////////////
#define DATABASE_MANAGER_INTERVAL (500 * 1000)
////////////////////////////////////////////////////////////////////////////////
/// @brief lock for serializing the creation of database
////////////////////////////////////////////////////////////////////////////////
static arangodb::Mutex DatabaseCreateLock;
////////////////////////////////////////////////////////////////////////////////
/// @brief variable protecting the server shutdown
////////////////////////////////////////////////////////////////////////////////
static std::atomic<bool> ServerShutdown;
////////////////////////////////////////////////////////////////////////////////
/// @brief server operation mode (e.g. read-only, normal etc).
////////////////////////////////////////////////////////////////////////////////
static TRI_vocbase_operationmode_e Mode = TRI_VOCBASE_MODE_NORMAL;
////////////////////////////////////////////////////////////////////////////////
/// @brief close all opened databases
////////////////////////////////////////////////////////////////////////////////
static int CloseDatabases(TRI_server_t* server) {
MUTEX_LOCKER(mutexLocker,
server->_databasesMutex); // Only one should do this at a time
// No need for the thread protector here, because we have the mutex
// Note however, that somebody could still read the lists concurrently,
// therefore we first install a new value, call scan() on the protector
// and only then really destroy the vocbases:
// Build the new value:
auto oldList = server->_databasesLists.load();
decltype(oldList) newList = nullptr;
try {
newList = new DatabasesLists();
newList->_droppedDatabases =
server->_databasesLists.load()->_droppedDatabases;
} catch (...) {
delete newList;
return TRI_ERROR_OUT_OF_MEMORY;
}
// Replace the old by the new:
server->_databasesLists = newList;
server->_databasesProtector.scan();
// Now it is safe to destroy the old databases and the old lists struct:
for (auto& p : oldList->_databases) {
TRI_vocbase_t* vocbase = p.second;
TRI_ASSERT(vocbase != nullptr);
TRI_ASSERT(vocbase->_type == TRI_VOCBASE_TYPE_NORMAL);
TRI_DestroyVocBase(vocbase);
delete vocbase;
}
for (auto& p : oldList->_coordinatorDatabases) {
TRI_vocbase_t* vocbase = p.second;
TRI_ASSERT(vocbase != nullptr);
TRI_ASSERT(vocbase->_type == TRI_VOCBASE_TYPE_COORDINATOR);
delete vocbase;
}
delete oldList; // Note that this does not delete the TRI_vocbase_t pointers!
return TRI_ERROR_NO_ERROR;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief initializes all databases
////////////////////////////////////////////////////////////////////////////////
int TRI_InitDatabasesServer(TRI_server_t* server) {
auto unuser(server->_databasesProtector.use());
auto theLists = server->_databasesLists.load();
for (auto& p : theLists->_databases) {
TRI_vocbase_t* vocbase = p.second;
// iterate over all databases
TRI_ASSERT(vocbase != nullptr);
TRI_ASSERT(vocbase->_type == TRI_VOCBASE_TYPE_NORMAL);
// start the compactor for the database
TRI_StartCompactorVocBase(vocbase);
// start the replication applier
TRI_ASSERT(vocbase->_replicationApplier != nullptr);
if (vocbase->_replicationApplier->_configuration._autoStart) {
if (server->_disableReplicationAppliers) {
LOG(INFO) << "replication applier explicitly deactivated for database '"
<< vocbase->_name << "'";
} else {
int res = vocbase->_replicationApplier->start(0, false, 0);
if (res != TRI_ERROR_NO_ERROR) {
LOG(WARN) << "unable to start replication applier for database '"
<< vocbase->_name << "': " << TRI_errno_string(res);
}
}
}
}
return TRI_ERROR_NO_ERROR;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief sets the current operation mode of the server
////////////////////////////////////////////////////////////////////////////////
int TRI_ChangeOperationModeServer(TRI_vocbase_operationmode_e mode) {
Mode = mode;
return TRI_ERROR_NO_ERROR;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the current operation server of the server
////////////////////////////////////////////////////////////////////////////////
TRI_vocbase_operationmode_e TRI_GetOperationModeServer() { return Mode; }
TRI_server_t::TRI_server_t()
: _databasesLists(new DatabasesLists()),
_queryRegistry(nullptr),
_basePath(nullptr),
_databasePath(nullptr),
_disableReplicationAppliers(false),
_disableCompactor(false),
_iterateMarkersOnOpen(false),
_initialized(false) {}
TRI_server_t::~TRI_server_t() {
if (_initialized) {
CloseDatabases(this);
auto p = _databasesLists.load();
delete p;
TRI_Free(TRI_CORE_MEM_ZONE, _databasePath);
TRI_Free(TRI_CORE_MEM_ZONE, _basePath);
}
}

47
arangod/VocBase/server.h
View File

@ -25,60 +25,13 @@
#define ARANGOD_VOC_BASE_SERVER_H 1
#include "Basics/Common.h"
#include "Basics/Mutex.h"
#include "Basics/DataProtector.h"
#include "VocBase/ticks.h"
#include "VocBase/voc-types.h"
struct TRI_vocbase_t;
namespace arangodb {
namespace aql {
class QueryRegistry;
}
namespace rest {
class ApplicationEndpointServer;
}
}
/// @brief server structure
struct TRI_server_t {
TRI_server_t();
~TRI_server_t();
std::atomic<DatabasesLists*> _databasesLists;
// TODO: Make this again a template once everybody has gcc >= 4.9.2
// arangodb::basics::DataProtector<64>
arangodb::basics::DataProtector _databasesProtector;
arangodb::Mutex _databasesMutex;
std::atomic<arangodb::aql::QueryRegistry*> _queryRegistry;
char* _basePath;
char* _databasePath;
bool _disableReplicationAppliers;
bool _disableCompactor;
bool _iterateMarkersOnOpen;
bool _initialized;
};
////////////////////////////////////////////////////////////////////////////////
/// @brief initializes all databases
////////////////////////////////////////////////////////////////////////////////
int TRI_InitDatabasesServer(TRI_server_t*);
////////////////////////////////////////////////////////////////////////////////
/// @brief sets the current operation mode of the server
////////////////////////////////////////////////////////////////////////////////
int TRI_ChangeOperationModeServer(TRI_vocbase_operationmode_e);
////////////////////////////////////////////////////////////////////////////////
/// @brief returns the current operation mode of the server
////////////////////////////////////////////////////////////////////////////////
TRI_vocbase_operationmode_e TRI_GetOperationModeServer();
#endif

1
arangod/VocBase/vocbase.h
View File

@ -39,7 +39,6 @@
struct TRI_document_collection_t;
class TRI_replication_applier_t;
struct TRI_server_t;
class TRI_vocbase_col_t;
namespace arangodb {

9
arangod/Wal/CollectorThread.cpp
View File

@ -38,7 +38,6 @@
#include "VocBase/DatafileHelper.h"
#include "VocBase/DatafileStatistics.h"
#include "VocBase/document-collection.h"
#include "VocBase/server.h"
#include "Wal/Logfile.h"
#include "Wal/LogfileManager.h"
@ -248,11 +247,9 @@ static bool ScanMarker(TRI_df_marker_t const* marker, void* data,
uint64_t const CollectorThread::Interval = 1000000;
/// @brief create the collector thread
CollectorThread::CollectorThread(LogfileManager* logfileManager,
TRI_server_t* server)
CollectorThread::CollectorThread(LogfileManager* logfileManager)
: Thread("WalCollector"),
_logfileManager(logfileManager),
_server(server),
_condition(),
_operationsQueueLock(),
_operationsQueue(),
@ -629,7 +626,7 @@ void CollectorThread::processCollectionMarker(
/// @brief process all operations for a single collection
int CollectorThread::processCollectionOperations(CollectorCache* cache) {
arangodb::DatabaseGuard dbGuard(_server, cache->databaseId);
arangodb::DatabaseGuard dbGuard(cache->databaseId);
TRI_vocbase_t* vocbase = dbGuard.database();
TRI_ASSERT(vocbase != nullptr);
@ -855,7 +852,7 @@ int CollectorThread::transferMarkers(Logfile* logfile,
TRI_ASSERT(!operations.empty());
// prepare database and collection
arangodb::DatabaseGuard dbGuard(_server, databaseId);
arangodb::DatabaseGuard dbGuard(databaseId);
TRI_vocbase_t* vocbase = dbGuard.database();
TRI_ASSERT(vocbase != nullptr);

6
arangod/Wal/CollectorThread.h
View File

@ -38,7 +38,6 @@
struct TRI_datafile_t;
struct TRI_df_marker_t;
struct TRI_document_collection_t;
struct TRI_server_t;
namespace arangodb {
namespace wal {
@ -140,7 +139,7 @@ class CollectorThread : public Thread {
CollectorThread& operator=(CollectorThread const&) = delete;
public:
CollectorThread(LogfileManager*, TRI_server_t*);
explicit CollectorThread(LogfileManager*);
~CollectorThread() { shutdown(); }
public:
@ -223,9 +222,6 @@ class CollectorThread : public Thread {
/// @brief the logfile manager
LogfileManager* _logfileManager;
/// @brief pointer to the server
TRI_server_t* _server;
/// @brief condition variable for the collector thread
basics::ConditionVariable _condition;

14
arangod/Wal/LogfileManager.cpp
View File

@ -40,7 +40,6 @@
#include "RestServer/DatabaseFeature.h"
#include "RestServer/DatabasePathFeature.h"
#include "StorageEngine/EngineSelectorFeature.h"
#include "VocBase/server.h"
#include "Wal/AllocatorThread.h"
#include "Wal/CollectorThread.h"
#include "Wal/RecoverState.h"
@ -87,7 +86,6 @@ static inline uint32_t MaxSlots() { return 1024 * 1024 * 16; }
// create the logfile manager
LogfileManager::LogfileManager(ApplicationServer* server)
: ApplicationFeature(server, "LogfileManager"),
_server(nullptr),
_recoverState(nullptr),
_allowWrites(false), // start in read-only mode
_hasFoundLastTick(false),
@ -246,8 +244,8 @@ void LogfileManager::validateOptions(std::shared_ptr<options::ProgramOptions> op
}
void LogfileManager::prepare() {
auto database = ApplicationServer::getFeature<DatabasePathFeature>("DatabasePath");
_databasePath = database->directory();
auto databasePath = ApplicationServer::getFeature<DatabasePathFeature>("DatabasePath");
_databasePath = databasePath->directory();
std::string const shutdownFile = shutdownFilename();
bool const shutdownFileExists = basics::FileUtils::exists(shutdownFile);
@ -270,9 +268,6 @@ void LogfileManager::prepare() {
void LogfileManager::start() {
Instance = this;
_server = DatabaseFeature::SERVER;
TRI_ASSERT(_server != nullptr);
// needs server initialized
size_t pageSize = PageSizeFeature::getPageSize();
_filesize = static_cast<uint32_t>(((_filesize + pageSize - 1) / pageSize) * pageSize);
@ -436,7 +431,8 @@ bool LogfileManager::open() {
_allocatorThread->recoveryDone();
// start compactor threads etc.
res = TRI_InitDatabasesServer(_server);
auto databaseFeature = ApplicationServer::getFeature<DatabaseFeature>("Database");
res = databaseFeature->recoveryDone();
if (res != TRI_ERROR_NO_ERROR) {
LOG(FATAL) << "could not initialize databases: " << TRI_errno_string(res);
@ -1877,7 +1873,7 @@ void LogfileManager::stopAllocatorThread() {
// start the collector thread
int LogfileManager::startCollectorThread() {
_collectorThread = new CollectorThread(this, _server);
_collectorThread = new CollectorThread(this);
if (!_collectorThread->start()) {
delete _collectorThread;

5
arangod/Wal/LogfileManager.h
View File

@ -33,8 +33,6 @@
#include "Wal/Marker.h"
#include "Wal/Slots.h"
struct TRI_server_t;
namespace arangodb {
namespace options {
class ProgramOptions;
@ -446,9 +444,6 @@ class LogfileManager final : public application_features::ApplicationFeature {
std::string logfileName(Logfile::IdType) const;
private:
// pointer to the server
TRI_server_t* _server;
// the arangod config variable containing the database path
std::string _databasePath;

1
lib/V8/v8-globals.cpp
View File

@ -119,7 +119,6 @@ TRI_v8_global_s::TRI_v8_global_s(v8::Isolate* isolate)
_transactionContext(nullptr),
_queryRegistry(nullptr),
_query(nullptr),
_server(nullptr),
_vocbase(nullptr),
_activeExternals(0),
_canceled(false),

6
lib/V8/v8-globals.h
View File

@ -992,12 +992,6 @@ typedef struct TRI_v8_global_s {
void* _query;
//////////////////////////////////////////////////////////////////////////////
/// @brief pointer to the server (TRI_server_t*)
//////////////////////////////////////////////////////////////////////////////
void* _server;
//////////////////////////////////////////////////////////////////////////////
/// @brief pointer to the vocbase (TRI_vocbase_t*)
//////////////////////////////////////////////////////////////////////////////