From af8e1889a1383203b9a389d0dd5e0959e517c701 Mon Sep 17 00:00:00 2001 From: Dan Larkin Date: Tue, 18 Apr 2017 15:35:45 -0400 Subject: [PATCH] Moved MMFiles replication handler. --- arangod/CMakeLists.txt | 1 - .../GeneralServer/GeneralServerFeature.cpp | 13 +- arangod/MMFiles/CMakeLists.txt | 1 + arangod/MMFiles/MMFilesRestHandlers.cpp | 13 +- .../MMFilesRestReplicationHandler.cpp} | 127 +++++++++--------- .../MMFilesRestReplicationHandler.h} | 37 +++-- 6 files changed, 96 insertions(+), 96 deletions(-) rename arangod/{RestHandler/RestReplicationHandler.cpp => MMFiles/MMFilesRestReplicationHandler.cpp} (96%) rename arangod/{RestHandler/RestReplicationHandler.h => MMFiles/MMFilesRestReplicationHandler.h} (94%) diff --git a/arangod/CMakeLists.txt b/arangod/CMakeLists.txt index ea741ba191..ee3f3b5c02 100644 --- a/arangod/CMakeLists.txt +++ b/arangod/CMakeLists.txt @@ -250,7 +250,6 @@ SET(ARANGOD_SOURCES RestHandler/RestPregelHandler.cpp RestHandler/RestQueryCacheHandler.cpp RestHandler/RestQueryHandler.cpp - RestHandler/RestReplicationHandler.cpp RestHandler/RestShutdownHandler.cpp RestHandler/RestSimpleHandler.cpp RestHandler/RestSimpleQueryHandler.cpp diff --git a/arangod/GeneralServer/GeneralServerFeature.cpp b/arangod/GeneralServer/GeneralServerFeature.cpp index 922cf4d9ba..a67dcde5cc 100644 --- a/arangod/GeneralServer/GeneralServerFeature.cpp +++ b/arangod/GeneralServer/GeneralServerFeature.cpp @@ -59,7 +59,6 @@ #include "RestHandler/RestPregelHandler.h" #include "RestHandler/RestQueryCacheHandler.h" #include "RestHandler/RestQueryHandler.h" -#include "RestHandler/RestReplicationHandler.h" #include "RestHandler/RestShutdownHandler.h" #include "RestHandler/RestSimpleHandler.h" #include "RestHandler/RestSimpleQueryHandler.h" @@ -362,10 +361,6 @@ void GeneralServerFeature::defineHandlers() { RestVocbaseBaseHandler::IMPORT_PATH, RestHandlerCreator::createNoData); - _handlerFactory->addPrefixHandler( - RestVocbaseBaseHandler::REPLICATION_PATH, - RestHandlerCreator::createNoData); - _handlerFactory->addPrefixHandler( RestVocbaseBaseHandler::SIMPLE_QUERY_ALL_PATH, RestHandlerCreator::createData< @@ -411,9 +406,9 @@ void GeneralServerFeature::defineHandlers() { _handlerFactory->addPrefixHandler( "/_api/query-cache", RestHandlerCreator::createNoData); - - _handlerFactory->addPrefixHandler("/_api/pregel", - RestHandlerCreator::createNoData); + + _handlerFactory->addPrefixHandler( + "/_api/pregel", RestHandlerCreator::createNoData); if (agency->isEnabled()) { _handlerFactory->addPrefixHandler( @@ -450,7 +445,7 @@ void GeneralServerFeature::defineHandlers() { _handlerFactory->addHandler( "/_api/version", RestHandlerCreator::createNoData); - + _handlerFactory->addHandler( "/_api/engine", RestHandlerCreator::createNoData); diff --git a/arangod/MMFiles/CMakeLists.txt b/arangod/MMFiles/CMakeLists.txt index 1347922e89..e0bab9d6ce 100644 --- a/arangod/MMFiles/CMakeLists.txt +++ b/arangod/MMFiles/CMakeLists.txt @@ -39,6 +39,7 @@ set(MMFILES_SOURCES MMFiles/MMFilesRemoverThread.cpp MMFiles/MMFilesRestExportHandler.cpp MMFiles/MMFilesRestHandlers.cpp + MMFiles/MMFilesRestReplicationHandler.cpp MMFiles/MMFilesRestWalHandler.cpp MMFiles/MMFilesRevisionsCache.cpp MMFiles/MMFilesSkiplistIndex.cpp diff --git a/arangod/MMFiles/MMFilesRestHandlers.cpp b/arangod/MMFiles/MMFilesRestHandlers.cpp index 0805de6171..2c89e65270 100644 --- a/arangod/MMFiles/MMFilesRestHandlers.cpp +++ b/arangod/MMFiles/MMFilesRestHandlers.cpp @@ -24,15 +24,22 @@ #include "MMFilesRestHandlers.h" #include "GeneralServer/RestHandlerFactory.h" #include "MMFiles/MMFilesRestExportHandler.h" +#include "MMFiles/MMFilesRestReplicationHandler.h" #include "MMFiles/MMFilesRestWalHandler.h" #include "RestHandler/RestHandlerCreator.h" using namespace arangodb; -void MMFilesRestHandlers::registerResources(rest::RestHandlerFactory* handlerFactory) { +void MMFilesRestHandlers::registerResources( + rest::RestHandlerFactory* handlerFactory) { handlerFactory->addPrefixHandler( "/_admin/wal", RestHandlerCreator::createNoData); - + handlerFactory->addPrefixHandler( - "/_api/export", RestHandlerCreator::createNoData); + "/_api/export", + RestHandlerCreator::createNoData); + + handlerFactory->addPrefixHandler( + "/_api/replication", + RestHandlerCreator::createNoData); } diff --git a/arangod/RestHandler/RestReplicationHandler.cpp b/arangod/MMFiles/MMFilesRestReplicationHandler.cpp similarity index 96% rename from arangod/RestHandler/RestReplicationHandler.cpp rename to arangod/MMFiles/MMFilesRestReplicationHandler.cpp index e6cf59bdb0..0197a5bb9e 100644 --- a/arangod/RestHandler/RestReplicationHandler.cpp +++ b/arangod/MMFiles/MMFilesRestReplicationHandler.cpp @@ -21,7 +21,7 @@ /// @author Jan Steemann //////////////////////////////////////////////////////////////////////////////// -#include "RestReplicationHandler.h" +#include "MMFilesRestReplicationHandler.h" #include "ApplicationFeatures/ApplicationServer.h" #include "Basics/ConditionLocker.h" #include "Basics/ReadLocker.h" @@ -67,16 +67,16 @@ using namespace arangodb; using namespace arangodb::basics; using namespace arangodb::rest; -uint64_t const RestReplicationHandler::defaultChunkSize = 128 * 1024; -uint64_t const RestReplicationHandler::maxChunkSize = 128 * 1024 * 1024; +uint64_t const MMFilesRestReplicationHandler::defaultChunkSize = 128 * 1024; +uint64_t const MMFilesRestReplicationHandler::maxChunkSize = 128 * 1024 * 1024; -RestReplicationHandler::RestReplicationHandler(GeneralRequest* request, - GeneralResponse* response) +MMFilesRestReplicationHandler::MMFilesRestReplicationHandler( + GeneralRequest* request, GeneralResponse* response) : RestVocbaseBaseHandler(request, response) {} -RestReplicationHandler::~RestReplicationHandler() {} +MMFilesRestReplicationHandler::~MMFilesRestReplicationHandler() {} -RestStatus RestReplicationHandler::execute() { +RestStatus MMFilesRestReplicationHandler::execute() { // extract the request type auto const type = _request->requestType(); auto const& suffixes = _request->suffixes(); @@ -320,7 +320,7 @@ BAD_CALL: /// @brief comparator to sort collections /// sort order is by collection type first (vertices before edges, this is /// because edges depend on vertices being there), then name -bool RestReplicationHandler::sortCollections( +bool MMFilesRestReplicationHandler::sortCollections( arangodb::LogicalCollection const* l, arangodb::LogicalCollection const* r) { if (l->type() != r->type()) { @@ -333,7 +333,7 @@ bool RestReplicationHandler::sortCollections( } /// @brief filter a collection based on collection attributes -bool RestReplicationHandler::filterCollection( +bool MMFilesRestReplicationHandler::filterCollection( arangodb::LogicalCollection* collection, void* data) { bool includeSystem = *((bool*)data); @@ -357,7 +357,7 @@ bool RestReplicationHandler::filterCollection( /// @brief creates an error if called on a coordinator server //////////////////////////////////////////////////////////////////////////////// -bool RestReplicationHandler::isCoordinatorError() { +bool MMFilesRestReplicationHandler::isCoordinatorError() { if (_vocbase->type() == TRI_VOCBASE_TYPE_COORDINATOR) { generateError(rest::ResponseCode::NOT_IMPLEMENTED, TRI_ERROR_CLUSTER_UNSUPPORTED, @@ -372,7 +372,8 @@ bool RestReplicationHandler::isCoordinatorError() { /// @brief insert the applier action into an action list //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::insertClient(TRI_voc_tick_t lastServedTick) { +void MMFilesRestReplicationHandler::insertClient( + TRI_voc_tick_t lastServedTick) { bool found; std::string const& value = _request->value("serverId", found); @@ -389,7 +390,7 @@ void RestReplicationHandler::insertClient(TRI_voc_tick_t lastServedTick) { /// @brief determine the chunk size //////////////////////////////////////////////////////////////////////////////// -uint64_t RestReplicationHandler::determineChunkSize() const { +uint64_t MMFilesRestReplicationHandler::determineChunkSize() const { // determine chunk size uint64_t chunkSize = defaultChunkSize; @@ -413,7 +414,7 @@ uint64_t RestReplicationHandler::determineChunkSize() const { /// @brief was docuBlock JSF_get_api_replication_logger_return_state //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandLoggerState() { +void MMFilesRestReplicationHandler::handleCommandLoggerState() { VPackBuilder builder; builder.add(VPackValue(VPackValueType::Object)); // Base @@ -464,7 +465,7 @@ void RestReplicationHandler::handleCommandLoggerState() { /// @brief was docuBlock JSF_get_api_replication_logger_tick_ranges //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandLoggerTickRanges() { +void MMFilesRestReplicationHandler::handleCommandLoggerTickRanges() { auto const& ranges = MMFilesLogfileManager::instance()->ranges(); VPackBuilder b; b.add(VPackValue(VPackValueType::Array)); @@ -486,7 +487,7 @@ void RestReplicationHandler::handleCommandLoggerTickRanges() { /// @brief was docuBlock JSF_get_api_replication_logger_first_tick //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandLoggerFirstTick() { +void MMFilesRestReplicationHandler::handleCommandLoggerFirstTick() { auto const& ranges = MMFilesLogfileManager::instance()->ranges(); VPackBuilder b; @@ -517,7 +518,7 @@ void RestReplicationHandler::handleCommandLoggerFirstTick() { /// @brief was docuBlock JSF_delete_batch_replication //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandBatch() { +void MMFilesRestReplicationHandler::handleCommandBatch() { // extract the request type auto const type = _request->requestType(); auto const& suffixes = _request->suffixes(); @@ -609,7 +610,7 @@ void RestReplicationHandler::handleCommandBatch() { /// @brief add or remove a WAL logfile barrier //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandBarrier() { +void MMFilesRestReplicationHandler::handleCommandBarrier() { // extract the request type auto const type = _request->requestType(); std::vector const& suffixes = _request->suffixes(); @@ -730,7 +731,7 @@ void RestReplicationHandler::handleCommandBarrier() { /// @brief forward a command in the coordinator case //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleTrampolineCoordinator() { +void MMFilesRestReplicationHandler::handleTrampolineCoordinator() { bool useVpp = false; if (_request->transportType() == Endpoint::TransportType::VPP) { useVpp = true; @@ -852,7 +853,7 @@ void RestReplicationHandler::handleTrampolineCoordinator() { /// @brief was docuBlock JSF_get_api_replication_logger_returns //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandLoggerFollow() { +void MMFilesRestReplicationHandler::handleCommandLoggerFollow() { bool useVpp = false; if (_request->transportType() == Endpoint::TransportType::VPP) { useVpp = true; @@ -1038,7 +1039,7 @@ void RestReplicationHandler::handleCommandLoggerFollow() { /// be called by client drivers directly //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandDetermineOpenTransactions() { +void MMFilesRestReplicationHandler::handleCommandDetermineOpenTransactions() { // determine start and end tick MMFilesLogfileManagerState const state = MMFilesLogfileManager::instance()->state(); @@ -1114,7 +1115,7 @@ void RestReplicationHandler::handleCommandDetermineOpenTransactions() { /// @brief was docuBlock JSF_put_api_replication_inventory //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandInventory() { +void MMFilesRestReplicationHandler::handleCommandInventory() { TRI_voc_tick_t tick = TRI_CurrentTickServer(); // include system collections? @@ -1130,7 +1131,7 @@ void RestReplicationHandler::handleCommandInventory() { std::shared_ptr collectionsBuilder; collectionsBuilder = _vocbase->inventory(tick, &filterCollection, (void*)&includeSystem, true, - RestReplicationHandler::sortCollections); + MMFilesRestReplicationHandler::sortCollections); VPackSlice const collections = collectionsBuilder->slice(); TRI_ASSERT(collections.isArray()); @@ -1166,7 +1167,7 @@ void RestReplicationHandler::handleCommandInventory() { /// @brief was docuBlock JSF_get_api_replication_cluster_inventory //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandClusterInventory() { +void MMFilesRestReplicationHandler::handleCommandClusterInventory() { std::string const& dbName = _request->databaseName(); bool found; bool includeSystem = true; @@ -1201,9 +1202,8 @@ void RestReplicationHandler::handleCommandClusterInventory() { /// @brief creates a collection, based on the VelocyPack provided TODO: MOVE //////////////////////////////////////////////////////////////////////////////// -int RestReplicationHandler::createCollection(VPackSlice slice, - arangodb::LogicalCollection** dst, - bool reuseId) { +int MMFilesRestReplicationHandler::createCollection( + VPackSlice slice, arangodb::LogicalCollection** dst, bool reuseId) { if (dst != nullptr) { *dst = nullptr; } @@ -1292,12 +1292,12 @@ int RestReplicationHandler::createCollection(VPackSlice slice, /// @brief restores the structure of a collection TODO MOVE //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandRestoreCollection() { +void MMFilesRestReplicationHandler::handleCommandRestoreCollection() { std::shared_ptr parsedRequest; try { parsedRequest = _request->toVelocyPackBuilderPtr(); - } catch(arangodb::velocypack::Exception const& e) { + } catch (arangodb::velocypack::Exception const& e) { std::string errorMsg = "invalid JSON: "; errorMsg += e.what(); generateError(rest::ResponseCode::BAD, TRI_ERROR_HTTP_BAD_PARAMETER, @@ -1374,7 +1374,7 @@ void RestReplicationHandler::handleCommandRestoreCollection() { /// @brief restores the indexes of a collection TODO MOVE //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandRestoreIndexes() { +void MMFilesRestReplicationHandler::handleCommandRestoreIndexes() { std::shared_ptr parsedRequest; try { @@ -1417,7 +1417,7 @@ void RestReplicationHandler::handleCommandRestoreIndexes() { /// @brief restores the structure of a collection TODO MOVE //////////////////////////////////////////////////////////////////////////////// -int RestReplicationHandler::processRestoreCollection( +int MMFilesRestReplicationHandler::processRestoreCollection( VPackSlice const& collection, bool dropExisting, bool reuseId, bool force, std::string& errorMsg) { if (!collection.isObject()) { @@ -1540,7 +1540,7 @@ int RestReplicationHandler::processRestoreCollection( /// @brief restores the structure of a collection, coordinator case //////////////////////////////////////////////////////////////////////////////// -int RestReplicationHandler::processRestoreCollectionCoordinator( +int MMFilesRestReplicationHandler::processRestoreCollectionCoordinator( VPackSlice const& collection, bool dropExisting, bool reuseId, bool force, uint64_t numberOfShards, std::string& errorMsg, uint64_t replicationFactor) { @@ -1688,9 +1688,8 @@ int RestReplicationHandler::processRestoreCollectionCoordinator( /// @brief restores the indexes of a collection TODO MOVE //////////////////////////////////////////////////////////////////////////////// -int RestReplicationHandler::processRestoreIndexes(VPackSlice const& collection, - bool force, - std::string& errorMsg) { +int MMFilesRestReplicationHandler::processRestoreIndexes( + VPackSlice const& collection, bool force, std::string& errorMsg) { if (!collection.isObject()) { errorMsg = "collection declaration is invalid"; @@ -1798,7 +1797,7 @@ int RestReplicationHandler::processRestoreIndexes(VPackSlice const& collection, /// @brief restores the indexes of a collection, coordinator case //////////////////////////////////////////////////////////////////////////////// -int RestReplicationHandler::processRestoreIndexesCoordinator( +int MMFilesRestReplicationHandler::processRestoreIndexesCoordinator( VPackSlice const& collection, bool force, std::string& errorMsg) { if (!collection.isObject()) { errorMsg = "collection declaration is invalid"; @@ -1883,7 +1882,7 @@ int RestReplicationHandler::processRestoreIndexesCoordinator( /// @brief apply the data from a collection dump or the continuous log //////////////////////////////////////////////////////////////////////////////// -int RestReplicationHandler::applyCollectionDumpMarker( +int MMFilesRestReplicationHandler::applyCollectionDumpMarker( transaction::Methods& trx, CollectionNameResolver const& resolver, std::string const& collectionName, TRI_replication_operation_e type, VPackSlice const& old, VPackSlice const& slice, std::string& errorMsg) { @@ -2034,7 +2033,7 @@ static int restoreDataParser(char const* ptr, char const* pos, /// @brief restores the data of a collection TODO MOVE //////////////////////////////////////////////////////////////////////////////// -int RestReplicationHandler::processRestoreDataBatch( +int MMFilesRestReplicationHandler::processRestoreDataBatch( transaction::Methods& trx, std::string const& collectionName, bool useRevision, bool force, std::string& errorMsg) { std::string const invalidMsg = @@ -2245,9 +2244,9 @@ int RestReplicationHandler::processRestoreDataBatch( /// @brief restores the data of a collection TODO MOVE //////////////////////////////////////////////////////////////////////////////// -int RestReplicationHandler::processRestoreData(std::string const& colName, - bool useRevision, bool force, - std::string& errorMsg) { +int MMFilesRestReplicationHandler::processRestoreData( + std::string const& colName, bool useRevision, bool force, + std::string& errorMsg) { SingleCollectionTransaction trx( transaction::StandaloneContext::Create(_vocbase), colName, AccessMode::Type::WRITE); @@ -2271,7 +2270,7 @@ int RestReplicationHandler::processRestoreData(std::string const& colName, /// @brief restores the data of a collection TODO MOVE //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandRestoreData() { +void MMFilesRestReplicationHandler::handleCommandRestoreData() { std::string const& colName = _request->value("collection"); if (colName.empty()) { @@ -2318,7 +2317,7 @@ void RestReplicationHandler::handleCommandRestoreData() { /// @brief produce list of keys for a specific collection //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandCreateKeys() { +void MMFilesRestReplicationHandler::handleCommandCreateKeys() { std::string const& collection = _request->value("collection"); if (collection.empty()) { @@ -2385,7 +2384,7 @@ void RestReplicationHandler::handleCommandCreateKeys() { /// @brief returns all key ranges //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandGetKeys() { +void MMFilesRestReplicationHandler::handleCommandGetKeys() { std::vector const& suffixes = _request->suffixes(); if (suffixes.size() != 2) { @@ -2463,7 +2462,7 @@ void RestReplicationHandler::handleCommandGetKeys() { /// @brief returns date for a key range //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandFetchKeys() { +void MMFilesRestReplicationHandler::handleCommandFetchKeys() { std::vector const& suffixes = _request->suffixes(); if (suffixes.size() != 2) { @@ -2561,7 +2560,7 @@ void RestReplicationHandler::handleCommandFetchKeys() { } } -void RestReplicationHandler::handleCommandRemoveKeys() { +void MMFilesRestReplicationHandler::handleCommandRemoveKeys() { std::vector const& suffixes = _request->suffixes(); if (suffixes.size() != 2) { @@ -2599,7 +2598,7 @@ void RestReplicationHandler::handleCommandRemoveKeys() { /// @brief was docuBlock JSF_get_api_replication_dump //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandDump() { +void MMFilesRestReplicationHandler::handleCommandDump() { std::string const& collection = _request->value("collection"); if (collection.empty()) { @@ -2756,7 +2755,7 @@ void RestReplicationHandler::handleCommandDump() { /// @brief was docuBlock JSF_put_api_replication_makeSlave //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandMakeSlave() { +void MMFilesRestReplicationHandler::handleCommandMakeSlave() { bool success; std::shared_ptr parsedBody = parseVelocyPackBody(success); if (!success) { @@ -2932,7 +2931,7 @@ void RestReplicationHandler::handleCommandMakeSlave() { /// @brief was docuBlock JSF_put_api_replication_synchronize //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandSync() { +void MMFilesRestReplicationHandler::handleCommandSync() { bool success; std::shared_ptr parsedBody = parseVelocyPackBody(success); if (!success) { @@ -3045,7 +3044,7 @@ void RestReplicationHandler::handleCommandSync() { /// @brief was docuBlock JSF_put_api_replication_serverID //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandServerId() { +void MMFilesRestReplicationHandler::handleCommandServerId() { VPackBuilder result; result.add(VPackValue(VPackValueType::Object)); std::string const serverId = StringUtils::itoa(ServerIdFeature::getId()); @@ -3058,7 +3057,7 @@ void RestReplicationHandler::handleCommandServerId() { /// @brief was docuBlock JSF_put_api_replication_applier //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandApplierGetConfig() { +void MMFilesRestReplicationHandler::handleCommandApplierGetConfig() { TRI_ASSERT(_vocbase->replicationApplier() != nullptr); TRI_replication_applier_configuration_t config; @@ -3075,7 +3074,7 @@ void RestReplicationHandler::handleCommandApplierGetConfig() { /// @brief was docuBlock JSF_put_api_replication_applier_adjust //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandApplierSetConfig() { +void MMFilesRestReplicationHandler::handleCommandApplierSetConfig() { TRI_ASSERT(_vocbase->replicationApplier() != nullptr); TRI_replication_applier_configuration_t config; @@ -3197,7 +3196,7 @@ void RestReplicationHandler::handleCommandApplierSetConfig() { /// @brief was docuBlock JSF_put_api_replication_applier_start //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandApplierStart() { +void MMFilesRestReplicationHandler::handleCommandApplierStart() { TRI_ASSERT(_vocbase->replicationApplier() != nullptr); bool found; @@ -3234,7 +3233,7 @@ void RestReplicationHandler::handleCommandApplierStart() { /// @brief was docuBlock JSF_put_api_replication_applier_stop //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandApplierStop() { +void MMFilesRestReplicationHandler::handleCommandApplierStop() { TRI_ASSERT(_vocbase->replicationApplier() != nullptr); int res = _vocbase->replicationApplier()->stop(true); @@ -3250,7 +3249,7 @@ void RestReplicationHandler::handleCommandApplierStop() { /// @brief was docuBlock JSF_get_api_replication_applier_state //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandApplierGetState() { +void MMFilesRestReplicationHandler::handleCommandApplierGetState() { TRI_ASSERT(_vocbase->replicationApplier() != nullptr); std::shared_ptr result = @@ -3262,7 +3261,7 @@ void RestReplicationHandler::handleCommandApplierGetState() { /// @brief delete the state of the replication applier //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandApplierDeleteState() { +void MMFilesRestReplicationHandler::handleCommandApplierDeleteState() { TRI_ASSERT(_vocbase->replicationApplier() != nullptr); int res = _vocbase->replicationApplier()->forget(); @@ -3278,7 +3277,7 @@ void RestReplicationHandler::handleCommandApplierDeleteState() { /// @brief add a follower of a shard to the list of followers //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandAddFollower() { +void MMFilesRestReplicationHandler::handleCommandAddFollower() { bool success = false; std::shared_ptr parsedBody = parseVelocyPackBody(success); if (!success) { @@ -3324,7 +3323,7 @@ void RestReplicationHandler::handleCommandAddFollower() { /// @brief remove a follower of a shard from the list of followers //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandRemoveFollower() { +void MMFilesRestReplicationHandler::handleCommandRemoveFollower() { bool success = false; std::shared_ptr parsedBody = parseVelocyPackBody(success); if (!success) { @@ -3369,7 +3368,7 @@ void RestReplicationHandler::handleCommandRemoveFollower() { /// @brief hold a read lock on a collection to stop writes temporarily //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandHoldReadLockCollection() { +void MMFilesRestReplicationHandler::handleCommandHoldReadLockCollection() { bool success = false; std::shared_ptr parsedBody = parseVelocyPackBody(success); if (!success) { @@ -3487,7 +3486,7 @@ void RestReplicationHandler::handleCommandHoldReadLockCollection() { /// @brief check the holding of a read lock on a collection //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandCheckHoldReadLockCollection() { +void MMFilesRestReplicationHandler::handleCommandCheckHoldReadLockCollection() { bool success = false; std::shared_ptr parsedBody = parseVelocyPackBody(success); if (!success) { @@ -3537,7 +3536,8 @@ void RestReplicationHandler::handleCommandCheckHoldReadLockCollection() { /// @brief cancel the holding of a read lock on a collection //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandCancelHoldReadLockCollection() { +void MMFilesRestReplicationHandler:: + handleCommandCancelHoldReadLockCollection() { bool success = false; std::shared_ptr parsedBody = parseVelocyPackBody(success); if (!success) { @@ -3588,7 +3588,7 @@ void RestReplicationHandler::handleCommandCancelHoldReadLockCollection() { /// @brief get ID for a read lock job //////////////////////////////////////////////////////////////////////////////// -void RestReplicationHandler::handleCommandGetIdForReadLockCollection() { +void MMFilesRestReplicationHandler::handleCommandGetIdForReadLockCollection() { std::string id = std::to_string(TRI_NewTickServer()); VPackBuilder b; @@ -3604,11 +3604,12 @@ void RestReplicationHandler::handleCommandGetIdForReadLockCollection() { /// @brief condition locker to wake up holdReadLockCollection jobs ////////////////////////////////////////////////////////////////////////////// -arangodb::basics::ConditionVariable RestReplicationHandler::_condVar; +arangodb::basics::ConditionVariable MMFilesRestReplicationHandler::_condVar; ////////////////////////////////////////////////////////////////////////////// /// @brief global table of flags to cancel holdReadLockCollection jobs, if /// the flag is set of the ID of a job, the job is cancelled ////////////////////////////////////////////////////////////////////////////// -std::unordered_map RestReplicationHandler::_holdReadLockJobs; +std::unordered_map + MMFilesRestReplicationHandler::_holdReadLockJobs; diff --git a/arangod/RestHandler/RestReplicationHandler.h b/arangod/MMFiles/MMFilesRestReplicationHandler.h similarity index 94% rename from arangod/RestHandler/RestReplicationHandler.h rename to arangod/MMFiles/MMFilesRestReplicationHandler.h index bcfa0a0176..979ca5e421 100644 --- a/arangod/RestHandler/RestReplicationHandler.h +++ b/arangod/MMFiles/MMFilesRestReplicationHandler.h @@ -21,8 +21,8 @@ /// @author Jan Steemann //////////////////////////////////////////////////////////////////////////////// -#ifndef ARANGOD_REST_HANDLER_REST_REPLICATION_HANDLER_H -#define ARANGOD_REST_HANDLER_REST_REPLICATION_HANDLER_H 1 +#ifndef ARANGOD_MMFILES_MMFILES_REST_REPLICATION_HANDLER_H +#define ARANGOD_MMFILES_MMFILES_REST_REPLICATION_HANDLER_H 1 #include "Basics/Common.h" @@ -35,21 +35,22 @@ class CollectionNameResolver; class LogicalCollection; namespace transaction { class Methods; -} -; +}; //////////////////////////////////////////////////////////////////////////////// /// @brief replication request handler //////////////////////////////////////////////////////////////////////////////// -class RestReplicationHandler : public RestVocbaseBaseHandler { +class MMFilesRestReplicationHandler : public RestVocbaseBaseHandler { public: - RestReplicationHandler(GeneralRequest*, GeneralResponse*); - ~RestReplicationHandler(); + MMFilesRestReplicationHandler(GeneralRequest*, GeneralResponse*); + ~MMFilesRestReplicationHandler(); public: RestStatus execute() override; - char const* name() const override final { return "RestReplicationHandler"; } + char const* name() const override final { + return "MMFilesRestReplicationHandler"; + } public: ////////////////////////////////////////////////////////////////////////////// @@ -98,7 +99,7 @@ class RestReplicationHandler : public RestVocbaseBaseHandler { /// @response VPackObject describing the ServerState in a certain point /// * state (server state) /// * server (version / id) - /// * clients (list of followers) + /// * clients (list of followers) ////////////////////////////////////////////////////////////////////////////// void handleCommandLoggerState(); @@ -229,25 +230,22 @@ class RestReplicationHandler : public RestVocbaseBaseHandler { int applyCollectionDumpMarker(transaction::Methods&, CollectionNameResolver const&, - std::string const&, - TRI_replication_operation_e, - VPackSlice const&, - VPackSlice const&, std::string&); + std::string const&, TRI_replication_operation_e, + VPackSlice const&, VPackSlice const&, + std::string&); ////////////////////////////////////////////////////////////////////////////// /// @brief restores the data of a collection TODO MOVE ////////////////////////////////////////////////////////////////////////////// - int processRestoreDataBatch(transaction::Methods&, - std::string const&, bool, bool, - std::string&); + int processRestoreDataBatch(transaction::Methods&, std::string const&, bool, + bool, std::string&); ////////////////////////////////////////////////////////////////////////////// /// @brief restores the data of a collection TODO MOVE ////////////////////////////////////////////////////////////////////////////// - int processRestoreData(std::string const&, bool, - bool, std::string&); + int processRestoreData(std::string const&, bool, bool, std::string&); ////////////////////////////////////////////////////////////////////////////// /// @brief handle a restore command for a specific collection @@ -394,14 +392,13 @@ class RestReplicationHandler : public RestVocbaseBaseHandler { /// read lock has been started, the bool is changed to true once /// this read lock is acquired. To cancel the read lock, remove /// the entry here (under the protection of the mutex of - /// condVar) and send a broadcast to the condition variable, + /// condVar) and send a broadcast to the condition variable, /// the job with that id is terminated. If it timeouts, then /// the read lock is released automatically and the entry here /// is deleted. ////////////////////////////////////////////////////////////////////////////// static std::unordered_map _holdReadLockJobs; - }; }