slight cleanup of replication-related code (#4286)

arangod/CMakeLists.txt

@@ -349,6 +349,7 @@ SET(ARANGOD_SOURCES
   Replication/ReplicationFeature.cpp
   Replication/Syncer.cpp
   Replication/TailingSyncer.cpp
+  Replication/common-defines.cpp
   RestHandler/RestAdminLogHandler.cpp
   RestHandler/RestAdminRoutingHandler.cpp
   RestHandler/RestAdminServerHandler.cpp
@@ -481,7 +482,6 @@ SET(ARANGOD_SOURCES
   VocBase/LogicalCollection.cpp
   VocBase/LogicalView.cpp
   VocBase/ManagedDocumentResult.cpp
-  VocBase/replication-common.cpp
   VocBase/ticks.cpp
   VocBase/vocbase.cpp
   ${ADDITIONAL_BIN_ARANGOD_SOURCES}

arangod/MMFiles/MMFilesRestReplicationHandler.cpp

@@ -22,6 +22,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 #include "MMFilesRestReplicationHandler.h"
+#include "Basics/StaticStrings.h"
 #include "Basics/VelocyPackHelper.h"
 #include "Logger/Logger.h"
 #include "MMFiles/MMFilesCollectionKeys.h"
@@ -418,14 +419,14 @@ void MMFilesRestReplicationHandler::handleCommandLoggerFollow() {
   _response->setContentType(rest::ContentType::DUMP);
 
   // set headers
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_CHECKMORE,
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderCheckMore,
                          checkMore ? "true" : "false");
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_LASTINCLUDED,
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderLastIncluded,
                          StringUtils::itoa(dump._lastFoundTick));
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_LASTTICK,
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderLastTick,
                          StringUtils::itoa(state.lastCommittedTick));
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_ACTIVE, "true");
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderActive, "true");
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_FROMPRESENT,
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderFromPresent,
                          dump._fromTickIncluded ? "true" : "false");
 
   if (length > 0) {
@@ -521,10 +522,10 @@ void MMFilesRestReplicationHandler::handleCommandDetermineOpenTransactions() {
 
   _response->setContentType(rest::ContentType::DUMP);
 
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_FROMPRESENT,
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderFromPresent,
                          dump._fromTickIncluded ? "true" : "false");
 
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_LASTTICK,
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderLastTick,
                          StringUtils::itoa(dump._lastFoundTick));
 
   if (length > 0) {
@@ -1031,10 +1032,10 @@ void MMFilesRestReplicationHandler::handleCommandDump() {
   response->setContentType(rest::ContentType::DUMP);
 
   // set headers
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_CHECKMORE,
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderCheckMore,
                          (dump._hasMore ? "true" : "false"));
 
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_LASTINCLUDED,
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderLastIncluded,
                          StringUtils::itoa(dump._lastFoundTick));
 
   // transfer ownership of the buffer contents

arangod/MMFiles/mmfiles-replication-common.h

@@ -25,7 +25,7 @@
 #define ARANGOD_MMFILES_MMFILES_REPLICATION_COMMON_H 1
 
 #include "MMFiles/MMFilesDatafile.h"
-#include "VocBase/replication-common.h"
+#include "Replication/common-defines.h"
 #include "VocBase/voc-types.h"
 
 namespace arangodb {

arangod/MMFiles/mmfiles-replication-dump.cpp

@@ -59,14 +59,22 @@ static void Append(MMFilesReplicationDumpContext* dump, char const* value) {
   }
 }
 
+static void Append(MMFilesReplicationDumpContext* dump, std::string const& value) {
+  int res = TRI_AppendString2StringBuffer(dump->_buffer, value.c_str(), value.size());
+
+  if (res != TRI_ERROR_NO_ERROR) {
+    THROW_ARANGO_EXCEPTION(res);
+  }
+}
+
 /// @brief translate a (local) collection id into a collection name
-static char const* NameFromCid(MMFilesReplicationDumpContext* dump,
+static std::string const& nameFromCid(MMFilesReplicationDumpContext* dump,
-                               TRI_voc_cid_t cid) {
+                                      TRI_voc_cid_t cid) {
   auto it = dump->_collectionNames.find(cid);
 
   if (it != dump->_collectionNames.end()) {
     // collection name is in cache already
-    return (*it).second.c_str();
+    return (*it).second;
   }
 
   // collection name not in cache yet
@@ -76,15 +84,15 @@ static char const* NameFromCid(MMFilesReplicationDumpContext* dump,
     // insert into cache
     try {
       dump->_collectionNames.emplace(cid, std::move(name));
+      // and look it up again
+      return nameFromCid(dump, cid);
     } catch (...) {
-      return nullptr;
+      // fall through to returning empty string
     }
 
-    // and look it up again
-    return NameFromCid(dump, cid);
   }
 
-  return nullptr;
+  return StaticStrings::Empty;
 }
 
 /// @brief stringify a raw marker from a logfile for a log dump or logger
@@ -128,9 +136,9 @@ static int StringifyMarker(MMFilesReplicationDumpContext* dump,
         Append(dump, collectionId);
         Append(dump, "\"");
         // also include collection name
-        char const* cname = NameFromCid(dump, collectionId);
+        std::string const& cname = nameFromCid(dump, collectionId);
 
-        if (cname != nullptr) {
+        if (!cname.empty()) {
           Append(dump, ",\"cname\":\"");
           Append(dump, cname);
           Append(dump, "\"");
@@ -229,8 +237,8 @@ static int SliceifyMarker(MMFilesReplicationDumpContext* dump,
       if (collectionId > 0) {
         builder.add("cid", VPackValue(collectionId));
         // also include collection name
-        char const* cname = NameFromCid(dump, collectionId);
+        std::string const& cname = nameFromCid(dump, collectionId);
-        if (cname != nullptr) {
+        if (!cname.empty()) {
           builder.add("cname", VPackValue(cname));
         }
       }
@@ -321,9 +329,9 @@ static bool MustReplicateWalMarker(
   TRI_voc_cid_t cid = collectionId;
 
   if (cid != 0) {
-    char const* name = NameFromCid(dump, cid);
+    std::string const& name = nameFromCid(dump, cid);
 
-    if (name != nullptr &&
+    if (!name.empty() &&
         TRI_ExcludeCollectionReplication(name, dump->_includeSystem)) {
       return false;
     }

arangod/MMFiles/mmfiles-replication-dump.h

@@ -27,8 +27,8 @@
 #include "Basics/Common.h"
 #include "Basics/Exceptions.h"
 #include "Basics/StringBuffer.h"
+#include "Replication/common-defines.h"
 #include "Transaction/Context.h"
-#include "VocBase/replication-common.h"
 #include "VocBase/voc-types.h"
 #include "VocBase/vocbase.h"
 
@@ -38,8 +38,6 @@
 #include <velocypack/Options.h>
 #include <velocypack/velocypack-aliases.h>
 
-#include <vector>
-
 /// @brief replication dump container
 struct MMFilesReplicationDumpContext {
   MMFilesReplicationDumpContext(std::shared_ptr<arangodb::transaction::Context> const&

arangod/Replication/DatabaseInitialSyncer.cpp

@@ -456,10 +456,10 @@ Result DatabaseInitialSyncer::handleCollectionDump(arangodb::LogicalCollection*
     }
 
     bool found;
-    std::string header = response->getHeaderField(TRI_REPLICATION_HEADER_CHECKMORE, found);
+    std::string header = response->getHeaderField(StaticStrings::ReplicationHeaderCheckMore, found);
     if (!found) {
       return Result(TRI_ERROR_REPLICATION_INVALID_RESPONSE, std::string("got invalid response from master at ") +
-                    _masterInfo._endpoint + url + ": required header " + TRI_REPLICATION_HEADER_CHECKMORE +
+                    _masterInfo._endpoint + url + ": required header " + StaticStrings::ReplicationHeaderCheckMore +
                     " is missing in dump response");
     }
 
@@ -467,11 +467,11 @@ Result DatabaseInitialSyncer::handleCollectionDump(arangodb::LogicalCollection*
     bool checkMore = StringUtils::boolean(header);
 
     if (checkMore) {
-      header = response->getHeaderField(TRI_REPLICATION_HEADER_LASTINCLUDED,
+      header = response->getHeaderField(StaticStrings::ReplicationHeaderLastIncluded,
                                         found);
       if (!found) {
         return Result(TRI_ERROR_REPLICATION_INVALID_RESPONSE, std::string("got invalid response from master at ") +
-                      _masterInfo._endpoint + url + ": required header " + TRI_REPLICATION_HEADER_LASTINCLUDED
+                      _masterInfo._endpoint + url + ": required header " + StaticStrings::ReplicationHeaderLastIncluded
                       + " is missing in dump response");
       }
 

arangod/Replication/DatabaseTailingSyncer.cpp

@@ -139,23 +139,23 @@ Result DatabaseTailingSyncer::syncCollectionFinalize(std::string const& collecti
     }
     
     bool found;
-    std::string header = response->getHeaderField(TRI_REPLICATION_HEADER_CHECKMORE, found);
+    std::string header = response->getHeaderField(StaticStrings::ReplicationHeaderCheckMore, found);
     bool checkMore = false;
     if (found) {
       checkMore = StringUtils::boolean(header);
     }
     
     header =
-    response->getHeaderField(TRI_REPLICATION_HEADER_LASTINCLUDED, found);
+    response->getHeaderField(StaticStrings::ReplicationHeaderLastIncluded, found);
     if (!found) {
       return Result(TRI_ERROR_REPLICATION_INVALID_RESPONSE, std::string("got invalid response from master at ") +
-                    _masterInfo._endpoint + ": required header " + TRI_REPLICATION_HEADER_LASTINCLUDED + " is missing");
+                    _masterInfo._endpoint + ": required header " + StaticStrings::ReplicationHeaderLastIncluded + " is missing");
     }
     TRI_voc_tick_t lastIncludedTick = StringUtils::uint64(header);
     
     // was the specified from value included the result?
     bool fromIncluded = false;
-    header = response->getHeaderField(TRI_REPLICATION_HEADER_FROMPRESENT, found);
+    header = response->getHeaderField(StaticStrings::ReplicationHeaderFromPresent, found);
     if (found) {
       fromIncluded = StringUtils::boolean(header);
     }

arangod/Replication/ReplicationApplier.cpp

@@ -33,9 +33,9 @@
 #include "Cluster/ServerState.h"
 #include "Logger/Logger.h"
 #include "Replication/TailingSyncer.h"
+#include "Replication/common-defines.h"
 #include "Rest/Version.h"
 #include "RestServer/ServerIdFeature.h"
-#include "VocBase/replication-common.h"
 
 using namespace arangodb;
 

arangod/Replication/ReplicationApplierState.cpp

@@ -22,7 +22,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 #include "ReplicationApplierState.h"
-#include "VocBase/replication-common.h"
+#include "Replication/common-defines.h"
 
 #include <velocypack/Builder.h>
 #include <velocypack/velocypack-aliases.h>

arangod/Replication/ReplicationApplierState.h

@@ -25,7 +25,7 @@
 #define ARANGOD_REPLICATION_REPLICATION_APPLIER_STATE_H 1
 
 #include "Basics/Common.h"
-#include "VocBase/replication-common.h"
+#include "Replication/common-defines.h"
 #include "VocBase/voc-types.h"
 
 #include <velocypack/Builder.h>

arangod/Replication/Syncer.h

@@ -26,8 +26,8 @@
 
 #include "Basics/Common.h"
 #include "Replication/ReplicationApplierConfiguration.h"
+#include "Replication/common-defines.h"
 #include "Utils/DatabaseGuard.h"
-#include "VocBase/replication-common.h"
 #include "VocBase/ticks.h"
 
 struct TRI_vocbase_t;

arangod/Replication/TailingSyncer.cpp

@@ -1269,20 +1269,20 @@ Result TailingSyncer::fetchOpenTransactions(TRI_voc_tick_t fromTick,
   
   bool found;
   std::string header =
-  response->getHeaderField(TRI_REPLICATION_HEADER_FROMPRESENT, found);
+  response->getHeaderField(StaticStrings::ReplicationHeaderFromPresent, found);
   
   if (found) {
     fromIncluded = StringUtils::boolean(header);
   }
   
   // fetch the tick from where we need to start scanning later
-  header = response->getHeaderField(TRI_REPLICATION_HEADER_LASTINCLUDED, found);
+  header = response->getHeaderField(StaticStrings::ReplicationHeaderLastIncluded, found);
   if (!found) {
     // we changed the API in 3.3 to use last included
-    header = response->getHeaderField(TRI_REPLICATION_HEADER_LASTTICK, found);
+    header = response->getHeaderField(StaticStrings::ReplicationHeaderLastTick, found);
     if (!found) {
       return Result(TRI_ERROR_REPLICATION_INVALID_RESPONSE, std::string("got invalid response from master at ") +
-                    _masterInfo._endpoint + ": required header " + TRI_REPLICATION_HEADER_LASTTICK +
+                    _masterInfo._endpoint + ": required header " + StaticStrings::ReplicationHeaderLastTick +
                     " is missing in determine-open-transactions response");
     }
   }
@@ -1389,32 +1389,32 @@ Result TailingSyncer::followMasterLog(TRI_voc_tick_t& fetchTick,
   }
   
   bool found;
-  std::string header = response->getHeaderField(TRI_REPLICATION_HEADER_CHECKMORE, found);
+  std::string header = response->getHeaderField(StaticStrings::ReplicationHeaderCheckMore, found);
   
   if (!found) {
     return Result(TRI_ERROR_REPLICATION_INVALID_RESPONSE, std::string("got invalid response from master at ") +
-                  _masterInfo._endpoint + ": required header " + TRI_REPLICATION_HEADER_CHECKMORE + " is missing");
+                  _masterInfo._endpoint + ": required header " + StaticStrings::ReplicationHeaderCheckMore + " is missing");
   }
   
   bool checkMore = StringUtils::boolean(header);
   
   // was the specified from value included the result?
   bool fromIncluded = false;
-  header = response->getHeaderField(TRI_REPLICATION_HEADER_FROMPRESENT, found);
+  header = response->getHeaderField(StaticStrings::ReplicationHeaderFromPresent, found);
   if (found) {
     fromIncluded = StringUtils::boolean(header);
   }
   
   bool active = false;
-  header = response->getHeaderField(TRI_REPLICATION_HEADER_ACTIVE, found);
+  header = response->getHeaderField(StaticStrings::ReplicationHeaderActive, found);
   if (found) {
     active = StringUtils::boolean(header);
   }
   
-  header = response->getHeaderField(TRI_REPLICATION_HEADER_LASTINCLUDED, found);
+  header = response->getHeaderField(StaticStrings::ReplicationHeaderLastIncluded, found);
   if (!found) {
     return Result(TRI_ERROR_REPLICATION_INVALID_RESPONSE, std::string("got invalid response from master at ") +
-                  _masterInfo._endpoint + ": required header " + TRI_REPLICATION_HEADER_LASTINCLUDED +
+                  _masterInfo._endpoint + ": required header " + StaticStrings::ReplicationHeaderLastIncluded +
                   " is missing in logger-follow response");
   }
   
@@ -1428,10 +1428,10 @@ Result TailingSyncer::followMasterLog(TRI_voc_tick_t& fetchTick,
     checkMore = false;
   }
   
-  header = response->getHeaderField(TRI_REPLICATION_HEADER_LASTTICK, found);
+  header = response->getHeaderField(StaticStrings::ReplicationHeaderLastTick, found);
   if (!found) {
     return Result(TRI_ERROR_REPLICATION_INVALID_RESPONSE, std::string("got invalid response from master at ") +
-                  _masterInfo._endpoint + ": required header " + TRI_REPLICATION_HEADER_LASTTICK +
+                  _masterInfo._endpoint + ": required header " + StaticStrings::ReplicationHeaderLastTick +
                   " is missing in logger-follow response");
   }
   

arangod/Replication/common-defines.cpp

@@ -21,13 +21,12 @@
 /// @author Jan Steemann
 ////////////////////////////////////////////////////////////////////////////////
 
-#include "replication-common.h"
+#include "Replication/common-defines.h"
 #include "Basics/tri-strings.h"
 
-////////////////////////////////////////////////////////////////////////////////
+namespace arangodb {
-/// @brief generate a timestamp string in a target buffer
-////////////////////////////////////////////////////////////////////////////////
 
+/// @brief generate a timestamp string in a target buffer
 void TRI_GetTimeStampReplication(char* dst, size_t maxLength) {
   struct tm tb;
   time_t tt = time(nullptr);
@@ -36,10 +35,7 @@ void TRI_GetTimeStampReplication(char* dst, size_t maxLength) {
   strftime(dst, maxLength, "%Y-%m-%dT%H:%M:%SZ", &tb);
 }
 
-////////////////////////////////////////////////////////////////////////////////
 /// @brief generate a timestamp string in a target buffer
-////////////////////////////////////////////////////////////////////////////////
-
 void TRI_GetTimeStampReplication(double timeStamp, char* dst,
                                  size_t maxLength) {
   struct tm tb;
@@ -49,18 +45,6 @@ void TRI_GetTimeStampReplication(double timeStamp, char* dst,
   strftime(dst, maxLength, "%Y-%m-%dT%H:%M:%SZ", &tb);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-/// @brief determine whether a collection should be included in replication
-////////////////////////////////////////////////////////////////////////////////
-
-bool TRI_ExcludeCollectionReplication(char const* name, bool includeSystem) {
-  if (name == nullptr) {
-    // name invalid
-    return true;
-  }
-  return TRI_ExcludeCollectionReplication(std::string(name), includeSystem);
-}
-
 bool TRI_ExcludeCollectionReplication(std::string const& name, bool includeSystem) {
   if (name.empty()) {
     // should not happen...
@@ -88,3 +72,5 @@ bool TRI_ExcludeCollectionReplication(std::string const& name, bool includeSyste
 
   return false;
 }
+
+}

arangod/Replication/common-defines.h

@@ -21,46 +21,14 @@
 /// @author Jan Steemann
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef ARANGOD_VOC_BASE_REPLICATION_COMMON_H
+#ifndef ARANGOD_REPLICATION_COMMON_DEFINES_H
-#define ARANGOD_VOC_BASE_REPLICATION_COMMON_H 1
+#define ARANGOD_REPLICATION_COMMON_DEFINES_H 1
 
 #include "Basics/Common.h"
-#include "VocBase/voc-types.h"
 
-////////////////////////////////////////////////////////////////////////////////
+namespace arangodb {
-/// @brief HTTP response header for "check for more data?"
-////////////////////////////////////////////////////////////////////////////////
 
-#define TRI_REPLICATION_HEADER_CHECKMORE "x-arango-replication-checkmore"
-
-////////////////////////////////////////////////////////////////////////////////
-/// @brief HTTP response header for "last included tick"
-////////////////////////////////////////////////////////////////////////////////
-
-#define TRI_REPLICATION_HEADER_LASTINCLUDED "x-arango-replication-lastincluded"
-
-////////////////////////////////////////////////////////////////////////////////
-/// @brief HTTP response header for "last logged tick"
-////////////////////////////////////////////////////////////////////////////////
-
-#define TRI_REPLICATION_HEADER_LASTTICK "x-arango-replication-lasttick"
-
-////////////////////////////////////////////////////////////////////////////////
-/// @brief HTTP response header for "from tick present"
-////////////////////////////////////////////////////////////////////////////////
-
-#define TRI_REPLICATION_HEADER_FROMPRESENT "x-arango-replication-frompresent"
-
-////////////////////////////////////////////////////////////////////////////////
-/// @brief HTTP response header for "replication active"
-////////////////////////////////////////////////////////////////////////////////
-
-#define TRI_REPLICATION_HEADER_ACTIVE "x-arango-replication-active"
-
-////////////////////////////////////////////////////////////////////////////////
 /// @brief replication operations
-////////////////////////////////////////////////////////////////////////////////
-
 typedef enum {
   REPLICATION_INVALID = 0,
 
@@ -94,23 +62,15 @@ typedef enum {
   REPLICATION_MAX
 } TRI_replication_operation_e;
 
-////////////////////////////////////////////////////////////////////////////////
 /// @brief generate a timestamp string in a target buffer
-////////////////////////////////////////////////////////////////////////////////
-
 void TRI_GetTimeStampReplication(char*, size_t);
 
-////////////////////////////////////////////////////////////////////////////////
 /// @brief generate a timestamp string in a target buffer
-////////////////////////////////////////////////////////////////////////////////
-
 void TRI_GetTimeStampReplication(double, char*, size_t);
 
-////////////////////////////////////////////////////////////////////////////////
 /// @brief determine whether a collection should be included in replication
-////////////////////////////////////////////////////////////////////////////////
-
-bool TRI_ExcludeCollectionReplication(char const* name, bool includeSystem);
 bool TRI_ExcludeCollectionReplication(std::string const& name, bool includeSystem);
 
+}
+
 #endif

arangod/RestHandler/RestReplicationHandler.h

@@ -27,8 +27,8 @@
 
 #include "Basics/Common.h"
 #include "Basics/Result.h"
+#include "Replication/common-defines.h"
 #include "RestHandler/RestVocbaseBaseHandler.h"
-#include "VocBase/replication-common.h"
 
 namespace arangodb {
 class ClusterInfo;

arangod/RestHandler/RestWalAccessHandler.cpp

@@ -22,9 +22,10 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 #include "RestWalAccessHandler.h"
-
+#include "Basics/StaticStrings.h"
 #include "Basics/VPackStringBufferAdapter.h"
 #include "Basics/VelocyPackHelper.h"
+#include "Replication/common-defines.h"
 #include "Rest/HttpResponse.h"
 #include "Rest/Version.h"
 #include "RestServer/DatabaseFeature.h"
@@ -35,7 +36,6 @@
 #include "Transaction/Helpers.h"
 #include "Utils/CollectionNameResolver.h"
 #include "VocBase/LogicalCollection.h"
-#include "VocBase/replication-common.h"
 
 #include <velocypack/Builder.h>
 #include <velocypack/Iterator.h>
@@ -325,15 +325,15 @@ void RestWalAccessHandler::handleCommandTail(WalAccess const* wal) {
   // set headers
   bool checkMore = result.lastIncludedTick() > 0 &&
                    result.lastIncludedTick() < result.latestTick();
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_CHECKMORE,
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderCheckMore,
                          checkMore ? "true" : "false");
   _response->setHeaderNC(
-      TRI_REPLICATION_HEADER_LASTINCLUDED,
+      StaticStrings::ReplicationHeaderLastIncluded,
       StringUtils::itoa(result.lastIncludedTick()));
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_LASTTICK,
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderLastTick,
                          StringUtils::itoa(result.latestTick()));
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_ACTIVE, "true");
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderActive, "true");
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_FROMPRESENT,
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderFromPresent,
                          result.fromTickIncluded() ? "true" : "false");
 
   if (length > 0) {
@@ -408,9 +408,9 @@ void RestWalAccessHandler::handleCommandDetermineOpenTransactions(
     auto cc = r.lastIncludedTick() != 0 ? ResponseCode::OK : ResponseCode::NO_CONTENT;
     generateResult(cc, std::move(buffer));
 
-    _response->setHeaderNC(TRI_REPLICATION_HEADER_FROMPRESENT,
+    _response->setHeaderNC(StaticStrings::ReplicationHeaderFromPresent,
                            r.fromTickIncluded() ? "true" : "false");
-    _response->setHeaderNC(TRI_REPLICATION_HEADER_LASTINCLUDED,
+    _response->setHeaderNC(StaticStrings::ReplicationHeaderLastIncluded,
                            StringUtils::itoa(r.lastIncludedTick()));
   }
 }

arangod/RocksDBEngine/RocksDBReplicationContext.cpp

@@ -27,6 +27,7 @@
 #include "Basics/StringRef.h"
 #include "Basics/VPackStringBufferAdapter.h"
 #include "Logger/Logger.h"
+#include "Replication/common-defines.h"
 #include "RestServer/DatabaseFeature.h"
 #include "RocksDBEngine/RocksDBCollection.h"
 #include "RocksDBEngine/RocksDBCommon.h"
@@ -38,7 +39,6 @@
 #include "Transaction/UserTransaction.h"
 #include "Utils/DatabaseGuard.h"
 #include "Utils/ExecContext.h"
-#include "VocBase/replication-common.h"
 #include "VocBase/ticks.h"
 
 #include <velocypack/Dumper.h>

arangod/RocksDBEngine/RocksDBReplicationTailing.cpp

@@ -25,12 +25,16 @@
 #include "Basics/StaticStrings.h"
 #include "Basics/StringRef.h"
 #include "Logger/Logger.h"
+#include "Replication/common-defines.h"
 #include "RocksDBEngine/RocksDBColumnFamily.h"
 #include "RocksDBEngine/RocksDBCommon.h"
 #include "RocksDBEngine/RocksDBLogValue.h"
-#include "VocBase/replication-common.h"
 #include "VocBase/ticks.h"
 
+#include <velocypack/Builder.h>
+#include <velocypack/Slice.h>
+#include <velocypack/velocypack-aliases.h>
+
 #include <rocksdb/utilities/transaction_db.h>
 #include <rocksdb/utilities/write_batch_with_index.h>
 #include <rocksdb/write_batch.h>

arangod/RocksDBEngine/RocksDBReplicationTailing.h

@@ -25,15 +25,16 @@
 #define ARANGO_ROCKSDB_ROCKSDB_REPLICATION_TAILING_H 1
 
 #include "Basics/Common.h"
+#include "Replication/common-defines.h"
 #include "RocksDBEngine/RocksDBReplicationCommon.h"
 #include "RocksDBEngine/RocksDBTypes.h"
 #include "VocBase/vocbase.h"
-#include "VocBase/replication-common.h"
-
-#include <velocypack/Slice.h>
-#include <velocypack/velocypack-aliases.h>
 
 namespace arangodb {
+namespace velocypack {
+class Builder;
+}
+
 namespace rocksutils {
 
 // iterates over WAL starting at 'from' and returns up to 'limit' documents
@@ -41,9 +42,9 @@ namespace rocksutils {
 RocksDBReplicationResult tailWal(TRI_vocbase_t* vocbase, uint64_t tickStart,
                                  uint64_t tickEnd, size_t chunkSize,
                                  bool includeSystem, TRI_voc_cid_t collectionId,
-                                 VPackBuilder& builder);
+                                 arangodb::velocypack::Builder& builder);
 
-TRI_replication_operation_e convertLogType(RocksDBLogType t);
+arangodb::TRI_replication_operation_e convertLogType(RocksDBLogType t);
 
 }  // namespace rocksutils
 }  // namespace arangodb

arangod/RocksDBEngine/RocksDBRestReplicationHandler.cpp

@@ -23,6 +23,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 #include "RocksDBRestReplicationHandler.h"
+#include "Basics/StaticStrings.h"
 #include "Basics/VPackStringBufferAdapter.h"
 #include "Basics/VelocyPackHelper.h"
 #include "Logger/Logger.h"
@@ -287,14 +288,14 @@ void RocksDBRestReplicationHandler::handleCommandLoggerFollow() {
   _response->setContentType(rest::ContentType::DUMP);
 
   // set headers
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_CHECKMORE,
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderCheckMore,
                          checkMore ? "true" : "false");
   _response->setHeaderNC(
-      TRI_REPLICATION_HEADER_LASTINCLUDED,
+      StaticStrings::ReplicationHeaderLastIncluded,
       StringUtils::itoa((length == 0) ? 0 : result.maxTick()));
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_LASTTICK, StringUtils::itoa(latest));
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderLastTick, StringUtils::itoa(latest));
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_ACTIVE, "true");
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderActive, "true");
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_FROMPRESENT,
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderFromPresent,
                          result.minTickIncluded() ? "true" : "false");
 
   if (length > 0) {
@@ -340,9 +341,9 @@ void RocksDBRestReplicationHandler::handleCommandDetermineOpenTransactions() {
   generateResult(rest::ResponseCode::OK, VPackSlice::emptyArraySlice());
   // rocksdb only includes finished transactions in the WAL.
   _response->setContentType(rest::ContentType::DUMP);
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_LASTTICK, "0");
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderLastTick, "0");
   // always true to satisfy continuous syncer
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_FROMPRESENT, "true");
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderFromPresent, "true");
 }
 
 void RocksDBRestReplicationHandler::handleCommandInventory() {
@@ -724,11 +725,11 @@ void RocksDBRestReplicationHandler::handleCommandDump() {
 
   response->setContentType(rest::ContentType::DUMP);
   // set headers
-  _response->setHeaderNC(TRI_REPLICATION_HEADER_CHECKMORE,
+  _response->setHeaderNC(StaticStrings::ReplicationHeaderCheckMore,
                          (context->more() ? "true" : "false"));
 
   _response->setHeaderNC(
-      TRI_REPLICATION_HEADER_LASTINCLUDED,
+      StaticStrings::ReplicationHeaderLastIncluded,
       StringUtils::itoa((dump.length() == 0) ? 0 : result.maxTick()));
 
   // transfer ownership of the buffer contents

arangosh/Dump/DumpFeature.cpp

@@ -30,6 +30,7 @@
 #include "ApplicationFeatures/ApplicationServer.h"
 #include "Basics/FileUtils.h"
 #include "Basics/OpenFilesTracker.h"
+#include "Basics/StaticStrings.h"
 #include "Basics/StringUtils.h"
 #include "Basics/VelocyPackHelper.h"
 #include "Basics/files.h"
@@ -350,7 +351,7 @@ int DumpFeature::dumpCollection(int fd, std::string const& cid,
 
     // TODO: fix hard-coded headers
     std::string header =
-        response->getHeaderField("x-arango-replication-checkmore", found);
+        response->getHeaderField(StaticStrings::ReplicationHeaderCheckMore, found);
 
     if (found) {
       checkMore = StringUtils::boolean(header);
@@ -358,8 +359,7 @@ int DumpFeature::dumpCollection(int fd, std::string const& cid,
 
       if (checkMore) {
         // TODO: fix hard-coded headers
-        header = response->getHeaderField("x-arango-replication-lastincluded",
+        header = response->getHeaderField(StaticStrings::ReplicationHeaderLastIncluded, found);
-                                          found);
 
         if (found) {
           uint64_t tick = StringUtils::uint64(header);
@@ -740,7 +740,7 @@ int DumpFeature::dumpShard(int fd, std::string const& DBserver,
 
     // TODO: fix hard-coded headers
     std::string header =
-        response->getHeaderField("x-arango-replication-checkmore", found);
+        response->getHeaderField(StaticStrings::ReplicationHeaderCheckMore, found);
 
     if (found) {
       checkMore = StringUtils::boolean(header);
@@ -748,8 +748,7 @@ int DumpFeature::dumpShard(int fd, std::string const& DBserver,
 
       if (checkMore) {
         // TODO: fix hard-coded headers
-        header = response->getHeaderField("x-arango-replication-lastincluded",
+        header = response->getHeaderField(StaticStrings::ReplicationHeaderLastIncluded, found);
-                                          found);
 
         if (found) {
           uint64_t tick = StringUtils::uint64(header);

lib/Basics/StaticStrings.cpp

@@ -57,6 +57,13 @@ std::string const StaticStrings::SilentString("silent");
 std::string const StaticStrings::WaitForSyncString("waitForSync");
 std::string const StaticStrings::IsSynchronousReplicationString(
     "isSynchronousReplication");
+  
+// replication headers
+std::string const StaticStrings::ReplicationHeaderCheckMore("x-arango-replication-checkmore");
+std::string const StaticStrings::ReplicationHeaderLastIncluded("x-arango-replication-lastincluded");
+std::string const StaticStrings::ReplicationHeaderLastTick("x-arango-replication-lasttick");
+std::string const StaticStrings::ReplicationHeaderFromPresent("x-arango-replication-frompresent");
+std::string const StaticStrings::ReplicationHeaderActive("x-arango-replication-active");
 
 // database and collection names
 std::string const StaticStrings::SystemDatabase("_system");

lib/Basics/StaticStrings.h

@@ -62,6 +62,13 @@ class StaticStrings {
   static std::string const SilentString;
   static std::string const WaitForSyncString;
   static std::string const IsSynchronousReplicationString;
+
+  // replication headers
+  static std::string const ReplicationHeaderCheckMore;
+  static std::string const ReplicationHeaderLastIncluded;
+  static std::string const ReplicationHeaderLastTick;
+  static std::string const ReplicationHeaderFromPresent;
+  static std::string const ReplicationHeaderActive;
  
   // database and collection names 
   static std::string const SystemDatabase;