initial commit

arangodb · gnusi · Jan 31, 2022 · Jan 22, 2022 · Jan 23, 2022 · Jan 23, 2022
commit be36dc90c38f101ec8952b571637574942f4424c
diff --git a/arangod/Actions/ActionFeature.cpp b/arangod/Actions/ActionFeature.cpp
@@ -24,22 +24,13 @@
 #include "ActionFeature.h"
 
 #include "Actions/actions.h"
-#include "ApplicationFeatures/ApplicationServer.h"
-#include "FeaturePhases/ClusterFeaturePhase.h"
 #include "ProgramOptions/ProgramOptions.h"
-#include "ProgramOptions/Section.h"
 
 using namespace arangodb::application_features;
 using namespace arangodb::options;
 
 namespace arangodb {
 
-ActionFeature::ActionFeature(application_features::ApplicationServer& server)
-    : ApplicationFeature(server, "Action"), _allowUseDatabase(false) {
-  setOptional(true);
-  startsAfter<ClusterFeaturePhase>();
-}
-
 void ActionFeature::collectOptions(std::shared_ptr<ProgramOptions> options) {
   options->addOption(
       "--server.allow-use-database",

diff --git a/arangod/Actions/ActionFeature.h b/arangod/Actions/ActionFeature.h
@@ -27,9 +27,18 @@
 
 namespace arangodb {
 
+class ClusterFeaturePhase;
+
 class ActionFeature final : public application_features::ApplicationFeature {
  public:
-  explicit ActionFeature(application_features::ApplicationServer& server);
+  static constexpr std::string_view name() noexcept { return "Action"; }
+
+  template<typename Server>
+  explicit ActionFeature(Server& server)
+      : ApplicationFeature(server, name()), _allowUseDatabase(false) {
+    setOptional(true);
+    startsAfter<ClusterFeaturePhase, Server>();
+  }
 
   void collectOptions(std::shared_ptr<options::ProgramOptions>) override final;
   void unprepare() override final;

diff --git a/arangod/Agency/AgencyFeature.cpp b/arangod/Agency/AgencyFeature.cpp
@@ -33,7 +33,6 @@
 #include "Basics/application-exit.h"
 #include "Cluster/ClusterFeature.h"
 #include "Endpoint/Endpoint.h"
-#include "FeaturePhases/FoxxFeaturePhase.h"
 #include "IResearch/IResearchAnalyzerFeature.h"
 #include "IResearch/IResearchFeature.h"
 #include "Logger/Logger.h"
@@ -51,29 +50,6 @@ using namespace arangodb::rest;
 
 namespace arangodb {
 
-AgencyFeature::AgencyFeature(application_features::ApplicationServer& server)
-    : ApplicationFeature(server, "Agency"),
-      _activated(false),
-      _size(1),
-      _poolSize(1),
-      _minElectionTimeout(1.0),
-      _maxElectionTimeout(5.0),
-      _supervision(false),
-      _supervisionTouched(false),
-      _waitForSync(true),
-      _supervisionFrequency(1.0),
-      _compactionStepSize(1000),
-      _compactionKeepSize(50000),
-      _maxAppendSize(250),
-      _supervisionGracePeriod(10.0),
-      _supervisionOkThreshold(5.0),
-      _cmdLineTimings(false) {
-  setOptional(true);
-  startsAfter<FoxxFeaturePhase>();
-}
-
-AgencyFeature::~AgencyFeature() = default;
-
 void AgencyFeature::collectOptions(std::shared_ptr<ProgramOptions> options) {
   options->addSection("agency", "agency");
 

diff --git a/arangod/Agency/AgencyFeature.h b/arangod/Agency/AgencyFeature.h
@@ -26,15 +26,40 @@
 #include "ApplicationFeatures/ApplicationFeature.h"
 
 namespace arangodb {
+namespace application_features {
+class FoxxFeaturePhase;
+}
 
 namespace consensus {
 class Agent;
 }
 
 class AgencyFeature : public application_features::ApplicationFeature {
  public:
-  explicit AgencyFeature(application_features::ApplicationServer& server);
-  ~AgencyFeature();
+  static constexpr std::string_view name() { return "Agency"; }
+
+  template<typename Server>
+  explicit AgencyFeature(Server& server)
+      : ApplicationFeature(server, Server::template id<AgencyFeature>(),
+                           name()),
+        _activated(false),
+        _size(1),
+        _poolSize(1),
+        _minElectionTimeout(1.0),
+        _maxElectionTimeout(5.0),
+        _supervision(false),
+        _supervisionTouched(false),
+        _waitForSync(true),
+        _supervisionFrequency(1.0),
+        _compactionStepSize(1000),
+        _compactionKeepSize(50000),
+        _maxAppendSize(250),
+        _supervisionGracePeriod(10.0),
+        _supervisionOkThreshold(5.0),
+        _cmdLineTimings(false) {
+    setOptional(true);
+    startsAfter<application_features::FoxxFeaturePhase, Server>();
+  }
 
   void collectOptions(std::shared_ptr<options::ProgramOptions>) override final;
   void validateOptions(std::shared_ptr<options::ProgramOptions>) override final;

diff --git a/arangod/CMakeLists.txt b/arangod/CMakeLists.txt
@@ -1162,6 +1162,10 @@ target_link_libraries(${BIN_ARANGOD}
   arangoserver
 )
 
+target_include_directories(${BIN_ARANGOD}
+  PUBLIC ${IRESEARCH_INCLUDE}
+)
+
 target_compile_features(${BIN_ARANGOD} PRIVATE cxx_constexpr)
 
 install(

diff --git a/arangod/Cluster/ClusterFeature.cpp b/arangod/Cluster/ClusterFeature.cpp
@@ -59,16 +59,15 @@ struct ClusterFeatureScale {
 DECLARE_HISTOGRAM(arangodb_agencycomm_request_time_msec, ClusterFeatureScale,
                   "Request time for Agency requests [ms]");
 
-ClusterFeature::ClusterFeature(application_features::ApplicationServer& server)
-    : ApplicationFeature(server, "Cluster"),
+ClusterFeature::ClusterFeature(application_features::ApplicationServer& server,
+                               metrics::MetricsFeature& metrics,
+                               DatabaseFeature& database, size_t registration)
+    : ApplicationFeature(server, registration, name()),
       _apiJwtPolicy("jwt-compat"),
       _agency_comm_request_time_ms(
-          server.getFeature<metrics::MetricsFeature>().add(
-              arangodb_agencycomm_request_time_msec{})) {
-  setOptional(true);
-  startsAfter<CommunicationFeaturePhase>();
-  startsAfter<DatabaseFeaturePhase>();
-}
+          metrics.add(arangodb_agencycomm_request_time_msec{})),
+      _metrics{metrics},
+      _database{database} {}
 
 ClusterFeature::~ClusterFeature() {
   if (_enableCluster) {
@@ -504,8 +503,7 @@ void ClusterFeature::prepare() {
 
   reportRole(_requestedRole);
 
-  network::ConnectionPool::Config config(
-      server().getFeature<metrics::MetricsFeature>());
+  network::ConnectionPool::Config config(_metrics);
   config.numIOThreads = 2u;
   config.maxOpenConnections = 2;
   config.idleConnectionMilli = 10000;
@@ -653,17 +651,13 @@ void ClusterFeature::start() {
 
   if (role == ServerState::RoleEnum::ROLE_DBSERVER) {
     _followersDroppedCounter =
-        &server().getFeature<metrics::MetricsFeature>().add(
-            arangodb_dropped_followers_total{});
+        &_metrics.add(arangodb_dropped_followers_total{});
     _followersRefusedCounter =
-        &server().getFeature<metrics::MetricsFeature>().add(
-            arangodb_refused_followers_total{});
+        &_metrics.add(arangodb_refused_followers_total{});
     _followersWrongChecksumCounter =
-        &server().getFeature<metrics::MetricsFeature>().add(
-            arangodb_sync_wrong_checksum_total{});
+        &_metrics.add(arangodb_sync_wrong_checksum_total{});
     _followersTotalRebuildCounter =
-        &server().getFeature<metrics::MetricsFeature>().add(
-            arangodb_sync_rebuilds_total{});
+        &_metrics.add(arangodb_sync_rebuilds_total{});
   }
 
   LOG_TOPIC("b6826", INFO, arangodb::Logger::CLUSTER)
@@ -973,7 +967,7 @@ bool ClusterFeature::isDirty(std::string const& dbName) const {
 
 std::unordered_set<std::string> ClusterFeature::allDatabases() const {
   std::unordered_set<std::string> allDBNames;
-  auto const tmp = server().getFeature<DatabaseFeature>().getDatabaseNames();
+  auto const tmp = _database.getDatabaseNames();
   allDBNames.reserve(tmp.size());
   for (auto const& i : tmp) {
     allDBNames.emplace(i);

diff --git a/arangod/Cluster/ClusterFeature.h b/arangod/Cluster/ClusterFeature.h
@@ -32,14 +32,34 @@
 #include "Metrics/Fwd.h"
 
 namespace arangodb {
+namespace application_features {
+class CommunicationFeaturePhase;
+class DatabaseFeaturePhase;
+}  // namespace application_features
+namespace metrics {
+class MetricsFeature;
+}
 
 class AgencyCache;
 class AgencyCallbackRegistry;
+class DatabaseFeature;
 class HeartbeatThread;
 
 class ClusterFeature : public application_features::ApplicationFeature {
  public:
   explicit ClusterFeature(application_features::ApplicationServer& server);
+
+  static constexpr std::string_view name() noexcept { return "Cluster"; }
+
+  template<typename Server>
+  explicit ClusterFeature(Server& server)
+      : ClusterFeature(server, server.getFeature<metrics::MetricsFeature>(),
+                       Server::template id<ClusterFeature>()) {
+    setOptional(true);
+    startsAfter<application_features::CommunicationFeaturePhase>();
+    startsAfter<application_features::DatabaseFeaturePhase>();
+  }
+
   ~ClusterFeature();
 
   void collectOptions(std::shared_ptr<options::ProgramOptions>) override final;
@@ -174,6 +194,9 @@ class ClusterFeature : public application_features::ApplicationFeature {
                             std::string const& endpoints);
 
  private:
+  ClusterFeature(application_features::ApplicationServer& server,
+                 metrics::MetricsFeature& metrics, DatabaseFeature& database,
+                 size_t registration);
   void reportRole(ServerState::RoleEnum);
 
   std::vector<std::string> _agencyEndpoints;
@@ -216,6 +239,8 @@ class ClusterFeature : public application_features::ApplicationFeature {
   metrics::Counter* _followersWrongChecksumCounter = nullptr;
   metrics::Counter* _followersTotalRebuildCounter = nullptr;
   std::shared_ptr<AgencyCallback> _hotbackupRestoreCallback;
+  metrics::MetricsFeature& _metrics;
+  DatabaseFeature& _database;
 
   /// @brief lock for dirty database list
   mutable arangodb::Mutex _dirtyLock;

diff --git a/arangod/FeaturePhases/AgencyFeaturePhase.cpp b/arangod/FeaturePhases/AgencyFeaturePhase.cpp
@@ -22,20 +22,3 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 #include "AgencyFeaturePhase.h"
-
-#include "Agency/AgencyFeature.h"
-#include "FeaturePhases/FoxxFeaturePhase.h"
-
-namespace arangodb {
-namespace application_features {
-
-AgencyFeaturePhase::AgencyFeaturePhase(ApplicationServer& server)
-    : ApplicationFeaturePhase(server, "AgencyPhase") {
-  setOptional(false);
-  startsAfter<FoxxFeaturePhase>();
-
-  startsAfter<AgencyFeature>();
-}
-
-}  // namespace application_features
-}  // namespace arangodb
diff --git a/arangod/FeaturePhases/AgencyFeaturePhase.h b/arangod/FeaturePhases/AgencyFeaturePhase.h
@@ -28,9 +28,21 @@
 namespace arangodb {
 namespace application_features {
 
+class AgencyFeature;
+class FoxxFeaturePhase;
+
 class AgencyFeaturePhase : public ApplicationFeaturePhase {
  public:
-  explicit AgencyFeaturePhase(ApplicationServer& server);
+  static constexpr std::string_view name() noexcept { return "AgencyPhase"; }
+
+  template<typename Server>
+  explicit AgencyFeaturePhase(Server& server)
+      : ApplicationFeaturePhase(
+            server, Server::template id<AgencyFeaturePhase>(), name()) {
+    setOptional(false);
+    startsAfter<FoxxFeaturePhase, Server>();
+    startsAfter<AgencyFeature, Server>();
+  }
 };
 
 }  // namespace application_features

diff --git a/arangod/FeaturePhases/AqlFeaturePhase.cpp b/arangod/FeaturePhases/AqlFeaturePhase.cpp
@@ -22,36 +22,3 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 #include "AqlFeaturePhase.h"
-
-#include "ApplicationFeatures/CommunicationFeaturePhase.h"
-#include "Aql/AqlFunctionFeature.h"
-#include "Aql/OptimizerRulesFeature.h"
-#include "FeaturePhases/V8FeaturePhase.h"
-#include "IResearch/IResearchAnalyzerFeature.h"
-#include "IResearch/IResearchFeature.h"
-#include "Pregel/PregelFeature.h"
-#include "RestServer/AqlFeature.h"
-#include "RestServer/QueryRegistryFeature.h"
-#include "RestServer/SystemDatabaseFeature.h"
-
-namespace arangodb {
-namespace application_features {
-
-AqlFeaturePhase::AqlFeaturePhase(ApplicationServer& server)
-    : ApplicationFeaturePhase(server, "AQLPhase") {
-  setOptional(false);
-  startsAfter<CommunicationFeaturePhase>();
-  startsAfter<V8FeaturePhase>();
-
-  startsAfter<AqlFeature>();
-  startsAfter<aql::AqlFunctionFeature>();
-  startsAfter<iresearch::IResearchAnalyzerFeature>();
-  startsAfter<iresearch::IResearchFeature>();
-  startsAfter<aql::OptimizerRulesFeature>();
-  startsAfter<pregel::PregelFeature>();
-  startsAfter<QueryRegistryFeature>();
-  startsAfter<SystemDatabaseFeature>();
-}
-
-}  // namespace application_features
-}  // namespace arangodb
diff --git a/arangod/FeaturePhases/AqlFeaturePhase.h b/arangod/FeaturePhases/AqlFeaturePhase.h
@@ -26,11 +26,47 @@
 #include "ApplicationFeatures/ApplicationFeaturePhase.h"
 
 namespace arangodb {
+namespace aql {
+class AqlFunctionFeature;
+class OptimizerRulesFeature;
+}  // namespace aql
+namespace iresearch {
+
+class IResearchAnalyzerFeature;
+class IResearchFeature;
+}  // namespace iresearch
+namespace pregel {
+class PregelFeature;
+}
 namespace application_features {
 
+class CommunicationFeaturePhase;
+class V8FeaturePhase;
+class AqlFeature;
+class SystemDatabaseFeature;
+class QueryRegistryFeature;
+
 class AqlFeaturePhase : public ApplicationFeaturePhase {
  public:
-  explicit AqlFeaturePhase(ApplicationServer& server);
+  static constexpr std::string_view name() noexcept { return "AQLPhase"; }
+
+  template<typename Server>
+  explicit AqlFeaturePhase(Server& server)
+      : ApplicationFeaturePhase(server, Server::template id<AqlFeaturePhase>(),
+                                name()) {
+    setOptional(false);
+    startsAfter<CommunicationFeaturePhase, Server>();
+    startsAfter<V8FeaturePhase, Server>();
+
+    startsAfter<AqlFeature, Server>();
+    startsAfter<aql::AqlFunctionFeature, Server>();
+    startsAfter<iresearch::IResearchAnalyzerFeature, Server>();
+    startsAfter<iresearch::IResearchFeature, Server>();
+    startsAfter<aql::OptimizerRulesFeature, Server>();
+    startsAfter<pregel::PregelFeature, Server>();
+    startsAfter<QueryRegistryFeature, Server>();
+    startsAfter<SystemDatabaseFeature, Server>();
+  }
 };
 
 }  // namespace application_features