Updated configuration for CapioCL

capiocl/configuration.h

@@ -72,15 +72,18 @@ class capiocl::configuration::CapioClConfiguration {
      * Get a string value
      * @param key key of option to get
      * @param value reference in which value will be stored
+     * @param def_value default value if @p key is not found in current configuration
      */
-    void getParameter(const std::string &key, int *value) const;
+    void getParameter(const std::string &key, int *value, int def_value) const;
 
     /**
      * Get a integer value
      * @param key key of option to get
      * @param value reference in which value will be stored
+     * @param def_value default value if @p key is not found in current configuration
      */
-    void getParameter(const std::string &key, std::string *value) const;
+    void getParameter(const std::string &key, std::string *value,
+                      const std::string &def_value) const;
 };
 
 /**

capiocl/engine.h

@@ -148,6 +148,9 @@ class Engine final {
     /// @brief Class constructor
     explicit Engine(bool use_default_settings = true);
 
+    /// @brief Class constructor storing CAPIO-CL configuration from external sources.
+    explicit Engine(const configuration::CapioClConfiguration &config);
+
     /// @brief Print the current CAPIO-CL configuration.
     void print() const;
 

src/Engine.cpp

@@ -182,6 +182,20 @@ capiocl::engine::Engine::Engine(const bool use_default_settings) {
         this->useDefaultConfiguration();
     }
 }
+capiocl::engine::Engine::Engine(const configuration::CapioClConfiguration &config) {
+    START_LOG(calf_current_tid(), "call()");
+
+    this->configuration = config;
+
+    node_name = std::string(1024, '\0');
+    gethostname(node_name.data(), node_name.size());
+    node_name.resize(std::strlen(node_name.c_str()));
+
+    this->configuration.getParameter("workflow_name", &this->workflow_name,
+                                     CAPIO_CL_DEFAULT_WF_NAME);
+    LOG("selected workflow name=%s source=environment node=%s", workflow_name.c_str(),
+        node_name.c_str());
+}
 
 void capiocl::engine::Engine::_newFile(const std::filesystem::path &path) const {
     START_LOG(calf_current_tid(), "call()");
@@ -1117,12 +1131,9 @@ void capiocl::engine::Engine::loadConfiguration(const std::string &path) {
 
     std::string multicast_monitor_enabled, fs_monitor_enabled;
 
-    try {
-        configuration.getParameter("monitor.mcast.enabled", &multicast_monitor_enabled);
-    } catch (...) {
-        multicast_monitor_enabled = "false";
-        LOG("configuration fallback key=monitor.mcast.enabled value=false");
-    }
+    configuration.getParameter("monitor.mcast.enabled", &multicast_monitor_enabled, "false");
+
+    LOG("configuration key=monitor.mcast.enabled value=%s", multicast_monitor_enabled.c_str());
 
     if (multicast_monitor_enabled == "true") {
         monitor.registerMonitorBackend(new monitor::MulticastMonitor(configuration));
@@ -1132,12 +1143,10 @@ void capiocl::engine::Engine::loadConfiguration(const std::string &path) {
         CALF_PRINT_COLOR(CALF_CLI_LEVEL_WARNING, "Skipping registration of  MulticastMonitor");
     }
 
-    try {
-        configuration.getParameter("monitor.filesystem.enabled", &fs_monitor_enabled);
-    } catch (...) {
-        fs_monitor_enabled = "false";
-        LOG("configuration fallback key=monitor.filesystem.enabled value=false");
-    }
+    configuration.getParameter("monitor.filesystem.enabled", &fs_monitor_enabled, "false");
+
+    LOG("configuration fallback key=monitor.filesystem.enabled value=%s",
+        fs_monitor_enabled.c_str());
 
     if (fs_monitor_enabled == "true") {
         monitor.registerMonitorBackend(new monitor::FileSystemMonitor());

src/api.cpp

@@ -126,19 +126,17 @@ capiocl::api::CapioClApiServer::CapioClApiServer(engine::Engine *engine,
 
     std::string address;
     int port;
-    try {
-        config.getParameter("dynamic_api.ip", &address); // GCOVR_EXCL_LINE
-    } catch (...) {
-        address = configuration::defaults::DEFAULT_API_MULTICAST_IP.v;
-        LOG("API configuration fallback key=dynamic_api.ip value=%s", address.c_str());
-    }
 
-    try {
-        config.getParameter("dynamic_api.port", &port); // GCOVR_EXCL_LINE
-    } catch (...) {
-        port = std::stoi(configuration::defaults::DEFAULT_API_MULTICAST_PORT.v);
-        LOG("API configuration fallback key=dynamic_api.port value=%d", port);
-    }
+    config.getParameter("dynamic_api.ip", &address,
+                        configuration::defaults::DEFAULT_API_MULTICAST_IP.v); // GCOVR_EXCL_LINE
+
+    LOG("API configuration key=dynamic_api.ip value=%s", address.c_str());
+
+    config.getParameter(
+        "dynamic_api.port", &port,
+        std::stoi(configuration::defaults::DEFAULT_API_MULTICAST_PORT.v)); // GCOVR_EXCL_LINE
+
+    LOG("API configuration key=dynamic_api.port value=%d", port);
 
     _webApiThread = std::thread(server, address, port, engine, &_terminate);
 

src/configuration.cpp

@@ -80,23 +80,23 @@ void capiocl::configuration::CapioClConfiguration::load(const std::filesystem::p
     LOG("loaded configuration path=%s parameters=%zu", path.string().c_str(), config.size());
 }
 
-void capiocl::configuration::CapioClConfiguration::getParameter(const std::string &key,
-                                                                int *value) const {
+void capiocl::configuration::CapioClConfiguration::getParameter(const std::string &key, int *value,
+                                                                int def_value) const {
     START_LOG(calf_current_tid(), "call()");
     if (config.find(key) != config.end()) {
         *value = std::stoi(config.at(key));
     } else {
-        throw CapioClConfigurationException("Key " + key + " not found!");
+        *value = def_value;
     }
 }
 
-void capiocl::configuration::CapioClConfiguration::getParameter(const std::string &key,
-                                                                std::string *value) const {
+void capiocl::configuration::CapioClConfiguration::getParameter(
+    const std::string &key, std::string *value, const std::string &def_value) const {
     START_LOG(calf_current_tid(), "call()");
     if (config.find(key) != config.end()) {
         *value = config.at(key);
     } else {
-        throw CapioClConfigurationException("Key " + key + " not found!");
+        *value = def_value;
     }
 }
 capiocl::configuration::CapioClConfigurationException::CapioClConfigurationException(

src/monitors/Multicast.cpp

@@ -343,11 +343,20 @@ void capiocl::monitor::MulticastMonitor::_send_message(const std::string &ip_add
 capiocl::monitor::MulticastMonitor::MulticastMonitor(
     const configuration::CapioClConfiguration &config) {
     START_LOG(calf_current_tid(), "call()");
-    config.getParameter("monitor.mcast.commit.ip", &MULTICAST_COMMIT_ADDR);
-    config.getParameter("monitor.mcast.commit.port", &MULTICAST_COMMIT_PORT);
-    config.getParameter("monitor.mcast.homenode.ip", &MULTICAST_HOME_NODE_ADDR);
-    config.getParameter("monitor.mcast.homenode.port", &MULTICAST_HOME_NODE_PORT);
-    config.getParameter("monitor.mcast.delay_ms", &MULTICAST_DELAY_MILLIS);
+    config.getParameter("monitor.mcast.commit.ip", &MULTICAST_COMMIT_ADDR,
+                        configuration::defaults::DEFAULT_MONITOR_MCAST_IP.v);
+
+    config.getParameter("monitor.mcast.commit.port", &MULTICAST_COMMIT_PORT,
+                        std::stoi(configuration::defaults::DEFAULT_MONITOR_MCAST_PORT.v));
+
+    config.getParameter("monitor.mcast.homenode.ip", &MULTICAST_HOME_NODE_ADDR,
+                        configuration::defaults::DEFAULT_MONITOR_HOMENODE_IP.v);
+
+    config.getParameter("monitor.mcast.homenode.port", &MULTICAST_HOME_NODE_PORT,
+                        std::stoi(configuration::defaults::DEFAULT_MONITOR_HOMENODE_PORT.v));
+
+    config.getParameter("monitor.mcast.delay_ms", &MULTICAST_DELAY_MILLIS,
+                        std::stoi(configuration::defaults::DEFAULT_MONITOR_MCAST_DELAY.v));
     gethostname(_hostname, sizeof(_hostname));
     _hostname[sizeof(_hostname) - 1] = '\0';
     std::string origin_host(_hostname);

tests/cpp/test_configuration.hpp

@@ -16,20 +16,24 @@ TEST(CONFIGURATION_SUITE_NAME, TestLoadEmptyPath) {
                  capiocl::configuration::CapioClConfigurationException);
 }
 
-TEST(CONFIGURATION_SUITE_NAME, TestExceptions) {
+TEST(CONFIGURATION_SUITE_NAME, TestGetParameter) {
     capiocl::configuration::CapioClConfiguration config;
+    config.load("/tmp/capio_cl_tomls/sample1.toml");
 
-    EXPECT_THROW(config.getParameter("not.a.valid.key", static_cast<int *>(nullptr)),
-                 capiocl::configuration::CapioClConfigurationException);
+    int int_value;
+    config.getParameter("monitor.mcast.delay_ms", &int_value, -1);
+    EXPECT_EQ(int_value, 300);
+    config.getParameter("not.a.valid.key", &int_value, 42);
+    EXPECT_EQ(int_value, 42);
 
-    EXPECT_THROW(config.getParameter("not.a.valid.key", static_cast<std::string *>(nullptr)),
-                 capiocl::configuration::CapioClConfigurationException);
+    std::string string_value;
+    config.getParameter("monitor.mcast.commit.ip", &string_value, "fallback");
+    EXPECT_EQ(string_value, "224.224.224.3");
+    config.getParameter("not.a.valid.key", &string_value, "fallback");
+    EXPECT_EQ(string_value, "fallback");
 
-    try {
-        config.getParameter("not.a.valid.key", static_cast<std::string *>(nullptr));
-    } catch (const capiocl::configuration::CapioClConfigurationException &err) {
-        EXPECT_GT(strlen(err.what()), 0);
-    }
+    EXPECT_THROW(config.getParameter("workflow_name", &int_value, 0),
+                 std::invalid_argument);
 }
 
 TEST(CONFIGURATION_SUITE_NAME, TestFailureParsingTOML) {
@@ -50,11 +54,11 @@ TEST(CONFIGURATION_SUITE_NAME, testNoBackendLoadedWithExplicitNoLoadOption) {
     config.load("/tmp/capio_cl_tomls/sample3.toml");
 
     std::string value;
-    config.getParameter("monitor.mcast.enabled", &value);
+    config.getParameter("monitor.mcast.enabled", &value, "true");
     EXPECT_TRUE("false" == value);
     value = "";
 
-    config.getParameter("monitor.filesystem.enabled", &value);
+    config.getParameter("monitor.filesystem.enabled", &value, "true");
     EXPECT_TRUE("false" == value);
 }
 

tests/cpp/test_engine.hpp

@@ -22,6 +22,16 @@ TEST(ENGINE_SUITE_NAME, testSetGetWfNameFromEnv) {
     EXPECT_TRUE(engine.getWorkflowName() == "my_custom_wf_name");
 }
 
+TEST(ENGINE_SUITE_NAME, testInstantiationFromConfiguration) {
+    capiocl::configuration::CapioClConfiguration config;
+    capiocl::engine::Engine default_engine(config);
+    EXPECT_EQ(default_engine.getWorkflowName(), capiocl::CAPIO_CL_DEFAULT_WF_NAME);
+
+    config.load("/tmp/capio_cl_tomls/sample1.toml");
+    capiocl::engine::Engine configured_engine(config);
+    EXPECT_EQ(configured_engine.getWorkflowName(), "configured_workflow");
+}
+
 TEST(ENGINE_SUITE_NAME, testAddFileDefault) {
     capiocl::engine::Engine engine;
     EXPECT_EQ(engine.size(), 0);
@@ -662,4 +672,4 @@ TEST(ENGINE_SUITE_NAME, TestEngineAddCapioClRule) {
     // TODO: test all entries of capioCL rule
 }
 
-#endif // CAPIO_CL_ENGINE_HPP
+#endif // CAPIO_CL_ENGINE_HPP

tests/tomls/sample1.toml

@@ -1,3 +1,5 @@
+workflow_name = "configured_workflow"
+
 [monitor.filesystem]
 enabled = true