wip

arangodb · gnusi · Jan 31, 2022 · Jan 22, 2022 · Jan 23, 2022 · Jan 23, 2022
commit 08e079624ccf8c697ebc0134f6a8f792598d77cd
diff --git a/client-tools/Backup/BackupFeature.cpp b/client-tools/Backup/BackupFeature.cpp
@@ -45,9 +45,6 @@
 
 namespace {
 
-/// @brief name of the feature to report to application server
-constexpr auto FeatureName = "Backup";
-
 constexpr auto OperationCreate = "create";
 constexpr auto OperationDelete = "delete";
 constexpr auto OperationList = "list";
@@ -156,7 +153,7 @@ arangodb::Result waitForRestart(arangodb::ClientManager& clientManager,
     auto now = std::chrono::high_resolution_clock::now();
     auto duration = now - start;
     return (static_cast<double>(duration.count()) /
-            decltype(duration)::period::den* decltype(duration)::period::num);
+            decltype(duration)::period::den * decltype(duration)::period::num);
   };
 
   LOG_TOPIC("0dfda", INFO, arangodb::Logger::BACKUP)
@@ -686,18 +683,16 @@ arangodb::Result executeTransfer(
 
 namespace arangodb {
 
-BackupFeature::BackupFeature(application_features::ApplicationServer& server,
-                             int& exitCode)
-    : ApplicationFeature(server, BackupFeature::featureName()),
-      _clientManager{server, Logger::BACKUP},
+BackupFeature::BackupFeature(Server& server, int& exitCode)
+    : ArangoBackupFeature{server, *this},
+      _clientManager{server.getFeature<HttpEndpointProvider, ClientFeature>(),
+                     Logger::BACKUP},
       _exitCode{exitCode} {
   requiresElevatedPrivileges(false);
   setOptional(false);
-  startsAfter<ClientFeature>();
+  startsAfter<HttpEndpointProvider>();
 }
 
-std::string BackupFeature::featureName() { return ::FeatureName; }
-
 std::string BackupFeature::operationList(std::string const& separator) {
   TRI_ASSERT(::Operations.size() > 0);
 

diff --git a/client-tools/Backup/BackupFeature.h b/client-tools/Backup/BackupFeature.h
@@ -23,6 +23,7 @@
 
 #pragma once
 
+#include "Backup/arangobackup.h"
 #include "ApplicationFeatures/ApplicationFeature.h"
 
 #include "Basics/Mutex.h"
@@ -33,9 +34,11 @@ namespace httpclient {
 class SimpleHttpResult;
 }
 
-class BackupFeature : public application_features::ApplicationFeature {
+class BackupFeature : public ArangoBackupFeature {
  public:
-  BackupFeature(application_features::ApplicationServer& server, int& exitCode);
+  static constexpr std::string_view name() noexcept { return "Backup"; }
+
+  BackupFeature(Server& server, int& exitCode);
 
   // for documentation of virtual methods, see `ApplicationFeature`
   virtual void collectOptions(

diff --git a/client-tools/Backup/arangobackup.cpp b/client-tools/Backup/arangobackup.cpp
@@ -49,14 +49,28 @@
 using namespace arangodb;
 using namespace arangodb::application_features;
 
-struct ArangoBackupInitializer
-    : public ArangoClientInitializer<ArangoBackupServer> {
+struct ArangoBackupInitializer {
  public:
   ArangoBackupInitializer(int* ret, char const* binaryName,
                           ArangoBackupServer& client)
-      : ArangoClientInitializer{binaryName, client}, _ret{ret} {}
+      : _ret{ret}, _binaryName{binaryName}, _client{client} {}
 
-  using ArangoClientInitializer::operator();
+  template<typename T>
+  void operator()(TypeTag<T>) {
+    _client.addFeature<T>();
+  }
+
+  void operator()(TypeTag<GreetingsFeaturePhase>) {
+    _client.addFeature<GreetingsFeaturePhase>(std::true_type{});
+  }
+
+  void operator()(TypeTag<ConfigFeature>) {
+    _client.addFeature<ConfigFeature>(_binaryName);
+  }
+
+  void operator()(TypeTag<LoggerFeature>) {
+    _client.addFeature<LoggerFeature>(false);
+  }
 
   void operator()(TypeTag<HttpEndpointProvider>) {
     _client.addFeature<HttpEndpointProvider, ClientFeature>(false);
@@ -73,6 +87,8 @@ struct ArangoBackupInitializer
 
  private:
   int* _ret;
+  char const* _binaryName;
+  ArangoBackupServer& _client;
 };
 
 int main(int argc, char* argv[]) {

diff --git a/client-tools/Backup/arangobackup.h b/client-tools/Backup/arangobackup.h
@@ -30,7 +30,8 @@ namespace arangodb {
 
 class BackupFeature;
 
-using ArangoBackupFeatures = ArangoClientFeatures<BackupFeature>;
+using ArangoBackupFeatures =
+    ArangoClientFeatures<BasicFeaturePhaseClient, BackupFeature>;
 using ArangoBackupServer = ApplicationServerT<ArangoBackupFeatures>;
 using ArangoBackupFeature = ApplicationFeatureT<ArangoBackupServer>;
 

diff --git a/client-tools/Benchmark/arangobench.cpp b/client-tools/Benchmark/arangobench.cpp
@@ -56,22 +56,33 @@ using namespace arangodb;
 using namespace arangodb::application_features;
 using namespace arangodb::basics;
 
-struct ArangoBenchInitializer
-    : public ArangoClientInitializer<ArangoBenchServer> {
+class ArangoBenchInitializer {
  public:
   ArangoBenchInitializer(int* ret, char const* binaryName,
                          ArangoBenchServer& client)
-      : ArangoClientInitializer{binaryName, client}, _ret{ret} {}
+      : _ret{ret}, _binaryName{binaryName}, _client{client} {}
 
-  using ArangoClientInitializer::operator();
+  template<typename T>
+  void operator()(TypeTag<T>) {
+    _client.addFeature<T>();
+  }
+
+  void operator()(TypeTag<GreetingsFeaturePhase>) {
+    _client.addFeature<GreetingsFeaturePhase>(std::true_type{});
+  }
+
+  void operator()(TypeTag<ConfigFeature>) {
+    _client.addFeature<ConfigFeature>(_binaryName);
+  }
 
   void operator()(TypeTag<HttpEndpointProvider>) {
+    // provide max number of endpoints
     _client.addFeature<HttpEndpointProvider, ClientFeature>(
         false, std::numeric_limits<size_t>::max());
   }
 
   void operator()(TypeTag<BenchFeature>) {
-    _client.addFeature<BenchFeature>(*_ret);
+    _client.addFeature<BenchFeature>(_ret);
   }
 
   void operator()(TypeTag<ShutdownFeature>) {
@@ -80,11 +91,13 @@ struct ArangoBenchInitializer
   }
 
   void operator()(TypeTag<TempFeature>) {
-    _client.template addFeature<TempFeature>(_binaryName);
+    _client.addFeature<TempFeature>(_binaryName);
   }
 
  private:
   int* _ret;
+  char const* _binaryName;
+  ArangoBenchServer& _client;
 };
 
 int main(int argc, char* argv[]) {

diff --git a/client-tools/Dump/arangodump.cpp b/client-tools/Dump/arangodump.cpp
@@ -53,14 +53,28 @@
 using namespace arangodb;
 using namespace arangodb::application_features;
 
-struct ArangoDumpInitializer
-    : public ArangoClientInitializer<ArangoDumpServer> {
+class ArangoDumpInitializer {
  public:
   ArangoDumpInitializer(int* ret, char const* binaryName,
                         ArangoDumpServer& client)
-      : ArangoClientInitializer{binaryName, client}, _ret{ret} {}
+      : _ret{ret}, _binaryName{binaryName}, _client{client} {}
 
-  using ArangoClientInitializer::operator();
+  template<typename T>
+  void operator()(TypeTag<T>) {
+    _client.addFeature<T>();
+  }
+
+  void operator()(TypeTag<GreetingsFeaturePhase>) {
+    _client.addFeature<GreetingsFeaturePhase>(std::true_type{});
+  }
+
+  void operator()(TypeTag<ConfigFeature>) {
+    _client.addFeature<ConfigFeature>(_binaryName);
+  }
+
+  void operator()(TypeTag<LoggerFeature>) {
+    _client.addFeature<LoggerFeature>(false);
+  }
 
   void operator()(TypeTag<HttpEndpointProvider>) {
     _client.addFeature<HttpEndpointProvider, ClientFeature>(
@@ -78,6 +92,8 @@ struct ArangoDumpInitializer
 
  private:
   int* _ret;
+  char const* _binaryName;
+  ArangoDumpServer& _client;
 };
 
 int main(int argc, char* argv[]) {

diff --git a/client-tools/Dump/arangodump.h b/client-tools/Dump/arangodump.h
@@ -37,7 +37,7 @@ using ArangoDumpFeatures = ArangoClientFeatures<
 #ifdef USE_ENTERPRISE
     EncryptionFeature,
 #endif
-    DumpFeature>;
+    BasicFeaturePhaseClient, DumpFeature>;
 
 using ArangoDumpServer = ApplicationServerT<ArangoDumpFeatures>;
 using ArangoDumpFeature = ApplicationFeatureT<ArangoDumpServer>;

diff --git a/client-tools/Export/ExportFeature.cpp b/client-tools/Export/ExportFeature.cpp
@@ -243,7 +243,11 @@ void ExportFeature::validateOptions(
 }
 
 void ExportFeature::prepare() {
-  _directory = std::make_unique<ManagedDirectory>(server(), _outputDirectory,
+  auto* encryption = server().hasFeature<EncryptionFeature>()
+                         ? &server().getFeature<EncryptionFeature>()
+                         : nullptr;
+
+  _directory = std::make_unique<ManagedDirectory>(encryption, _outputDirectory,
                                                   !_overwrite, true, _useGzip);
   if (_directory->status().fail()) {
     switch (static_cast<int>(_directory->status().errorNumber())) {

diff --git a/client-tools/Export/arangoexport.cpp b/client-tools/Export/arangoexport.cpp
@@ -54,21 +54,35 @@
 using namespace arangodb;
 using namespace arangodb::application_features;
 
-struct ArangoExportInitializer
-    : public ArangoClientInitializer<ArangoExportServer> {
+class ArangoExportInitializer {
  public:
   ArangoExportInitializer(int* ret, char const* binaryName,
                           ArangoExportServer& client)
-      : ArangoClientInitializer{binaryName, client}, _ret{ret} {}
+      : _ret{ret}, _binaryName{binaryName}, _client{client} {}
 
-  using ArangoClientInitializer::operator();
+  template<typename T>
+  void operator()(TypeTag<T>) {
+    _client.addFeature<T>();
+  }
+
+  void operator()(TypeTag<GreetingsFeaturePhase>) {
+    _client.addFeature<GreetingsFeaturePhase>(std::true_type{});
+  }
+
+  void operator()(TypeTag<ConfigFeature>) {
+    _client.addFeature<ConfigFeature>(_binaryName);
+  }
+
+  void operator()(TypeTag<LoggerFeature>) {
+    _client.addFeature<LoggerFeature>(false);
+  }
 
   void operator()(TypeTag<HttpEndpointProvider>) {
     _client.addFeature<HttpEndpointProvider, ClientFeature>(false);
   }
 
   void operator()(TypeTag<ExportFeature>) {
-    _client.addFeature<ExportFeature>(*_ret);
+    _client.addFeature<ExportFeature>(_ret);
   }
 
   void operator()(TypeTag<ShutdownFeature>) {
@@ -77,11 +91,13 @@ struct ArangoExportInitializer
   }
 
   void operator()(TypeTag<TempFeature>) {
-    _client.template addFeature<TempFeature>(_binaryName);
+    _client.addFeature<TempFeature>(_binaryName);
   }
 
  private:
   int* _ret;
+  char const* _binaryName;
+  ArangoExportServer& _client;
 };
 
 int main(int argc, char* argv[]) {

diff --git a/client-tools/Export/arangoexport.h b/client-tools/Export/arangoexport.h
@@ -38,7 +38,7 @@ using ArangoExportFeatures = ArangoClientFeatures<
 #ifdef USE_ENTERPRISE
     EncryptionFeature,
 #endif
-    TempFeature, ExportFeature>;
+    BasicFeaturePhaseClient, TempFeature, ExportFeature>;
 
 using ArangoExportServer = ApplicationServerT<ArangoExportFeatures>;
 using ArangoExportFeature = ApplicationFeatureT<ArangoExportServer>;

diff --git a/client-tools/Import/ImportFeature.cpp b/client-tools/Import/ImportFeature.cpp
@@ -477,9 +477,14 @@ void ImportFeature::start() {
 
   _httpClient->disconnect();  // we do not reuse this anymore
 
+  auto* encryption = server().hasFeature<EncryptionFeature>()
+                         ? &server().getFeature<EncryptionFeature>()
+                         : nullptr;
+
   SimpleHttpClientParams params = _httpClient->params();
-  arangodb::import::ImportHelper ih(client, client.endpoint(), params,
-                                    _chunkSize, _threadCount, _autoChunkSize);
+  arangodb::import::ImportHelper ih(encryption, client, client.endpoint(),
+                                    params, _chunkSize, _threadCount,
+                                    _autoChunkSize);
 
   // create colletion
   if (_createCollection) {

diff --git a/client-tools/Import/ImportHelper.cpp b/client-tools/Import/ImportHelper.cpp
@@ -158,12 +158,13 @@ unsigned const ImportHelper::MaxBatchSize = 768 * 1024 * 1024;
 /// constructor and destructor
 ////////////////////////////////////////////////////////////////////////////////
 
-ImportHelper::ImportHelper(ClientFeature const& client,
+ImportHelper::ImportHelper(EncryptionFeature* encryption,
+                           ClientFeature const& client,
                            std::string const& endpoint,
                            httpclient::SimpleHttpClientParams const& params,
                            uint64_t maxUploadSize, uint32_t threadCount,
                            bool autoUploadSize)
-    : _clientFeature(client),
+    : _encryption{encryption},
       _httpClient(client.createHttpClient(endpoint, params)),
       _maxUploadSize(maxUploadSize),
       _periodByteCount(0),
@@ -239,8 +240,8 @@ bool ImportHelper::readHeadersFile(std::string const& headersFile,
   TRI_ASSERT(!headersFile.empty());
   TRI_ASSERT(!_headersSeen);
 
-  ManagedDirectory directory(_clientFeature.server(), TRI_Dirname(headersFile),
-                             false, false, false);
+  ManagedDirectory directory(_encryption, TRI_Dirname(headersFile), false,
+                             false, false);
   if (directory.status().fail()) {
     _errorMessages.emplace_back(directory.status().errorMessage());
     return false;
@@ -331,11 +332,7 @@ bool ImportHelper::importDelimited(std::string const& collectionName,
                                    std::string const& pathName,
                                    std::string const& headersFile,
                                    DelimitedImportType typeImport) {
-  auto* encryption = _server.hasFeature<EncryptionFeature>()
-                         ? &_server.getFeature<EncryptionFeature>()
-                         : nullptr;
-
-  ManagedDirectory directory(encryption, TRI_Dirname(pathName), false, false,
+  ManagedDirectory directory(_encryption, TRI_Dirname(pathName), false, false,
                              true);
   if (directory.status().fail()) {
     _errorMessages.emplace_back(directory.status().errorMessage());
@@ -458,8 +455,8 @@ bool ImportHelper::importDelimited(std::string const& collectionName,
 bool ImportHelper::importJson(std::string const& collectionName,
                               std::string const& pathName,
                               bool assumeLinewise) {
-  ManagedDirectory directory(_clientFeature.server(), TRI_Dirname(pathName),
-                             false, false, true);
+  ManagedDirectory directory(_encryption, TRI_Dirname(pathName), false, false,
+                             true);
   std::string fileName(TRI_Basename(pathName.c_str()));
   _collectionName = collectionName;
   _firstLine = "";