[remove] configurator changes

Author: iceseer

example/config.yaml

@@ -1,7 +1,5 @@
 general:
   name: NameFromConfig
-  base_path: /tmp/jam_node
-  modules_dir: modules
 
 metrics:
   enabled: true

src/app/configuration.cpp

@@ -18,14 +18,6 @@ namespace jam::app {
     return name_;
   }
 
-  std::filesystem::path Configuration::basePath() const {
-    return base_path_;
-  }
-
-  std::filesystem::path Configuration::modulesDir() const {
-    return modules_dir_;
-  }
-
   std::optional<Configuration::Endpoint> Configuration::metricsEndpoint()
       const {
     return metrics_endpoint_;

src/app/configuration.hpp

@@ -23,8 +23,6 @@ namespace jam::app {
 
     [[nodiscard]] std::string nodeVersion() const;
     [[nodiscard]] std::string nodeName() const;
-    [[nodiscard]] std::filesystem::path basePath() const;
-    [[nodiscard]] std::filesystem::path modulesDir() const;
 
     [[nodiscard]] std::optional<Endpoint> metricsEndpoint() const;
 
@@ -33,8 +31,6 @@ namespace jam::app {
 
     std::string version_;
     std::string name_;
-    std::filesystem::path base_path_;
-    std::filesystem::path modules_dir_;
 
     Endpoint metrics_endpoint_;
     std::optional<bool> metrics_enabled_;

src/app/configurator.cpp

@@ -27,8 +27,6 @@ OUTCOME_CPP_DEFINE_CATEGORY(jam::app, Configurator::Error, e) {
       return "CLI Arguments parse failed";
     case E::ConfigFileParseFailed:
       return "Config file parse failed";
-    case E::InvalidValue:
-      return "Result config has invalid values";
   }
   BOOST_UNREACHABLE_RETURN("Unknown log::Error");
 }
@@ -86,18 +84,16 @@ namespace jam::app {
 
     po::options_description general_options("General options", 120, 100);
     general_options.add_options()
-        ("help,h", "Show this help message")
-        ("version,v", "Show version information")
-        ("base_path", po::value<std::string>(), "Set base path. All relative paths will be resolved based on this path.")
-        ("config,c", po::value<std::string>(),  "Optional. Filepath to load configuration from. Overrides default configuration values.")
-        ("name,n", po::value<std::string>(), "Set name of node")
+        ("help,h", "show this help message")
+        ("version,v", "show version information")
+        ("name,n", po::value<std::string>(), "set name of node")
+        ("config,c", po::value<std::string>(),  "optional, filepath to load configuration from. Overrides default config values")
         ("log,l", po::value<std::vector<std::string>>(),
           "Sets a custom logging filter.\n"
-          "Syntax: <target>=<level>, e.g., -llibp2p=off.\n"
-          "Log levels: trace, debug, verbose, info, warn, error, critical, off.\n"
-          "Default: all targets log at `info`.\n"
-          "Global log level can be set with: -l<level>.")
-        ("modules_dir", po::value<std::string>(), "Set path to modules directory.")
+          "Syntax is `<target>=<level>`, e.g. -llibp2p=off.\n"
+          "Log levels (most to least verbose) are trace, debug, verbose, info, warn, error, critical, off.\n"
+          "By default, all targets log `info`.\n"
+          "The global log level can be set with -l<level>.")
         ;
 
     po::options_description metrics_options("Metric options");
@@ -196,8 +192,7 @@ namespace jam::app {
   }
 
   outcome::result<std::shared_ptr<Configuration>> Configurator::calculateConfig(
-      qtils::StrictSharedPtr<soralog::Logger> logger) {
-    logger_ = std::move(logger);
+      std::shared_ptr<soralog::Logger> logger) {
     OUTCOME_TRY(initGeneralConfig());
     OUTCOME_TRY(initOpenMetricsConfig());
 
@@ -220,97 +215,24 @@ namespace jam::app {
               file_has_error_ = true;
             }
           }
-          auto base_path = section["base_path"];
-          if (base_path.IsDefined()) {
-            if (base_path.IsScalar()) {
-              auto value = base_path.as<std::string>();
-              config_->base_path_ = value;
-            } else {
-              file_errors_ << "E: Value 'general.base_path' must be scalar\n";
-              file_has_error_ = true;
-            }
-          }
-          auto modules_dir = section["modules_dir"];
-          if (modules_dir.IsDefined()) {
-            if (modules_dir.IsScalar()) {
-              auto value = modules_dir.as<std::string>();
-              config_->modules_dir_ = value;
-            } else {
-              file_errors_ << "E: Value 'general.modules_dir' must be scalar\n";
-              file_has_error_ = true;
-            }
-          }
         } else {
-          file_errors_ << "E: Section 'general' defined, but is not map\n";
+          file_errors_ << "E: Section 'general' defined, but is not scalar\n";
           file_has_error_ = true;
         }
       }
     }
 
-    if (file_has_error_) {
-      std::string path;
-      find_argument<std::string>(
-          cli_values_map_, "config", [&](const std::string &value) {
-            path = value;
-          });
-      SL_ERROR(logger_, "Config file `{}` has some problems:", path);
-      std::istringstream iss(file_errors_.str());
-      std::string line;
-      while (std::getline(iss, line)) {
-        SL_ERROR(logger_, "  {}", std::string_view(line).substr(3));
-      }
-      return Error::ConfigFileParseFailed;
-    }
-
-    // Adjust by CLI arguments
     bool fail;
 
     fail = false;
     find_argument<std::string>(
         cli_values_map_, "name", [&](const std::string &value) {
           config_->name_ = value;
         });
-    find_argument<std::string>(
-        cli_values_map_, "base_path", [&](const std::string &value) {
-          config_->base_path_ = value;
-        });
-    find_argument<std::string>(
-        cli_values_map_, "modules_dir", [&](const std::string &value) {
-          config_->modules_dir_ = value;
-        });
     if (fail) {
       return Error::CliArgsParseFailed;
     }
 
-    // Check values
-    if (not config_->base_path_.is_absolute()) {
-      SL_ERROR(logger_,
-               "The 'base_path' must be defined as absolute: {}",
-               config_->base_path_.c_str());
-      return Error::InvalidValue;
-    }
-    if (not is_directory(config_->base_path_)) {
-      SL_ERROR(logger_,
-               "The 'base_path' does not exist or is not a directory: {}",
-               config_->base_path_.c_str());
-      return Error::InvalidValue;
-    }
-    current_path(config_->base_path_);
-
-    auto make_absolute = [&](const std::filesystem::path &path) {
-      return weakly_canonical(config_->base_path_.is_absolute()
-                                  ? path
-                                  : (config_->base_path_ / path));
-    };
-
-    config_->modules_dir_ = make_absolute(config_->modules_dir_);
-    if (not is_directory(config_->modules_dir_)) {
-      SL_ERROR(logger_,
-               "The 'modules_dir' does not exist or is not a directory: {}",
-               config_->modules_dir_.c_str());
-      return Error::InvalidValue;
-    }
-
     return outcome::success();
   }
 

src/app/configurator.hpp

@@ -5,11 +5,11 @@
 
 #pragma once
 
+#include <optional>
+
 #include <boost/program_options.hpp>
-#include <log/logger.hpp>
 #include <qtils/enum_error_code.hpp>
 #include <qtils/outcome.hpp>
-#include <qtils/strict_sptr.hpp>
 #include <yaml-cpp/yaml.h>
 
 #include "injector/dont_inject.hpp"
@@ -29,7 +29,6 @@ namespace jam::app {
     enum class Error : uint8_t {
       CliArgsParseFailed,
       ConfigFileParseFailed,
-      InvalidValue,
     };
 
     DONT_INJECT(Configurator);
@@ -52,7 +51,7 @@ namespace jam::app {
     outcome::result<YAML::Node> getLoggingConfig();
 
     outcome::result<std::shared_ptr<Configuration>> calculateConfig(
-        qtils::StrictSharedPtr<soralog::Logger> logger);
+        std::shared_ptr<soralog::Logger> logger);
 
    private:
     outcome::result<void> initGeneralConfig();
@@ -63,7 +62,6 @@ namespace jam::app {
     const char **env_;
 
     std::shared_ptr<Configuration> config_;
-    std::shared_ptr<soralog::Logger> logger_;
 
     std::optional<YAML::Node> config_file_;
     bool file_has_warn_ = false;

src/app/impl/application_impl.cpp

@@ -20,12 +20,12 @@
 namespace jam::app {
 
   ApplicationImpl::ApplicationImpl(
-      qtils::StrictSharedPtr<log::LoggingSystem> logsys,
-      qtils::StrictSharedPtr<Configuration> config,
-      qtils::StrictSharedPtr<StateManager> state_manager,
-      qtils::StrictSharedPtr<Watchdog> watchdog,
-      qtils::StrictSharedPtr<metrics::Exposer> metrics_exposer,
-      qtils::StrictSharedPtr<clock::SystemClock> system_clock)
+      std::shared_ptr<log::LoggingSystem> logsys,
+      std::shared_ptr<Configuration> config,
+      std::shared_ptr<StateManager> state_manager,
+      std::shared_ptr<Watchdog> watchdog,
+      std::shared_ptr<metrics::Exposer> metrics_exposer,
+      std::shared_ptr<clock::SystemClock> system_clock)
       : logger_(logsys->getLogger("Application", "application")),
         app_config_(std::move(config)),
         state_manager_(std::move(state_manager)),
@@ -34,13 +34,15 @@ namespace jam::app {
         system_clock_(std::move(system_clock)),
         metrics_registry_(metrics::createRegistry()) {
     // Metric for exposing name and version of node
-    metrics::GaugeHelper(
-        "jam_build_info",
-        "A metric with a constant '1' value labeled by name, version",
-        std::map<std::string, std::string>{
-            {"name", app_config_->nodeName()},
-            {"version", app_config_->nodeVersion()}})
-        ->set(1);
+    constexpr auto buildInfoMetricName = "jam_build_info";
+    metrics_registry_->registerGaugeFamily(
+        buildInfoMetricName,
+        "A metric with a constant '1' value labeled by name, version");
+    auto metric_build_info = metrics_registry_->registerGaugeMetric(
+        buildInfoMetricName,
+        {{"name", app_config_->nodeName()},
+         {"version", app_config_->nodeVersion()}});
+    metric_build_info->set(1);
   }
 
   void ApplicationImpl::run() {

src/app/impl/application_impl.hpp

@@ -44,22 +44,22 @@ namespace jam::app {
 
   class ApplicationImpl final : public Application {
    public:
-    ApplicationImpl(qtils::StrictSharedPtr<log::LoggingSystem> logsys,
-                    qtils::StrictSharedPtr<Configuration> config,
-                    qtils::StrictSharedPtr<StateManager> state_manager,
-                    qtils::StrictSharedPtr<Watchdog> watchdog,
-                    qtils::StrictSharedPtr<metrics::Exposer> metrics_exposer,
-                    qtils::StrictSharedPtr<clock::SystemClock> system_clock);
+    ApplicationImpl(std::shared_ptr<log::LoggingSystem> logsys,
+                    std::shared_ptr<Configuration> config,
+                    std::shared_ptr<StateManager> state_manager,
+                    std::shared_ptr<Watchdog> watchdog,
+                    std::shared_ptr<metrics::Exposer> metrics_exposer,
+                    std::shared_ptr<clock::SystemClock> system_clock);
 
     void run() override;
 
    private:
-    qtils::StrictSharedPtr<soralog::Logger> logger_;
-    qtils::StrictSharedPtr<Configuration> app_config_;
-    qtils::StrictSharedPtr<StateManager> state_manager_;
-    qtils::StrictSharedPtr<Watchdog> watchdog_;
-    qtils::StrictSharedPtr<metrics::Exposer> metrics_exposer_;
-    qtils::StrictSharedPtr<clock::SystemClock> system_clock_;
+    std::shared_ptr<soralog::Logger> logger_;
+    std::shared_ptr<Configuration> app_config_;
+    std::shared_ptr<StateManager> state_manager_;
+    std::shared_ptr<Watchdog> watchdog_;
+    std::shared_ptr<metrics::Exposer> metrics_exposer_;
+    std::shared_ptr<clock::SystemClock> system_clock_;
 
     // Metrics
     std::unique_ptr<metrics::Registry> metrics_registry_;

src/app/impl/state_manager_impl.cpp

@@ -92,7 +92,7 @@ namespace jam::app {
   }
 
   StateManagerImpl::StateManagerImpl(
-      qtils::StrictSharedPtr<log::LoggingSystem> logging_system)
+      std::shared_ptr<log::LoggingSystem> logging_system)
       : logger_(logging_system->getLogger("StateManager", "application")),
         logging_system_(std::move(logging_system)) {
     shuttingDownSignalsEnable();

src/app/impl/state_manager_impl.hpp

@@ -7,11 +7,10 @@
 #pragma once
 
 #include <condition_variable>
+#include <csignal>
 #include <mutex>
 #include <queue>
 
-#include <qtils/strict_sptr.hpp>
-
 #include "app/state_manager.hpp"
 #include "utils/ctor_limiters.hpp"
 
@@ -29,7 +28,7 @@ namespace jam::app {
         public StateManager,
         public std::enable_shared_from_this<StateManagerImpl> {
    public:
-    StateManagerImpl(qtils::StrictSharedPtr<log::LoggingSystem> logging_system);
+    StateManagerImpl(std::shared_ptr<log::LoggingSystem> logging_system);
 
     ~StateManagerImpl() override;
 
@@ -66,8 +65,8 @@ namespace jam::app {
 
     void shutdownRequestWaiting();
 
-    qtils::StrictSharedPtr<soralog::Logger> logger_;
-    qtils::StrictSharedPtr<log::LoggingSystem> logging_system_;
+    std::shared_ptr<soralog::Logger> logger_;
+    std::shared_ptr<log::LoggingSystem> logging_system_;
 
     std::atomic<State> state_ = State::Init;
 

src/executable/jam_node.cpp

@@ -48,7 +48,7 @@ namespace {
     // Load modules
     {
       auto logger = logsys->getLogger("Modules", "jam");
-      const std::string path(appcfg->modulesDir());
+      const std::string path("modules");
 
       jam::modules::ModuleLoader module_loader(path);
       auto modules = module_loader.get_modules();