1
0
Fork 0

use new and delete for TRI_server_t

This commit is contained in:
Jan Steemann 2015-07-21 11:57:04 +02:00
parent 7c1aca6d11
commit e8205e5dc0
22 changed files with 390 additions and 559 deletions

View File

@ -35,7 +35,7 @@
#include "ApplicationServer/ApplicationFeature.h"
#include "Cluster/ServerState.h"
struct TRI_server_s;
struct TRI_server_t;
namespace triagens {
namespace rest {
@ -66,7 +66,7 @@ namespace triagens {
/// @brief constructor
////////////////////////////////////////////////////////////////////////////////
ApplicationCluster (struct TRI_server_s*,
ApplicationCluster (TRI_server_t*,
triagens::rest::ApplicationDispatcher*,
triagens::arango::ApplicationV8*);
@ -150,7 +150,7 @@ namespace triagens {
/// @brief server
////////////////////////////////////////////////////////////////////////////////
struct TRI_server_s* _server;
TRI_server_t* _server;
////////////////////////////////////////////////////////////////////////////////
/// @brief dispatcher

View File

@ -40,7 +40,6 @@
struct TRI_json_t;
struct TRI_memory_zone_s;
struct TRI_server_s;
namespace triagens {
namespace arango {

View File

@ -37,7 +37,7 @@
#include "Basics/logging.h"
#include "Cluster/AgencyComm.h"
struct TRI_server_s;
struct TRI_server_t;
struct TRI_vocbase_t;
namespace triagens {
@ -68,7 +68,7 @@ namespace triagens {
/// @brief constructs a heartbeat thread
////////////////////////////////////////////////////////////////////////////////
HeartbeatThread (struct TRI_server_s*,
HeartbeatThread (TRI_server_t*,
triagens::rest::ApplicationDispatcher*,
ApplicationV8*,
uint64_t,
@ -205,7 +205,7 @@ namespace triagens {
/// @brief server
////////////////////////////////////////////////////////////////////////////////
struct TRI_server_s* _server;
TRI_server_t* _server;
////////////////////////////////////////////////////////////////////////////////
/// @brief Job dispatcher

View File

@ -36,7 +36,7 @@
#include "Dispatcher/Job.h"
#include "Rest/Handler.h"
struct TRI_server_s;
struct TRI_server_t;
// -----------------------------------------------------------------------------
// --SECTION-- class ServerJob
@ -67,7 +67,7 @@ namespace triagens {
////////////////////////////////////////////////////////////////////////////////
ServerJob (HeartbeatThread* heartbeat,
struct TRI_server_s* server,
TRI_server_t* server,
ApplicationV8* applicationV8);
////////////////////////////////////////////////////////////////////////////////
@ -172,7 +172,7 @@ namespace triagens {
/// @brief server
////////////////////////////////////////////////////////////////////////////////
struct TRI_server_s* _server;
TRI_server_t* _server;
////////////////////////////////////////////////////////////////////////////////
/// @brief v8 dispatcher

View File

@ -41,7 +41,7 @@
// -----------------------------------------------------------------------------
struct TRI_json_t;
struct TRI_server_s;
struct TRI_server_t;
struct TRI_vocbase_t;
namespace triagens {
@ -74,7 +74,7 @@ namespace triagens {
/// @brief constructor
////////////////////////////////////////////////////////////////////////////////
ContinuousSyncer (struct TRI_server_s*,
ContinuousSyncer (TRI_server_t*,
TRI_vocbase_t*,
struct TRI_replication_applier_configuration_s const*,
TRI_voc_tick_t,
@ -214,7 +214,7 @@ namespace triagens {
/// @brief server
////////////////////////////////////////////////////////////////////////////////
struct TRI_server_s* _server;
TRI_server_t* _server;
////////////////////////////////////////////////////////////////////////////////
/// @brief pointer to the applier state

View File

@ -378,11 +378,7 @@ ArangoServer::ArangoServer (int argc, char** argv)
TRI_InitServerGlobals();
_server = TRI_CreateServer();
if (_server == nullptr) {
LOG_FATAL_AND_EXIT("could not create server instance");
}
_server = new TRI_server_t;
}
////////////////////////////////////////////////////////////////////////////////
@ -394,11 +390,7 @@ ArangoServer::~ArangoServer () {
delete _jobManager;
if (_server != nullptr) {
TRI_FreeServer(_server);
}
TRI_FreeServerGlobals();
delete _server;
Nonce::destroy();
}
@ -465,7 +457,7 @@ void ArangoServer::buildApplicationServer () {
// ...........................................................................
_queryRegistry = new aql::QueryRegistry();
_server->_queryRegistry = static_cast<void*>(_queryRegistry);
_server->_queryRegistry = _queryRegistry;
// .............................................................................
// V8 engine

View File

@ -43,7 +43,7 @@
#include "HttpServer/HttpHandlerFactory.h"
#include "Aql/QueryRegistry.h"
struct TRI_server_s;
struct TRI_server_t;
struct TRI_vocbase_defaults_s;
// -----------------------------------------------------------------------------
@ -647,7 +647,7 @@ namespace triagens {
/// @brief the server
////////////////////////////////////////////////////////////////////////////////
struct TRI_server_s* _server;
TRI_server_t* _server;
////////////////////////////////////////////////////////////////////////////////
/// @brief the server

View File

@ -40,7 +40,7 @@
// --SECTION-- forward declarations
// -----------------------------------------------------------------------------
struct TRI_server_s;
struct TRI_server_t;
struct TRI_vocbase_t;
// -----------------------------------------------------------------------------
@ -101,7 +101,7 @@ namespace triagens {
////////////////////////////////////////////////////////////////////////////////
VocbaseContext (rest::HttpRequest*,
struct TRI_server_s*,
TRI_server_t*,
TRI_vocbase_t*);
////////////////////////////////////////////////////////////////////////////////
@ -172,7 +172,7 @@ namespace triagens {
/// @brief the server
////////////////////////////////////////////////////////////////////////////////
struct TRI_server_s* TRI_UNUSED _server;
TRI_server_t* TRI_UNUSED _server;
////////////////////////////////////////////////////////////////////////////////
/// @brief the vocbase

View File

@ -31,6 +31,7 @@
#define ARANGODB_UTILS_COLLECTION_NAME_RESOLVER_H 1
#include "Basics/Common.h"
#include "Basics/ReadLocker.h"
#include "Basics/StringBuffer.h"
#include "Basics/StringUtils.h"
#include "Cluster/ServerState.h"
@ -152,7 +153,7 @@ namespace triagens {
std::string name;
if (ServerState::instance()->isDBServer()) {
TRI_READ_LOCK_COLLECTIONS_VOCBASE(_vocbase);
READ_LOCKER(_vocbase->_collectionsLock);
TRI_vocbase_col_t* found
= static_cast<TRI_vocbase_col_t*>(
@ -176,8 +177,6 @@ namespace triagens {
name = ci->name(); // can be empty, if collection unknown
}
}
TRI_READ_UNLOCK_COLLECTIONS_VOCBASE(_vocbase);
}
else {
// exactly as in the non-cluster case

View File

@ -43,7 +43,7 @@
// --SECTION-- forward declarations
// -----------------------------------------------------------------------------
struct TRI_server_s;
struct TRI_server_t;
struct TRI_vocbase_t;
namespace triagens {
@ -273,7 +273,7 @@ namespace triagens {
/// @brief constructor
////////////////////////////////////////////////////////////////////////////////
ApplicationV8 (struct TRI_server_s*,
ApplicationV8 (TRI_server_t*,
triagens::aql::QueryRegistry*,
rest::ApplicationScheduler*,
rest::ApplicationDispatcher*);
@ -475,7 +475,7 @@ namespace triagens {
/// @brief server object
////////////////////////////////////////////////////////////////////////////////
struct TRI_server_s* _server;
TRI_server_t* _server;
////////////////////////////////////////////////////////////////////////////////
/// @brief query registry object

View File

@ -545,9 +545,8 @@ static TRI_vocbase_col_t const* UseCollection (v8::Handle<v8::Object> collection
/// @brief get all cluster collections
////////////////////////////////////////////////////////////////////////////////
static TRI_vector_pointer_t GetCollectionsCluster (TRI_vocbase_t* vocbase) {
TRI_vector_pointer_t result;
TRI_InitVectorPointer(&result, TRI_UNKNOWN_MEM_ZONE);
static std::vector<TRI_vocbase_col_t*> GetCollectionsCluster (TRI_vocbase_t* vocbase) {
std::vector<TRI_vocbase_col_t*> result;
std::vector<shared_ptr<CollectionInfo> > const& collections
= ClusterInfo::instance()->getCollections(vocbase->_name);
@ -556,7 +555,7 @@ static TRI_vector_pointer_t GetCollectionsCluster (TRI_vocbase_t* vocbase) {
TRI_vocbase_col_t* c = CoordinatorCollection(vocbase, *(collections[i]));
if (c != nullptr) {
TRI_PushBackVectorPointer(&result, c);
result.emplace_back(c);
}
}
@ -567,20 +566,15 @@ static TRI_vector_pointer_t GetCollectionsCluster (TRI_vocbase_t* vocbase) {
/// @brief get all cluster collection names
////////////////////////////////////////////////////////////////////////////////
static TRI_vector_string_t GetCollectionNamesCluster (TRI_vocbase_t* vocbase) {
TRI_vector_string_t result;
TRI_InitVectorString(&result, TRI_UNKNOWN_MEM_ZONE);
static std::vector<std::string> GetCollectionNamesCluster (TRI_vocbase_t* vocbase) {
std::vector<std::string> result;
std::vector<shared_ptr<CollectionInfo> > const& collections
= ClusterInfo::instance()->getCollections(vocbase->_name);
for (size_t i = 0, n = collections.size(); i < n; ++i) {
string const& name = collections[i]->name();
char* s = TRI_DuplicateString2Z(TRI_UNKNOWN_MEM_ZONE, name.c_str(), name.size());
if (s != nullptr) {
TRI_PushBackVectorString(&result, s);
}
result.emplace_back(name);
}
return result;
@ -3816,7 +3810,7 @@ static void JS_CollectionsVocbase (const v8::FunctionCallbackInfo<v8::Value>& ar
TRI_V8_THROW_EXCEPTION(TRI_ERROR_ARANGO_DATABASE_NOT_FOUND);
}
TRI_vector_pointer_t colls;
std::vector<TRI_vocbase_col_t*> colls;
// if we are a coordinator, we need to fetch the collection info from the agency
if (ServerState::instance()->isCoordinator()) {
@ -3830,9 +3824,10 @@ static void JS_CollectionsVocbase (const v8::FunctionCallbackInfo<v8::Value>& ar
// already create an array of the correct size
v8::Handle<v8::Array> result = v8::Array::New(isolate);
uint32_t n = (uint32_t) colls._length;
for (uint32_t i = 0; i < n; ++i) {
auto collection = static_cast<TRI_vocbase_col_t const*>(colls._buffer[i]);
size_t const n = colls.size();
for (size_t i = 0; i < n; ++i) {
auto collection = colls[i];
v8::Handle<v8::Value> c = WrapCollection(isolate, collection);
@ -3841,11 +3836,9 @@ static void JS_CollectionsVocbase (const v8::FunctionCallbackInfo<v8::Value>& ar
break;
}
result->Set(i, c);
result->Set(static_cast<uint32_t>(i), c);
}
TRI_DestroyVectorPointer(&colls);
if (error) {
TRI_V8_THROW_EXCEPTION_MEMORY();
}
@ -3868,34 +3861,25 @@ static void JS_CompletionsVocbase (const v8::FunctionCallbackInfo<v8::Value>& ar
TRI_V8_RETURN(v8::Array::New(isolate));
}
TRI_vector_string_t names;
std::vector<std::string> names;
if (ServerState::instance()->isCoordinator()) {
if (ClusterInfo::instance()->doesDatabaseExist(vocbase->_name)) {
names = GetCollectionNamesCluster(vocbase);
}
else {
TRI_InitVectorString(&names, TRI_UNKNOWN_MEM_ZONE);
}
}
else {
names = TRI_CollectionNamesVocBase(vocbase);
}
size_t n = names._length;
uint32_t j = 0;
v8::Handle<v8::Array> result = v8::Array::New(isolate);
// add collection names
for (size_t i = 0; i < n; ++i) {
char const* name = TRI_AtVectorString(&names, i);
if (name != nullptr) {
result->Set(j++, TRI_V8_STRING(name));
}
for (auto& name : names) {
result->Set(j++, TRI_V8_STD_STRING(name));
}
TRI_DestroyVectorString(&names);
// add function names. these are hard coded
result->Set(j++, TRI_V8_ASCII_STRING("_changeMode()"));
result->Set(j++, TRI_V8_ASCII_STRING("_collection()"));

View File

@ -36,7 +36,7 @@
#include "ShapedJson/shaped-json.h"
#include "VocBase/document-collection.h"
struct TRI_server_s;
struct TRI_server_t;
struct TRI_vocbase_t;
namespace triagens {
@ -101,7 +101,7 @@ void TRI_InitV8VocBridge (v8::Isolate* isolate,
triagens::arango::ApplicationV8*,
v8::Handle<v8::Context>,
triagens::aql::QueryRegistry*,
struct TRI_server_s*,
TRI_server_t*,
TRI_vocbase_t*,
triagens::arango::JSLoader*,
size_t);

View File

@ -237,15 +237,15 @@ void TRI_CleanupVocBase (void* data) {
// check if we can get the compactor lock exclusively
if (TRI_CheckAndLockCompactorVocBase(vocbase)) {
// copy all collections
TRI_READ_LOCK_COLLECTIONS_VOCBASE(vocbase);
try {
READ_LOCKER(vocbase->_collectionsLock);
// copy all collections
collections = vocbase->_collections;
}
catch (...) {
collections.clear();
}
TRI_READ_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
for (auto& collection : collections) {
TRI_ASSERT(collection != nullptr);

View File

@ -1393,15 +1393,14 @@ void TRI_CompactorVocBase (void* data) {
double now = TRI_microtime();
numCompacted = 0;
// copy all collections
TRI_READ_LOCK_COLLECTIONS_VOCBASE(vocbase);
try {
READ_LOCKER(vocbase->_collectionsLock);
// copy all collections
collections = vocbase->_collections;
}
catch (...) {
collections.clear();
}
TRI_READ_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
for (auto& collection : collections) {
if (! TRI_TRY_READ_LOCK_STATUS_VOCBASE_COL(collection)) {

View File

@ -42,7 +42,7 @@
// -----------------------------------------------------------------------------
struct TRI_json_t;
struct TRI_server_s;
struct TRI_server_t;
struct TRI_vocbase_t;
// -----------------------------------------------------------------------------
@ -158,7 +158,7 @@ struct TRI_replication_applier_t {
_runningRemoteTransactions.clear();
}
struct TRI_server_s* _server;
TRI_server_t* _server;
TRI_vocbase_t* _vocbase;
TRI_read_write_lock_t _statusLock;
TRI_spin_t _threadLock;
@ -179,7 +179,7 @@ struct TRI_replication_applier_t {
/// @brief create a replication applier
////////////////////////////////////////////////////////////////////////////////
TRI_replication_applier_t* TRI_CreateReplicationApplier (struct TRI_server_s*,
TRI_replication_applier_t* TRI_CreateReplicationApplier (TRI_server_t*,
TRI_vocbase_t*);
////////////////////////////////////////////////////////////////////////////////

View File

@ -48,6 +48,8 @@
#include "Basics/memory-map.h"
#include "Basics/MutexLocker.h"
#include "Basics/random.h"
#include "Basics/SpinLock.h"
#include "Basics/SpinLocker.h"
#include "Basics/tri-strings.h"
#include "Cluster/ServerState.h"
#include "Utils/CursorRepository.h"
@ -67,46 +69,6 @@
size_t PageSize;
class DatabaseReadLocker {
public:
DatabaseReadLocker (DatabaseReadLocker const&) = delete;
DatabaseReadLocker& operator= (DatabaseReadLocker const&) = delete;
DatabaseReadLocker (TRI_read_write_lock_t* lock)
: _lock(lock) {
TRI_ReadLockReadWriteLock(_lock);
}
~DatabaseReadLocker () {
TRI_ReadUnlockReadWriteLock(_lock);
}
private:
TRI_read_write_lock_t* _lock;
};
class DatabaseWriteLocker {
public:
DatabaseWriteLocker (DatabaseWriteLocker const&) = delete;
DatabaseWriteLocker& operator= (DatabaseWriteLocker const&) = delete;
DatabaseWriteLocker (TRI_read_write_lock_t* lock)
: _lock(lock) {
while (! TRI_TryWriteLockReadWriteLock(lock)) {
usleep(1000);
}
}
~DatabaseWriteLocker () {
TRI_WriteUnlockReadWriteLock(_lock);
}
private:
TRI_read_write_lock_t* _lock;
};
// -----------------------------------------------------------------------------
// --SECTION-- private defines
// -----------------------------------------------------------------------------
@ -161,7 +123,7 @@ static uint64_t CurrentTick = 0;
/// @brief tick lock
////////////////////////////////////////////////////////////////////////////////
static TRI_spin_t TickLock;
static triagens::basics::SpinLock TickLock;
////////////////////////////////////////////////////////////////////////////////
/// @brief the server's global id
@ -822,7 +784,7 @@ static int OpenDatabases (TRI_server_t* server,
////////////////////////////////////////////////////////////////////////////////
static void StopReplicationAppliers (TRI_server_t* server) {
DatabaseWriteLocker locker(&server->_databasesLock);
WRITE_LOCKER_EVENTUAL(server->_databasesLock, 1000);
size_t n = server->_databases._nrAlloc;
@ -844,7 +806,7 @@ static void StopReplicationAppliers (TRI_server_t* server) {
////////////////////////////////////////////////////////////////////////////////
static int CloseDatabases (TRI_server_t* server) {
DatabaseWriteLocker locker(&server->_databasesLock);
WRITE_LOCKER_EVENTUAL(server->_databasesLock, 1000);
size_t n = server->_databases._nrAlloc;
@ -886,12 +848,12 @@ static int CloseDatabases (TRI_server_t* server) {
////////////////////////////////////////////////////////////////////////////////
static int CloseDroppedDatabases (TRI_server_t* server) {
DatabaseWriteLocker locker(&server->_databasesLock);
WRITE_LOCKER_EVENTUAL(server->_databasesLock, 1000);
size_t n = server->_droppedDatabases._length;
size_t const n = server->_droppedDatabases.size();
for (size_t i = 0; i < n; ++i) {
TRI_vocbase_t* vocbase = static_cast<TRI_vocbase_t*>(TRI_AtVectorPointer(&server->_droppedDatabases, i));
auto vocbase = server->_droppedDatabases[i];
if (vocbase != nullptr) {
if (vocbase->_type == TRI_VOCBASE_TYPE_NORMAL) {
@ -899,12 +861,12 @@ static int CloseDroppedDatabases (TRI_server_t* server) {
delete vocbase;
// clear to avoid potential double freeing
server->_droppedDatabases._buffer[i] = nullptr;
server->_droppedDatabases[i] = nullptr;
}
else if (vocbase->_type == TRI_VOCBASE_TYPE_COORDINATOR) {
delete vocbase;
// clear to avoid potential double freeing
server->_droppedDatabases._buffer[i] = nullptr;
server->_droppedDatabases[i] = nullptr;
}
else {
LOG_ERROR("unknown database type %d %s - close doing nothing.",
@ -1596,19 +1558,18 @@ static void DatabaseManager (void* data) {
TRI_vocbase_t* database = nullptr;
{
DatabaseWriteLocker locker(&server->_databasesLock);
WRITE_LOCKER_EVENTUAL(server->_databasesLock, 1000);
size_t const n = server->_droppedDatabases._length;
for (size_t i = 0; i < n; ++i) {
TRI_vocbase_t* vocbase = static_cast<TRI_vocbase_t*>(TRI_AtVectorPointer(&server->_droppedDatabases, i));
for (auto it = server->_droppedDatabases.begin(); it != server->_droppedDatabases.end(); ++it) {
auto vocbase = (*it);
if (! TRI_CanRemoveVocBase(vocbase)) {
continue;
}
// found a database to delete
database = static_cast<TRI_vocbase_t*>(TRI_RemoveVectorPointer(&server->_droppedDatabases, i));
server->_droppedDatabases.erase(it);
database = vocbase;
break;
}
}
@ -1677,7 +1638,7 @@ static void DatabaseManager (void* data) {
++cleanupCycles == 10) {
cleanupCycles = 0;
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
size_t const n = server->_coordinatorDatabases._nrAlloc;
@ -1707,21 +1668,13 @@ static void DatabaseManager (void* data) {
// --SECTION-- constructors / destructors
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief create a server instance
////////////////////////////////////////////////////////////////////////////////
TRI_server_t* TRI_CreateServer () {
return static_cast<TRI_server_t*>(TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(TRI_server_t), true));
}
////////////////////////////////////////////////////////////////////////////////
/// @brief initialise a server instance with configuration
////////////////////////////////////////////////////////////////////////////////
int TRI_InitServer (TRI_server_t* server,
void* applicationEndpointServer,
void* indexPool,
triagens::rest::ApplicationEndpointServer* applicationEndpointServer,
triagens::basics::ThreadPool* indexPool,
char const* basePath,
char const* appPath,
TRI_vocbase_defaults_t const* defaults,
@ -1811,51 +1764,15 @@ int TRI_InitServer (TRI_server_t* server,
EqualKeyDatabaseName,
nullptr);
TRI_InitReadWriteLock(&server->_databasesLock);
TRI_InitVectorPointer(&server->_droppedDatabases, TRI_UNKNOWN_MEM_ZONE, 64);
server->_disableReplicationAppliers = disableAppliers;
server->_queryRegistry = nullptr; // will be filled in later
server->_initialised = true;
server->_initialized = true;
return TRI_ERROR_NO_ERROR;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief destroy a server instance
////////////////////////////////////////////////////////////////////////////////
void TRI_DestroyServer (TRI_server_t* server) {
if (server->_initialised) {
CloseDatabases(server);
TRI_DestroyVectorPointer(&server->_droppedDatabases);
TRI_DestroyReadWriteLock(&server->_databasesLock);
TRI_DestroyAssociativePointer(&server->_coordinatorDatabases);
TRI_DestroyAssociativePointer(&server->_databases);
TRI_Free(TRI_CORE_MEM_ZONE, server->_appPath);
TRI_Free(TRI_CORE_MEM_ZONE, server->_serverIdFilename);
TRI_Free(TRI_CORE_MEM_ZONE, server->_lockFilename);
TRI_Free(TRI_CORE_MEM_ZONE, server->_databasePath);
TRI_Free(TRI_CORE_MEM_ZONE, server->_basePath);
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief free a server instance
////////////////////////////////////////////////////////////////////////////////
void TRI_FreeServer (TRI_server_t* server) {
TRI_DestroyServer(server);
TRI_Free(TRI_CORE_MEM_ZONE, server);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief initialise globals
/// @brief initialize globals
////////////////////////////////////////////////////////////////////////////////
void TRI_InitServerGlobals () {
@ -1863,16 +1780,6 @@ void TRI_InitServerGlobals () {
PageSize = (size_t) getpagesize();
memset(&ServerId, 0, sizeof(TRI_server_id_t));
TRI_InitSpin(&TickLock);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief de-initialise globals
////////////////////////////////////////////////////////////////////////////////
void TRI_FreeServerGlobals () {
TRI_DestroySpin(&TickLock);
}
// -----------------------------------------------------------------------------
@ -2077,7 +1984,7 @@ int TRI_StartServer (TRI_server_t* server,
////////////////////////////////////////////////////////////////////////////////
int TRI_InitDatabasesServer (TRI_server_t* server) {
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
size_t const n = server->_databases._nrAlloc;
@ -2159,7 +2066,7 @@ int TRI_CreateCoordinatorDatabaseServer (TRI_server_t* server,
MUTEX_LOCKER(DatabaseCreateLock);
{
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
TRI_vocbase_t* vocbase = static_cast<TRI_vocbase_t*>(TRI_LookupByKeyAssociativePointer(&server->_coordinatorDatabases, name));
@ -2207,7 +2114,7 @@ int TRI_CreateCoordinatorDatabaseServer (TRI_server_t* server,
vocbase->_state = (sig_atomic_t) TRI_VOCBASE_STATE_NORMAL;
{
DatabaseWriteLocker locker(&server->_databasesLock);
WRITE_LOCKER_EVENTUAL(server->_databasesLock, 1000);
if (TRI_InsertKeyAssociativePointer(&server->_coordinatorDatabases, vocbase->_name, vocbase, false) != nullptr) {
// this shouldn't happen, since we will leak and not replace the new database.
@ -2245,7 +2152,7 @@ int TRI_CreateDatabaseServer (TRI_server_t* server,
{
{
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
vocbase = static_cast<TRI_vocbase_t*>(TRI_LookupByKeyAssociativePointer(&server->_databases, name));
@ -2348,7 +2255,7 @@ int TRI_CreateDatabaseServer (TRI_server_t* server,
}
{
DatabaseWriteLocker locker(&server->_databasesLock);
WRITE_LOCKER_EVENTUAL(server->_databasesLock, 1000);
TRI_InsertKeyAssociativePointer(&server->_databases, vocbase->_name, vocbase, false);
}
@ -2377,7 +2284,8 @@ TRI_voc_tick_t* TRI_GetIdsCoordinatorDatabaseServer (TRI_server_t* server) {
TRI_InitVector(&v, TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_voc_tick_t));
{
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
size_t const n = server->_coordinatorDatabases._nrAlloc;
for (size_t i = 0; i < n; ++i) {
@ -2412,10 +2320,13 @@ int TRI_DropByIdCoordinatorDatabaseServer (TRI_server_t* server,
bool force) {
int res = TRI_ERROR_ARANGO_DATABASE_NOT_FOUND;
DatabaseWriteLocker locker(&server->_databasesLock);
WRITE_LOCKER_EVENTUAL(server->_databasesLock, 1000);
if (TRI_ReserveVectorPointer(&server->_droppedDatabases, 1) != TRI_ERROR_NO_ERROR) {
try {
// we need space for one more element
server->_droppedDatabases.reserve(server->_droppedDatabases.size() + 1);
}
catch (...) {
return TRI_ERROR_OUT_OF_MEMORY;
}
@ -2432,7 +2343,7 @@ int TRI_DropByIdCoordinatorDatabaseServer (TRI_server_t* server,
LOG_INFO("dropping coordinator database '%s'",
vocbase->_name);
TRI_PushBackVectorPointer(&server->_droppedDatabases, vocbase);
server->_droppedDatabases.emplace_back(vocbase);
res = TRI_ERROR_NO_ERROR;
}
break;
@ -2453,10 +2364,13 @@ int TRI_DropCoordinatorDatabaseServer (TRI_server_t* server,
return TRI_ERROR_FORBIDDEN;
}
DatabaseWriteLocker locker(&server->_databasesLock);
WRITE_LOCKER_EVENTUAL(server->_databasesLock, 1000);
if (TRI_ReserveVectorPointer(&server->_droppedDatabases, 1) != TRI_ERROR_NO_ERROR) {
try {
// we need space for one more element
server->_droppedDatabases.reserve(server->_droppedDatabases.size() + 1);
}
catch (...) {
return TRI_ERROR_OUT_OF_MEMORY;
}
@ -2474,8 +2388,8 @@ int TRI_DropCoordinatorDatabaseServer (TRI_server_t* server,
if (TRI_DropVocBase(vocbase)) {
LOG_INFO("dropping coordinator database '%s'",
vocbase->_name);
TRI_PushBackVectorPointer(&server->_droppedDatabases, vocbase);
server->_droppedDatabases.emplace_back(vocbase);
res = TRI_ERROR_NO_ERROR;
}
else {
@ -2500,10 +2414,13 @@ int TRI_DropDatabaseServer (TRI_server_t* server,
return TRI_ERROR_FORBIDDEN;
}
DatabaseWriteLocker locker(&server->_databasesLock);
WRITE_LOCKER_EVENTUAL(server->_databasesLock, 1000);
if (TRI_ReserveVectorPointer(&server->_droppedDatabases, 1) != TRI_ERROR_NO_ERROR) {
try {
// we need space for one more element
server->_droppedDatabases.reserve(server->_droppedDatabases.size() + 1);
}
catch (...) {
return TRI_ERROR_OUT_OF_MEMORY;
}
@ -2541,7 +2458,7 @@ int TRI_DropDatabaseServer (TRI_server_t* server,
vocbase->_path);
// TODO: what to do here in case of error?
TRI_PushBackVectorPointer(&server->_droppedDatabases, vocbase);
server->_droppedDatabases.emplace_back(vocbase);
if (writeMarker) {
WriteDropMarker(vocbase->_id);
@ -2565,7 +2482,7 @@ int TRI_DropByIdDatabaseServer (TRI_server_t* server,
std::string name;
{
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
size_t const n = server->_databases._nrAlloc;
@ -2590,7 +2507,8 @@ int TRI_DropByIdDatabaseServer (TRI_server_t* server,
TRI_vocbase_t* TRI_UseByIdCoordinatorDatabaseServer (TRI_server_t* server,
TRI_voc_tick_t id) {
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
size_t const n = server->_coordinatorDatabases._nrAlloc;
for (size_t i = 0; i < n; ++i) {
@ -2615,7 +2533,7 @@ TRI_vocbase_t* TRI_UseByIdCoordinatorDatabaseServer (TRI_server_t* server,
TRI_vocbase_t* TRI_UseCoordinatorDatabaseServer (TRI_server_t* server,
char const* name) {
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
TRI_vocbase_t* vocbase = static_cast<TRI_vocbase_t*>(TRI_LookupByKeyAssociativePointer(&server->_coordinatorDatabases, name));
@ -2633,7 +2551,7 @@ TRI_vocbase_t* TRI_UseCoordinatorDatabaseServer (TRI_server_t* server,
TRI_vocbase_t* TRI_UseDatabaseServer (TRI_server_t* server,
char const* name) {
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
TRI_vocbase_t* vocbase = static_cast<TRI_vocbase_t*>(TRI_LookupByKeyAssociativePointer(&server->_databases, name));
@ -2650,7 +2568,8 @@ TRI_vocbase_t* TRI_UseDatabaseServer (TRI_server_t* server,
TRI_vocbase_t* TRI_LookupDatabaseByIdServer (TRI_server_t* server,
TRI_voc_tick_t id) {
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
size_t const n = server->_databases._nrAlloc;
for (size_t i = 0; i < n; ++i) {
@ -2670,7 +2589,8 @@ TRI_vocbase_t* TRI_LookupDatabaseByIdServer (TRI_server_t* server,
TRI_vocbase_t* TRI_LookupDatabaseByNameServer (TRI_server_t* server,
char const* name) {
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
size_t const n = server->_databases._nrAlloc;
for (size_t i = 0; i < n; ++i) {
@ -2691,7 +2611,8 @@ TRI_vocbase_t* TRI_LookupDatabaseByNameServer (TRI_server_t* server,
TRI_vocbase_t* TRI_UseDatabaseByIdServer (TRI_server_t* server,
TRI_voc_tick_t id) {
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
size_t const n = server->_databases._nrAlloc;
for (size_t i = 0; i < n; ++i) {
@ -2723,7 +2644,8 @@ void TRI_ReleaseDatabaseServer (TRI_server_t* server,
bool TRI_ExistsDatabaseByIdServer (TRI_server_t* server,
TRI_voc_tick_t id) {
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
size_t const n = server->_databases._nrAlloc;
for (size_t i = 0; i < n; ++i) {
@ -2748,7 +2670,8 @@ int TRI_GetUserDatabasesServer (TRI_server_t* server,
int res = TRI_ERROR_NO_ERROR;
{
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
size_t const n = server->_databases._nrAlloc;
for (size_t i = 0; i < n; ++i) {
@ -2794,7 +2717,8 @@ int TRI_GetDatabaseNamesServer (TRI_server_t* server,
int res = TRI_ERROR_NO_ERROR;
{
DatabaseReadLocker locker(&server->_databasesLock);
READ_LOCKER(server->_databasesLock);
size_t const n = server->_databases._nrAlloc;
for (size_t i = 0; i < n; ++i) {
@ -2848,12 +2772,10 @@ void TRI_GetDatabaseDefaultsServer (TRI_server_t* server,
TRI_voc_tick_t TRI_NewTickServer () {
uint64_t tick = ServerIdentifier;
TRI_LockSpin(&TickLock);
SPIN_LOCKER(TickLock);
tick |= (++CurrentTick) << 16;
TRI_UnlockSpin(&TickLock);
return tick;
}
@ -2862,9 +2784,8 @@ TRI_voc_tick_t TRI_NewTickServer () {
////////////////////////////////////////////////////////////////////////////////
void TRI_UpdateTickServer (TRI_voc_tick_t tick) {
TRI_LockSpin(&TickLock);
SPIN_LOCKER(TickLock);
UpdateTick(tick);
TRI_UnlockSpin(&TickLock);
}
////////////////////////////////////////////////////////////////////////////////
@ -2880,13 +2801,8 @@ void TRI_FastUpdateTickServer (TRI_voc_tick_t tick) {
////////////////////////////////////////////////////////////////////////////////
TRI_voc_tick_t TRI_CurrentTickServer () {
TRI_voc_tick_t tick;
TRI_LockSpin(&TickLock);
tick = GetTick();
TRI_UnlockSpin(&TickLock);
return tick;
SPIN_LOCKER(TickLock);
return GetTick();
}
// -----------------------------------------------------------------------------
@ -2936,6 +2852,40 @@ int TRI_ChangeOperationModeServer (TRI_vocbase_operationmode_e mode) {
TRI_vocbase_operationmode_e TRI_GetOperationModeServer () {
return Mode;
}
// -----------------------------------------------------------------------------
// --SECTION-- TRI_server_t
// -----------------------------------------------------------------------------
TRI_server_t::TRI_server_t ()
: _applicationEndpointServer(nullptr),
_indexPool(nullptr),
_queryRegistry(nullptr),
_basePath(nullptr),
_databasePath(nullptr),
_lockFilename(nullptr),
_serverIdFilename(nullptr),
_appPath(nullptr),
_disableReplicationAppliers(false),
_iterateMarkersOnOpen(false),
_hasCreatedSystemDatabase(false),
_initialized(false) {
}
TRI_server_t::~TRI_server_t () {
if (_initialized) {
CloseDatabases(this);
TRI_DestroyAssociativePointer(&_coordinatorDatabases);
TRI_DestroyAssociativePointer(&_databases);
TRI_Free(TRI_CORE_MEM_ZONE, _appPath);
TRI_Free(TRI_CORE_MEM_ZONE, _serverIdFilename);
TRI_Free(TRI_CORE_MEM_ZONE, _lockFilename);
TRI_Free(TRI_CORE_MEM_ZONE, _databasePath);
TRI_Free(TRI_CORE_MEM_ZONE, _basePath);
}
}
// -----------------------------------------------------------------------------
// --SECTION-- END-OF-FILE

View File

@ -33,6 +33,7 @@
#include "Basics/Common.h"
#include "Basics/associative.h"
#include "Basics/locks.h"
#include "Basics/ReadWriteLock.h"
#include "Basics/threads.h"
#include "Basics/vector.h"
#include "VocBase/voc-types.h"
@ -40,6 +41,18 @@
struct TRI_vocbase_t;
namespace triagens {
namespace aql {
class QueryRegistry;
}
namespace basics {
class ThreadPool;
}
namespace rest {
class ApplicationEndpointServer;
}
}
// -----------------------------------------------------------------------------
// --SECTION-- public types
// -----------------------------------------------------------------------------
@ -48,33 +61,33 @@ struct TRI_vocbase_t;
/// @brief server structure
////////////////////////////////////////////////////////////////////////////////
typedef struct TRI_server_s {
TRI_associative_pointer_t _databases;
TRI_associative_pointer_t _coordinatorDatabases;
TRI_read_write_lock_t _databasesLock;
struct TRI_server_t {
TRI_server_t ();
~TRI_server_t ();
TRI_thread_t _databaseManager;
TRI_vector_pointer_t _droppedDatabases;
TRI_associative_pointer_t _databases;
TRI_associative_pointer_t _coordinatorDatabases;
triagens::basics::ReadWriteLock _databasesLock;
TRI_vocbase_defaults_t _defaults;
void* _applicationEndpointServer; // ptr to C++ object
void* _indexPool; // ptr to C++ object
TRI_thread_t _databaseManager;
std::vector<TRI_vocbase_t*> _droppedDatabases;
char* _basePath;
char* _databasePath;
char* _lockFilename;
char* _serverIdFilename;
TRI_vocbase_defaults_t _defaults;
triagens::rest::ApplicationEndpointServer* _applicationEndpointServer;
triagens::basics::ThreadPool* _indexPool;
triagens::aql::QueryRegistry* _queryRegistry;
char* _appPath;
char* _basePath;
char* _databasePath;
char* _lockFilename;
char* _serverIdFilename;
char* _appPath;
bool _disableReplicationAppliers;
bool _iterateMarkersOnOpen;
bool _hasCreatedSystemDatabase;
bool _initialised;
void* _queryRegistry;
}
TRI_server_t;
bool _disableReplicationAppliers;
bool _iterateMarkersOnOpen;
bool _hasCreatedSystemDatabase;
bool _initialized;
};
////////////////////////////////////////////////////////////////////////////////
/// @brief page size
@ -86,19 +99,13 @@ extern size_t PageSize;
// --SECTION-- constructors / destructors
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief create a server instance
////////////////////////////////////////////////////////////////////////////////
TRI_server_t* TRI_CreateServer (void);
////////////////////////////////////////////////////////////////////////////////
/// @brief initialise a server instance with configuration
////////////////////////////////////////////////////////////////////////////////
int TRI_InitServer (TRI_server_t*,
void*,
void*,
triagens::rest::ApplicationEndpointServer*,
triagens::basics::ThreadPool*,
char const*,
char const*,
TRI_vocbase_defaults_t const*,
@ -106,29 +113,11 @@ int TRI_InitServer (TRI_server_t*,
bool);
////////////////////////////////////////////////////////////////////////////////
/// @brief destroy a server instance
////////////////////////////////////////////////////////////////////////////////
void TRI_DestroyServer (TRI_server_t*);
////////////////////////////////////////////////////////////////////////////////
/// @brief free a server instance
////////////////////////////////////////////////////////////////////////////////
void TRI_FreeServer (TRI_server_t*);
////////////////////////////////////////////////////////////////////////////////
/// @brief initialise globals
/// @brief initialize globals
////////////////////////////////////////////////////////////////////////////////
void TRI_InitServerGlobals (void);
////////////////////////////////////////////////////////////////////////////////
/// @brief de-initialise globals
////////////////////////////////////////////////////////////////////////////////
void TRI_FreeServerGlobals (void);
// -----------------------------------------------------------------------------
// --SECTION-- public functions
// -----------------------------------------------------------------------------

View File

@ -217,7 +217,7 @@ static bool UnregisterCollection (TRI_vocbase_t* vocbase,
TRI_vocbase_col_t* collection) {
TRI_ASSERT(collection != nullptr);
TRI_WRITE_LOCK_COLLECTIONS_VOCBASE(vocbase);
WRITE_LOCKER(vocbase->_collectionsLock);
// pre-condition
TRI_ASSERT(vocbase->_collectionsByName._nrUsed == vocbase->_collectionsById._nrUsed);
@ -232,8 +232,6 @@ static bool UnregisterCollection (TRI_vocbase_t* vocbase,
// post-condition
TRI_ASSERT_EXPENSIVE(vocbase->_collectionsByName._nrUsed == vocbase->_collectionsById._nrUsed);
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
return true;
}
@ -377,20 +375,19 @@ static bool DropCollectionCallback (TRI_collection_t* col,
vocbase = collection->_vocbase;
TRI_WRITE_LOCK_COLLECTIONS_VOCBASE(vocbase);
{
WRITE_LOCKER(vocbase->_collectionsLock);
auto it = std::find(vocbase->_collections.begin(), vocbase->_collections.end(), collection);
auto it = std::find(vocbase->_collections.begin(), vocbase->_collections.end(), collection);
if (it != vocbase->_collections.end()) {
vocbase->_collections.erase(it);
if (it != vocbase->_collections.end()) {
vocbase->_collections.erase(it);
}
// we need to clean up the pointers later so we insert it into this vector
vocbase->_deadCollections.emplace_back(collection);
}
// we need to clean up the pointers later so we insert it into this vector
vocbase->_deadCollections.emplace_back(collection);
// we are now done with the vocbase structure
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
// .............................................................................
// rename collection directory
// .............................................................................
@ -480,7 +477,7 @@ static bool DropCollectionCallback (TRI_collection_t* col,
////////////////////////////////////////////////////////////////////////////////
/// @brief adds a new collection
///
/// Caller must hold TRI_WRITE_LOCK_COLLECTIONS_VOCBASE.
/// Caller must hold _collectionsLock in write mode
////////////////////////////////////////////////////////////////////////////////
static TRI_vocbase_col_t* AddCollection (TRI_vocbase_t* vocbase,
@ -592,7 +589,7 @@ static TRI_vocbase_col_t* AddCollection (TRI_vocbase_t* vocbase,
TRI_InitReadWriteLock(&collection->_lock);
// this needs TRI_WRITE_LOCK_COLLECTIONS_VOCBASE
// this needs the write lock on _collectionsLock
vocbase->_collections.emplace_back(collection);
return collection;
}
@ -604,10 +601,12 @@ static TRI_vocbase_col_t* AddCollection (TRI_vocbase_t* vocbase,
static TRI_vocbase_col_t* CreateCollection (TRI_vocbase_t* vocbase,
TRI_col_info_t* parameter,
TRI_voc_cid_t cid,
bool writeMarker) {
bool writeMarker,
TRI_json_t*& json) {
TRI_ASSERT(json == nullptr);
char const* name = parameter->_name;
TRI_WRITE_LOCK_COLLECTIONS_VOCBASE(vocbase);
WRITE_LOCKER(vocbase->_collectionsLock);
try {
// reserve room for collection
@ -615,8 +614,6 @@ static TRI_vocbase_col_t* CreateCollection (TRI_vocbase_t* vocbase,
vocbase->_deadCollections.reserve(vocbase->_deadCollections.size() + 1);
}
catch (...) {
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY);
return nullptr;
}
@ -628,8 +625,6 @@ static TRI_vocbase_col_t* CreateCollection (TRI_vocbase_t* vocbase,
void const* found = TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsByName, name);
if (found != nullptr) {
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_set_errno(TRI_ERROR_ARANGO_DUPLICATE_NAME);
return nullptr;
}
@ -641,8 +636,6 @@ static TRI_vocbase_col_t* CreateCollection (TRI_vocbase_t* vocbase,
TRI_document_collection_t* document = TRI_CreateDocumentCollection(vocbase, vocbase->_path, parameter, cid);
if (document == nullptr) {
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
return nullptr;
}
@ -656,8 +649,6 @@ static TRI_vocbase_col_t* CreateCollection (TRI_vocbase_t* vocbase,
col->_directory);
if (collection == nullptr) {
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_CloseDocumentCollection(document, false);
TRI_FreeDocumentCollection(document);
// TODO: does the collection directory need to be removed?
@ -678,47 +669,10 @@ static TRI_vocbase_col_t* CreateCollection (TRI_vocbase_t* vocbase,
document->_directory,
sizeof(collection->_path) - 1);
TRI_json_t* json = nullptr;
if (writeMarker) {
json = TRI_CreateJsonCollectionInfo(&col->_info);
if (json == nullptr) {
// TODO: revert the operation
return collection;
}
}
// release the lock on the list of collections
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
if (! writeMarker) {
return collection;
}
int res = TRI_ERROR_NO_ERROR;
try {
triagens::wal::CreateCollectionMarker marker(vocbase->_id, cid, triagens::basics::JsonHelper::toString(json));
triagens::wal::SlotInfoCopy slotInfo = triagens::wal::LogfileManager::instance()->allocateAndWrite(marker, false);
if (slotInfo.errorCode != TRI_ERROR_NO_ERROR) {
THROW_ARANGO_EXCEPTION(slotInfo.errorCode);
}
TRI_FreeJson(TRI_CORE_MEM_ZONE, json);
return collection;
}
catch (triagens::basics::Exception const& ex) {
res = ex.code();
}
catch (...) {
res = TRI_ERROR_INTERNAL;
}
TRI_FreeJson(TRI_CORE_MEM_ZONE, json);
LOG_WARNING("could not save collection create marker in log: %s", TRI_errno_string(res));
// TODO: what to do here?
return collection;
}
@ -729,112 +683,88 @@ static TRI_vocbase_col_t* CreateCollection (TRI_vocbase_t* vocbase,
static int RenameCollection (TRI_vocbase_t* vocbase,
TRI_vocbase_col_t* collection,
char const* oldName,
char const* newName,
bool writeMarker) {
TRI_col_info_t info;
TRI_EVENTUAL_WRITE_LOCK_STATUS_VOCBASE_COL(collection);
// this must be done after the collection lock
TRI_WRITE_LOCK_COLLECTIONS_VOCBASE(vocbase);
char const* newName) {
// cannot rename a corrupted collection
if (collection->_status == TRI_VOC_COL_STATUS_CORRUPTED) {
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_WRITE_UNLOCK_STATUS_VOCBASE_COL(collection);
return TRI_set_errno(TRI_ERROR_ARANGO_CORRUPTED_COLLECTION);
}
// cannot rename a deleted collection
if (collection->_status == TRI_VOC_COL_STATUS_DELETED) {
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_WRITE_UNLOCK_STATUS_VOCBASE_COL(collection);
return TRI_set_errno(TRI_ERROR_ARANGO_COLLECTION_NOT_FOUND);
}
// check if the new name is unused
void const* found = TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsByName, newName);
{
WRITE_LOCKER(vocbase->_collectionsLock);
if (found != nullptr) {
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_WRITE_UNLOCK_STATUS_VOCBASE_COL(collection);
// check if the new name is unused
void const* found = TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsByName, newName);
return TRI_set_errno(TRI_ERROR_ARANGO_DUPLICATE_NAME);
}
// .............................................................................
// collection is unloaded
// .............................................................................
else if (collection->_status == TRI_VOC_COL_STATUS_UNLOADED) {
int res = TRI_LoadCollectionInfo(collection->_path, &info, true);
if (res != TRI_ERROR_NO_ERROR) {
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_WRITE_UNLOCK_STATUS_VOCBASE_COL(collection);
return TRI_set_errno(res);
if (found != nullptr) {
return TRI_set_errno(TRI_ERROR_ARANGO_DUPLICATE_NAME);
}
TRI_CopyString(info._name, newName, sizeof(info._name) - 1);
// .............................................................................
// collection is unloaded
// .............................................................................
res = TRI_SaveCollectionInfo(collection->_path, &info, vocbase->_settings.forceSyncProperties);
else if (collection->_status == TRI_VOC_COL_STATUS_UNLOADED) {
TRI_col_info_t info;
int res = TRI_LoadCollectionInfo(collection->_path, &info, true);
TRI_FreeCollectionInfoOptions(&info);
if (res != TRI_ERROR_NO_ERROR) {
return TRI_set_errno(res);
}
if (res != TRI_ERROR_NO_ERROR) {
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_WRITE_UNLOCK_STATUS_VOCBASE_COL(collection);
TRI_CopyString(info._name, newName, sizeof(info._name) - 1);
return TRI_set_errno(res);
res = TRI_SaveCollectionInfo(collection->_path, &info, vocbase->_settings.forceSyncProperties);
TRI_FreeCollectionInfoOptions(&info);
if (res != TRI_ERROR_NO_ERROR) {
return TRI_set_errno(res);
}
// fall-through intentional
}
}
// .............................................................................
// collection is loaded
// .............................................................................
// .............................................................................
// collection is loaded
// .............................................................................
else if (collection->_status == TRI_VOC_COL_STATUS_LOADED ||
collection->_status == TRI_VOC_COL_STATUS_UNLOADING ||
collection->_status == TRI_VOC_COL_STATUS_LOADING) {
else if (collection->_status == TRI_VOC_COL_STATUS_LOADED ||
collection->_status == TRI_VOC_COL_STATUS_UNLOADING ||
collection->_status == TRI_VOC_COL_STATUS_LOADING) {
int res = TRI_RenameCollection(collection->_collection, newName);
int res = TRI_RenameCollection(collection->_collection, newName);
if (res != TRI_ERROR_NO_ERROR) {
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_WRITE_UNLOCK_STATUS_VOCBASE_COL(collection);
return TRI_set_errno(res);
if (res != TRI_ERROR_NO_ERROR) {
return TRI_set_errno(res);
}
// fall-through intentional
}
}
// .............................................................................
// upps, unknown status
// .............................................................................
// .............................................................................
// unknown status
// .............................................................................
else {
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_WRITE_UNLOCK_STATUS_VOCBASE_COL(collection);
else {
return TRI_set_errno(TRI_ERROR_INTERNAL);
}
return TRI_set_errno(TRI_ERROR_INTERNAL);
}
// .............................................................................
// rename and release locks
// .............................................................................
// .............................................................................
// rename and release locks
// .............................................................................
TRI_RemoveKeyAssociativePointer(&vocbase->_collectionsByName, oldName);
TRI_CopyString(collection->_name, newName, sizeof(collection->_name) - 1);
TRI_RemoveKeyAssociativePointer(&vocbase->_collectionsByName, oldName);
TRI_CopyString(collection->_name, newName, sizeof(collection->_name) - 1);
// this shouldn't fail, as we removed an element above so adding one should be ok
found = TRI_InsertKeyAssociativePointer(&vocbase->_collectionsByName, newName, CONST_CAST(collection), false);
TRI_ASSERT(found == nullptr);
// this shouldn't fail, as we removed an element above so adding one should be ok
found = TRI_InsertKeyAssociativePointer(&vocbase->_collectionsByName, newName, CONST_CAST(collection), false);
TRI_ASSERT(found == nullptr);
TRI_ASSERT_EXPENSIVE(vocbase->_collectionsByName._nrUsed == vocbase->_collectionsById._nrUsed);
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_ASSERT_EXPENSIVE(vocbase->_collectionsByName._nrUsed == vocbase->_collectionsById._nrUsed);
} // _colllectionsLock
// to prevent caching returning now invalid old collection name in db's NamedPropertyAccessor,
// i.e. db.<old-collection-name>
@ -843,37 +773,7 @@ static int RenameCollection (TRI_vocbase_t* vocbase,
// invalidate all entries for the two collections
triagens::aql::QueryCache::instance()->invalidate(vocbase, std::vector<char const*>{ oldName, newName });
TRI_WRITE_UNLOCK_STATUS_VOCBASE_COL(collection);
if (! writeMarker) {
return TRI_ERROR_NO_ERROR;
}
// now log the operation
int res = TRI_ERROR_NO_ERROR;
try {
triagens::wal::RenameCollectionMarker marker(vocbase->_id, collection->_cid, std::string(newName));
triagens::wal::SlotInfoCopy slotInfo = triagens::wal::LogfileManager::instance()->allocateAndWrite(marker, false);
if (slotInfo.errorCode != TRI_ERROR_NO_ERROR) {
THROW_ARANGO_EXCEPTION(slotInfo.errorCode);
}
return TRI_ERROR_NO_ERROR;
}
catch (triagens::basics::Exception const& ex) {
res = ex.code();
}
catch (...) {
res = TRI_ERROR_INTERNAL;
}
if (res != TRI_ERROR_NO_ERROR) {
LOG_WARNING("could not save collection rename marker in log: %s", TRI_errno_string(res));
}
return res;
return TRI_ERROR_NO_ERROR;
}
////////////////////////////////////////////////////////////////////////////////
@ -1594,9 +1494,10 @@ void TRI_DestroyVocBase (TRI_vocbase_t* vocbase) {
std::vector<TRI_vocbase_col_t*> collections;
TRI_WRITE_LOCK_COLLECTIONS_VOCBASE(vocbase);
collections = vocbase->_collections;
TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
{
WRITE_LOCKER(vocbase->_collectionsLock);
collections = vocbase->_collections;
}
// from here on, the vocbase is unusable, i.e. no collections can be created/loaded etc.
@ -1683,23 +1584,19 @@ int TRI_StopCompactorVocBase (TRI_vocbase_t* vocbase) {
/// @brief returns all known (document) collections
////////////////////////////////////////////////////////////////////////////////
TRI_vector_pointer_t TRI_CollectionsVocBase (TRI_vocbase_t* vocbase) {
TRI_vector_pointer_t result;
std::vector<TRI_vocbase_col_t*> TRI_CollectionsVocBase (TRI_vocbase_t* vocbase) {
std::vector<TRI_vocbase_col_t*> result;
TRI_InitVectorPointer(&result, TRI_UNKNOWN_MEM_ZONE);
TRI_READ_LOCK_COLLECTIONS_VOCBASE(vocbase);
READ_LOCKER(vocbase->_collectionsLock);
for (size_t i = 0; i < vocbase->_collectionsById._nrAlloc; ++i) {
TRI_vocbase_col_t* found = static_cast<TRI_vocbase_col_t*>(vocbase->_collectionsById._table[i]);
if (found != nullptr) {
TRI_PushBackVectorPointer(&result, found);
result.emplace_back(found);
}
}
TRI_READ_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
return result;
}
@ -1707,12 +1604,10 @@ TRI_vector_pointer_t TRI_CollectionsVocBase (TRI_vocbase_t* vocbase) {
/// @brief returns names of all known (document) collections
////////////////////////////////////////////////////////////////////////////////
TRI_vector_string_t TRI_CollectionNamesVocBase (TRI_vocbase_t* vocbase) {
TRI_vector_string_t result;
std::vector<std::string> TRI_CollectionNamesVocBase (TRI_vocbase_t* vocbase) {
std::vector<std::string> result;
TRI_InitVectorString(&result, TRI_UNKNOWN_MEM_ZONE);
TRI_READ_LOCK_COLLECTIONS_VOCBASE(vocbase);
READ_LOCKER(vocbase->_collectionsLock);
for (size_t i = 0; i < vocbase->_collectionsById._nrAlloc; ++i) {
TRI_vocbase_col_t* found = static_cast<TRI_vocbase_col_t*>(vocbase->_collectionsById._table[i]);
@ -1721,13 +1616,11 @@ TRI_vector_string_t TRI_CollectionNamesVocBase (TRI_vocbase_t* vocbase) {
char const* name = found->_name;
if (name != nullptr) {
TRI_PushBackVectorString(&result, TRI_DuplicateStringZ(TRI_UNKNOWN_MEM_ZONE, name));
result.emplace_back(std::string(name));
}
}
}
TRI_READ_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
return result;
}
@ -1755,9 +1648,10 @@ TRI_json_t* TRI_InventoryCollectionsVocBase (TRI_vocbase_t* vocbase,
// copy collection pointers into vector so we can work with the copy without
// the global lock
TRI_READ_LOCK_COLLECTIONS_VOCBASE(vocbase);
collections = vocbase->_collections;
TRI_READ_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
{
READ_LOCKER(vocbase->_collectionsLock);
collections = vocbase->_collections;
}
for (auto& collection : collections) {
TRI_READ_LOCK_STATUS_VOCBASE_COL(collection);
@ -1843,12 +1737,11 @@ const char* TRI_GetStatusStringCollectionVocBase (TRI_vocbase_col_status_e statu
char* TRI_GetCollectionNameByIdVocBase (TRI_vocbase_t* vocbase,
const TRI_voc_cid_t id) {
char* name;
TRI_READ_LOCK_COLLECTIONS_VOCBASE(vocbase);
READ_LOCKER(vocbase->_collectionsLock);
TRI_vocbase_col_t* found = static_cast<TRI_vocbase_col_t*>(TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsById, &id));
char* name;
if (found == nullptr) {
name = nullptr;
}
@ -1856,8 +1749,6 @@ char* TRI_GetCollectionNameByIdVocBase (TRI_vocbase_t* vocbase,
name = TRI_DuplicateStringZ(TRI_UNKNOWN_MEM_ZONE, found->_name);
}
TRI_READ_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
return name;
}
@ -1876,11 +1767,8 @@ TRI_vocbase_col_t* TRI_LookupCollectionByNameVocBase (TRI_vocbase_t* vocbase,
}
// otherwise we'll look up the collection by name
TRI_READ_LOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_vocbase_col_t* found = static_cast<TRI_vocbase_col_t*>(TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsByName, name));
TRI_READ_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
return found;
READ_LOCKER(vocbase->_collectionsLock);
return static_cast<TRI_vocbase_col_t*>(TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsByName, name));
}
////////////////////////////////////////////////////////////////////////////////
@ -1889,11 +1777,8 @@ TRI_vocbase_col_t* TRI_LookupCollectionByNameVocBase (TRI_vocbase_t* vocbase,
TRI_vocbase_col_t* TRI_LookupCollectionByIdVocBase (TRI_vocbase_t* vocbase,
TRI_voc_cid_t id) {
TRI_READ_LOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_vocbase_col_t* found = static_cast<TRI_vocbase_col_t*>(TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsById, &id));
TRI_READ_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
return found;
READ_LOCKER(vocbase->_collectionsLock);
return static_cast<TRI_vocbase_col_t*>(TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsById, &id));
}
////////////////////////////////////////////////////////////////////////////////
@ -1909,21 +1794,23 @@ TRI_vocbase_col_t* TRI_FindCollectionByNameOrCreateVocBase (TRI_vocbase_t* vocba
TRI_vocbase_col_t* found = nullptr;
TRI_READ_LOCK_COLLECTIONS_VOCBASE(vocbase);
if (name[0] >= '0' && name[0] <= '9') {
// support lookup by id, too
try {
TRI_voc_cid_t id = triagens::basics::StringUtils::uint64(name, strlen(name));
found = static_cast<TRI_vocbase_col_t*>(TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsById, &id));
{
READ_LOCKER(vocbase->_collectionsLock);
if (name[0] >= '0' && name[0] <= '9') {
// support lookup by id, too
try {
TRI_voc_cid_t id = triagens::basics::StringUtils::uint64(name, strlen(name));
found = static_cast<TRI_vocbase_col_t*>(TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsById, &id));
}
catch (...) {
// no need to throw here... found will still be a nullptr
}
}
catch (...) {
// no need to throw here... found will still be a nullptr
else {
found = static_cast<TRI_vocbase_col_t*>(TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsByName, name));
}
}
else {
found = static_cast<TRI_vocbase_col_t*>(TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsByName, name));
}
TRI_READ_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
if (found != nullptr) {
return found;
@ -1970,7 +1857,44 @@ TRI_vocbase_col_t* TRI_CreateCollectionVocBase (TRI_vocbase_t* vocbase,
READ_LOCKER(vocbase->_inventoryLock);
return CreateCollection(vocbase, parameters, cid, writeMarker);
TRI_json_t* json = nullptr;
auto collection = CreateCollection(vocbase, parameters, cid, writeMarker, json);
if (! writeMarker) {
TRI_ASSERT(json == nullptr);
return collection;
}
if (json == nullptr) {
// TODO: what to do here?
return collection;
}
int res = TRI_ERROR_NO_ERROR;
try {
triagens::wal::CreateCollectionMarker marker(vocbase->_id, cid, triagens::basics::JsonHelper::toString(json));
triagens::wal::SlotInfoCopy slotInfo = triagens::wal::LogfileManager::instance()->allocateAndWrite(marker, false);
if (slotInfo.errorCode != TRI_ERROR_NO_ERROR) {
THROW_ARANGO_EXCEPTION(slotInfo.errorCode);
}
TRI_FreeJson(TRI_CORE_MEM_ZONE, json);
return collection;
}
catch (triagens::basics::Exception const& ex) {
res = ex.code();
}
catch (...) {
res = TRI_ERROR_INTERNAL;
}
TRI_FreeJson(TRI_CORE_MEM_ZONE, json);
LOG_WARNING("could not save collection create marker in log: %s", TRI_errno_string(res));
// TODO: what to do here?
return collection;
}
////////////////////////////////////////////////////////////////////////////////
@ -2158,7 +2082,35 @@ int TRI_RenameCollectionVocBase (TRI_vocbase_t* vocbase,
READ_LOCKER(vocbase->_inventoryLock);
int res = RenameCollection(vocbase, collection, oldName, newName, writeMarker);
TRI_EVENTUAL_WRITE_LOCK_STATUS_VOCBASE_COL(collection);
int res = RenameCollection(vocbase, collection, oldName, newName);
TRI_WRITE_UNLOCK_STATUS_VOCBASE_COL(collection);
if (res == TRI_ERROR_NO_ERROR && writeMarker) {
// now log the operation
try {
triagens::wal::RenameCollectionMarker marker(vocbase->_id, collection->_cid, std::string(newName));
triagens::wal::SlotInfoCopy slotInfo = triagens::wal::LogfileManager::instance()->allocateAndWrite(marker, false);
if (slotInfo.errorCode != TRI_ERROR_NO_ERROR) {
THROW_ARANGO_EXCEPTION(slotInfo.errorCode);
}
return TRI_ERROR_NO_ERROR;
}
catch (triagens::basics::Exception const& ex) {
res = ex.code();
}
catch (...) {
res = TRI_ERROR_INTERNAL;
}
if (res != TRI_ERROR_NO_ERROR) {
LOG_WARNING("could not save collection rename marker in log: %s", TRI_errno_string(res));
}
}
TRI_FreeString(TRI_CORE_MEM_ZONE, oldName);
@ -2186,9 +2138,11 @@ TRI_vocbase_col_t* TRI_UseCollectionByIdVocBase (TRI_vocbase_t* vocbase,
// check that we have an existing name
// .............................................................................
TRI_READ_LOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_vocbase_col_t const* collection = static_cast<TRI_vocbase_col_t const*>(TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsById, &cid));
TRI_READ_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_vocbase_col_t const* collection = nullptr;
{
READ_LOCKER(vocbase->_collectionsLock);
collection = static_cast<TRI_vocbase_col_t const*>(TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsById, &cid));
}
if (collection == nullptr) {
TRI_set_errno(TRI_ERROR_ARANGO_COLLECTION_NOT_FOUND);
@ -2221,9 +2175,12 @@ TRI_vocbase_col_t* TRI_UseCollectionByNameVocBase (TRI_vocbase_t* vocbase,
// check that we have an existing name
// .............................................................................
TRI_READ_LOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_vocbase_col_t const* collection = static_cast<TRI_vocbase_col_t const*>(TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsByName, name));
TRI_READ_UNLOCK_COLLECTIONS_VOCBASE(vocbase);
TRI_vocbase_col_t const* collection = nullptr;
{
READ_LOCKER(vocbase->_collectionsLock);
collection = static_cast<TRI_vocbase_col_t const*>(TRI_LookupByKeyAssociativePointer(&vocbase->_collectionsByName, name));
}
if (collection == nullptr) {
LOG_DEBUG("unknown collection '%s'", name);
@ -2462,8 +2419,6 @@ TRI_vocbase_t::TRI_vocbase_t (TRI_server_t* server,
TRI_InitAuthInfo(this);
TRI_InitReadWriteLock(&_lock);
TRI_CreateUserStructuresVocBase(this);
TRI_InitCondition(&_compactorCondition);
@ -2489,8 +2444,6 @@ TRI_vocbase_t::~TRI_vocbase_t () {
TRI_DestroyCondition(&_cleanupCondition);
TRI_DestroyCondition(&_compactorCondition);
TRI_DestroyReadWriteLock(&_lock);
TRI_DestroyAuthInfo(this);
TRI_DestroyAssociativePointer(&_collectionsByName);

View File

@ -31,8 +31,6 @@
#define ARANGODB_VOC_BASE_VOCBASE_H 1
#include "Basics/Common.h"
#include "Basics/ReadWriteLock.h"
#include "Basics/associative.h"
#include "Basics/locks.h"
#include "Basics/ReadWriteLock.h"
@ -45,15 +43,13 @@
// --SECTION-- forward declarations
// -----------------------------------------------------------------------------
struct TRI_document_collection_t;
struct TRI_col_info_s;
struct TRI_document_collection_t;
struct TRI_json_t;
struct TRI_server_s;
struct TRI_vector_pointer_s;
struct TRI_vector_string_s;
struct TRI_replication_applier_t;
struct TRI_server_t;
struct TRI_vocbase_col_s;
struct TRI_vocbase_defaults_s;
struct TRI_replication_applier_t;
extern bool IGNORE_DATAFILE_ERRORS;
@ -61,34 +57,6 @@ extern bool IGNORE_DATAFILE_ERRORS;
// --SECTION-- public macros
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief read locks the collections structure
////////////////////////////////////////////////////////////////////////////////
#define TRI_READ_LOCK_COLLECTIONS_VOCBASE(a) \
TRI_ReadLockReadWriteLock(&(a)->_lock)
////////////////////////////////////////////////////////////////////////////////
/// @brief read unlocks the collections structure
////////////////////////////////////////////////////////////////////////////////
#define TRI_READ_UNLOCK_COLLECTIONS_VOCBASE(a) \
TRI_ReadUnlockReadWriteLock(&(a)->_lock)
////////////////////////////////////////////////////////////////////////////////
/// @brief write locks the collections structure
////////////////////////////////////////////////////////////////////////////////
#define TRI_WRITE_LOCK_COLLECTIONS_VOCBASE(a) \
TRI_WriteLockReadWriteLock(&(a)->_lock)
////////////////////////////////////////////////////////////////////////////////
/// @brief write unlocks the collections structure
////////////////////////////////////////////////////////////////////////////////
#define TRI_WRITE_UNLOCK_COLLECTIONS_VOCBASE(a) \
TRI_WriteUnlockReadWriteLock(&(a)->_lock)
////////////////////////////////////////////////////////////////////////////////
/// @brief tries to read lock the vocbase collection status
////////////////////////////////////////////////////////////////////////////////
@ -289,7 +257,7 @@ TRI_vocbase_type_e;
////////////////////////////////////////////////////////////////////////////////
struct TRI_vocbase_t {
TRI_vocbase_t (struct TRI_server_s*,
TRI_vocbase_t (TRI_server_t*,
TRI_vocbase_type_e,
char const*,
TRI_voc_tick_t,
@ -310,10 +278,10 @@ struct TRI_vocbase_t {
}
_usage;
struct TRI_server_s* _server;
TRI_server_t* _server;
TRI_vocbase_defaults_t _settings;
TRI_read_write_lock_t _lock; // collection iterator lock
triagens::basics::ReadWriteLock _collectionsLock; // collection iterator lock
std::vector<struct TRI_vocbase_col_s*> _collections; // pointers to ALL collections
std::vector<struct TRI_vocbase_col_s*> _deadCollections; // pointers to collections dropped that can be removed later
@ -424,7 +392,7 @@ void TRI_FreeCollectionVocBase (TRI_vocbase_col_t*);
/// @brief create a vocbase object, without threads and some other attributes
////////////////////////////////////////////////////////////////////////////////
TRI_vocbase_t* TRI_CreateInitialVocBase (struct TRI_server_s*,
TRI_vocbase_t* TRI_CreateInitialVocBase (TRI_server_t*,
TRI_vocbase_type_e,
char const*,
TRI_voc_tick_t,
@ -435,7 +403,7 @@ TRI_vocbase_t* TRI_CreateInitialVocBase (struct TRI_server_s*,
/// @brief opens an existing database, loads all collections
////////////////////////////////////////////////////////////////////////////////
TRI_vocbase_t* TRI_OpenVocBase (struct TRI_server_s*,
TRI_vocbase_t* TRI_OpenVocBase (TRI_server_t*,
char const*,
TRI_voc_tick_t,
char const*,
@ -465,13 +433,13 @@ int TRI_StopCompactorVocBase (TRI_vocbase_t*);
/// @brief returns all known collections
////////////////////////////////////////////////////////////////////////////////
TRI_vector_pointer_t TRI_CollectionsVocBase (TRI_vocbase_t*);
std::vector<TRI_vocbase_col_t*> TRI_CollectionsVocBase (TRI_vocbase_t*);
////////////////////////////////////////////////////////////////////////////////
/// @brief returns names of all known collections
////////////////////////////////////////////////////////////////////////////////
TRI_vector_string_t TRI_CollectionNamesVocBase (TRI_vocbase_t*);
std::vector<std::string> TRI_CollectionNamesVocBase (TRI_vocbase_t*);
////////////////////////////////////////////////////////////////////////////////
/// @brief returns all known (document) collections with their parameters

View File

@ -43,7 +43,7 @@
struct TRI_datafile_s;
struct TRI_df_marker_s;
struct TRI_document_collection_t;
struct TRI_server_s;
struct TRI_server_t;
namespace triagens {
namespace wal {
@ -210,7 +210,7 @@ namespace triagens {
////////////////////////////////////////////////////////////////////////////////
CollectorThread (LogfileManager*,
struct TRI_server_s*);
TRI_server_t*);
////////////////////////////////////////////////////////////////////////////////
/// @brief destroy the collector thread
@ -390,7 +390,7 @@ namespace triagens {
/// @brief pointer to the server
////////////////////////////////////////////////////////////////////////////////
struct TRI_server_s* _server;
TRI_server_t* _server;
////////////////////////////////////////////////////////////////////////////////
/// @brief condition variable for the collector thread

View File

@ -41,7 +41,7 @@
#include <regex.h>
struct TRI_server_s;
struct TRI_server_t;
namespace triagens {
namespace wal {
@ -87,7 +87,7 @@ namespace triagens {
public:
LogfileManager (struct TRI_server_s*,
LogfileManager (TRI_server_t*,
std::string*);
////////////////////////////////////////////////////////////////////////////////
@ -107,7 +107,7 @@ namespace triagens {
////////////////////////////////////////////////////////////////////////////////
static void initialise (std::string*,
struct TRI_server_s*);
TRI_server_t*);
// -----------------------------------------------------------------------------
// --SECTION-- ApplicationFeature methods
@ -790,7 +790,7 @@ namespace triagens {
/// @brief pointer to the server
////////////////////////////////////////////////////////////////////////////////
struct TRI_server_s* _server;
TRI_server_t* _server;
////////////////////////////////////////////////////////////////////////////////
/// @brief the arangod config variable containing the database path

View File

@ -41,8 +41,6 @@
#include "Wal/Marker.h"
#include <functional>
struct TRI_server_s;
////////////////////////////////////////////////////////////////////////////////
/// @brief shortcut for multi-operation remote transaction
////////////////////////////////////////////////////////////////////////////////