Expose mappings of requirements, provides and modules to modules

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.14)
 
 project(everest-framework
-    VERSION 0.17.2
+    VERSION 0.18.0
     DESCRIPTION "The open operating system for e-mobility charging stations"
     LANGUAGES CXX C
 )

include/framework/ModuleAdapter.hpp

@@ -92,6 +92,8 @@ struct ModuleAdapter {
     using ExtMqttSubscribeFunc = std::function<UnsubscribeToken(const std::string&, StringHandler)>;
     using TelemetryPublishFunc =
         std::function<void(const std::string&, const std::string&, const std::string&, const TelemetryMap&)>;
+    using GetMappingFunc = std::function<std::optional<ModuleTierMappings>()>;
+    using GetImplMappingFunc = std::function<std::optional<Mapping>(const std::string&)>;
 
     CallFunc call;
     PublishFunc publish;
@@ -107,6 +109,8 @@ struct ModuleAdapter {
     ExtMqttSubscribeFunc ext_mqtt_subscribe;
     std::vector<cmd> registered_commands;
     TelemetryPublishFunc telemetry_publish;
+    GetMappingFunc get_mapping;
+    GetImplMappingFunc get_impl_mapping;
 
     void check_complete() {
         // FIXME (aw): I should throw if some of my handlers are not set

include/framework/everest.hpp

@@ -142,6 +142,16 @@ class Everest {
     /// \returns true if telemetry is enabled
     bool is_telemetry_enabled();
 
+    ///
+    /// \returns the 3 tier model mappings for this module
+    ///
+    std::optional<ModuleTierMappings> get_3_tier_model_mapping();
+
+    ///
+    /// \returns the 3 tier model mapping for the given \p impl_id
+    ///
+    std::optional<Mapping> get_3_tier_model_mapping(const std::string& impl_id);
+
     ///
     /// \brief Chccks if all commands of a module that are listed in its manifest are available
     ///

include/framework/runtime.hpp

@@ -134,14 +134,18 @@ void populate_module_info_path_from_runtime_settings(ModuleInfo&, std::shared_pt
 
 struct ModuleCallbacks {
     std::function<void(ModuleAdapter module_adapter)> register_module_adapter;
-    std::function<std::vector<cmd>(const json& connections)> everest_register;
+    std::function<std::vector<cmd>(
+        const std::map<std::string, std::vector<RequirementConnection>>& requirement_connections)>
+        everest_register;
     std::function<void(ModuleConfigs module_configs, const ModuleInfo& info)> init;
     std::function<void()> ready;
 
     ModuleCallbacks() = default;
 
     ModuleCallbacks(const std::function<void(ModuleAdapter module_adapter)>& register_module_adapter,
-                    const std::function<std::vector<cmd>(const json& connections)>& everest_register,
+                    const std::function<std::vector<cmd>(
+                        const std::map<std::string, std::vector<RequirementConnection>>& requirement_connections)>&
+                        everest_register,
                     const std::function<void(ModuleConfigs module_configs, const ModuleInfo& info)>& init,
                     const std::function<void()>& ready);
 };

include/utils/config.hpp

@@ -147,9 +147,9 @@ class Config {
     json resolve_requirement(const std::string& module_id, const std::string& requirement_id) const;
 
     ///
-    /// \returns a list of Requirements for \p module_id
+    /// \returns a map of RequirementConnections for \p module_id
     ///
-    std::list<Requirement> get_requirements(const std::string& module_id) const;
+    std::map<std::string, std::vector<RequirementConnection>> get_requirement_connections(const std::string& module_id);
 
     ///
     /// \brief checks if the config contains the given \p module_id

include/utils/types.hpp

@@ -64,26 +64,6 @@ enum class QOS {
     QOS2  ///< Exactly once delivery
 };
 
-struct ModuleInfo {
-    struct Paths {
-        std::filesystem::path etc;
-        std::filesystem::path libexec;
-        std::filesystem::path share;
-    };
-
-    std::string name;
-    std::vector<std::string> authors;
-    std::string license;
-    std::string id;
-    Paths paths;
-    bool telemetry_enabled;
-    bool global_errors_enabled;
-};
-
-struct TelemetryConfig {
-    int id;
-};
-
 /// \brief A Mapping that can be used to map a module or implementation to a specific EVSE or optionally to a Connector
 struct Mapping {
     int evse;                     ///< The EVSE id
@@ -96,6 +76,30 @@ struct Mapping {
     }
 };
 
+/// \brief Writes the string representation of the given Mapping \p mapping to the given output stream \p os
+/// \returns an output stream with the Mapping written to
+inline std::ostream& operator<<(std::ostream& os, const Mapping& mapping) {
+    os << "Mapping(evse: " << mapping.evse;
+    if (mapping.connector.has_value()) {
+        os << ", connector: " << mapping.connector.value();
+    }
+    os << ")";
+
+    return os;
+}
+
+/// \brief Writes the string representation of the given Mapping \p mapping to the given output stream \p os
+/// \returns an output stream with the Mapping written to
+inline std::ostream& operator<<(std::ostream& os, const std::optional<Mapping>& mapping) {
+    if (mapping.has_value()) {
+        os << mapping.value();
+    } else {
+        os << "Mapping(charging station)";
+    }
+
+    return os;
+}
+
 /// \brief A 3 tier mapping for a module and its individual implementations
 struct ModuleTierMappings {
     std::optional<Mapping> module; ///< Mapping of the whole module to an EVSE id and optional Connector id. If this is
@@ -104,11 +108,39 @@ struct ModuleTierMappings {
         implementations; ///< Mappings for the individual implementations of the module
 };
 
+struct ModuleInfo {
+    struct Paths {
+        std::filesystem::path etc;
+        std::filesystem::path libexec;
+        std::filesystem::path share;
+    };
+
+    std::string name;
+    std::vector<std::string> authors;
+    std::string license;
+    std::string id;
+    Paths paths;
+    bool telemetry_enabled;
+    bool global_errors_enabled;
+    std::optional<Mapping> mapping;
+};
+
+struct TelemetryConfig {
+    int id;
+};
+
 struct Requirement {
-    Requirement(const std::string& requirement_id_, size_t index_);
+    Requirement() = default;
+    Requirement(const std::string& requirement_id_, size_t index_, std::optional<Mapping> mapping = std::nullopt);
     bool operator<(const Requirement& rhs) const;
     std::string id;
-    size_t index;
+    size_t index = 0;
+    std::optional<Mapping> mapping;
+};
+
+struct RequirementConnection {
+    Requirement requirement;
+    std::string requirement_module_id;
 };
 
 struct ImplementationIdentifier {

lib/config.cpp

@@ -705,23 +705,32 @@ json Config::resolve_requirement(const std::string& module_id, const std::string
     return module_config["connections"][requirement_id];
 }
 
-std::list<Requirement> Config::get_requirements(const std::string& module_id) const {
+std::map<std::string, std::vector<RequirementConnection>>
+Config::get_requirement_connections(const std::string& module_id) {
     BOOST_LOG_FUNCTION();
 
-    std::list<Requirement> res;
+    std::map<std::string, std::vector<RequirementConnection>> res;
 
     std::string module_name = get_module_name(module_id);
     for (const std::string& req_id : Config::keys(this->manifests.at(module_name).at("requires"))) {
+        std::vector<RequirementConnection> requirement_connections;
         json resolved_req = this->resolve_requirement(module_id, req_id);
         if (!resolved_req.is_array()) {
-            Requirement req(req_id, 0);
-            res.push_back(req);
+            auto resolved_module_id = resolved_req.at("module_id");
+            auto resolved_impl_id = resolved_req.at("implementation_id");
+            const auto mapping = this->get_3_tier_model_mapping(resolved_module_id, resolved_impl_id);
+            Requirement req(req_id, 0, mapping);
+            requirement_connections.push_back({req, resolved_module_id});
         } else {
             for (int i = 0; i < resolved_req.size(); i++) {
-                Requirement req(req_id, i);
-                res.push_back(req);
+                auto resolved_module_id = resolved_req.at(i).at("module_id");
+                auto resolved_impl_id = resolved_req.at(i).at("implementation_id");
+                const auto mapping = this->get_3_tier_model_mapping(resolved_module_id, resolved_impl_id);
+                Requirement req(req_id, i, mapping);
+                requirement_connections.push_back({req, resolved_module_id});
             }
         }
+        res[req_id] = requirement_connections;
     }
 
     return res;
@@ -823,7 +832,8 @@ std::optional<Mapping> Config::get_3_tier_model_mapping(const std::string& modul
     }
     auto& mapping = module_tier_mappings.value();
     if (mapping.implementations.find(impl_id) == mapping.implementations.end()) {
-        return std::nullopt;
+        // if no specific implementation mapping is given, use the module mapping
+        return mapping.module;
     }
     return mapping.implementations.at(impl_id);
 }

lib/everest.cpp

@@ -158,30 +158,33 @@ Everest::Everest(std::string module_id_, const Config& config_, bool validate_da
     }
 
     // setup error_databases, error_managers and error_state_monitors for all requirements
-    for (const Requirement& req : config.get_requirements(module_id)) {
-        // setup shared database
-        std::shared_ptr<error::ErrorDatabaseMap> error_database = std::make_shared<error::ErrorDatabaseMap>();
-
-        // setup error manager
-        std::string interface_name = this->module_manifest.at("requires").at(req.id).at("interface");
-        json interface_def = this->config.get_interface_definition(interface_name);
-        std::list<std::string> allowed_error_types;
-        for (const auto& error_namespace_it : interface_def["errors"].items()) {
-            for (const auto& error_name_it : error_namespace_it.value().items()) {
-                allowed_error_types.push_back(error_namespace_it.key() + "/" + error_name_it.key());
+    for (const auto& requirement_connections : config.get_requirement_connections(module_id)) {
+        for (const RequirementConnection& req_con : requirement_connections.second) {
+            auto& req = req_con.requirement;
+            // setup shared database
+            std::shared_ptr<error::ErrorDatabaseMap> error_database = std::make_shared<error::ErrorDatabaseMap>();
+
+            // setup error manager
+            std::string interface_name = this->module_manifest.at("requires").at(req.id).at("interface");
+            json interface_def = this->config.get_interface_definition(interface_name);
+            std::list<std::string> allowed_error_types;
+            for (const auto& error_namespace_it : interface_def["errors"].items()) {
+                for (const auto& error_name_it : error_namespace_it.value().items()) {
+                    allowed_error_types.push_back(error_namespace_it.key() + "/" + error_name_it.key());
+                }
             }
+            error::ErrorManagerReq::SubscribeErrorFunc subscribe_error_func =
+                [this, req](const error::ErrorType& type, const error::ErrorCallback& callback,
+                            const error::ErrorCallback& clear_callback) {
+                    this->subscribe_error(req, type, callback, clear_callback);
+                };
+            this->req_error_managers[req] = std::make_shared<error::ErrorManagerReq>(
+                std::make_shared<error::ErrorTypeMap>(this->config.get_error_map()), error_database,
+                allowed_error_types, subscribe_error_func);
+
+            // setup error state monitor
+            this->req_error_state_monitors[req] = std::make_shared<error::ErrorStateMonitor>(error_database);
         }
-        error::ErrorManagerReq::SubscribeErrorFunc subscribe_error_func =
-            [this, req](const error::ErrorType& type, const error::ErrorCallback& callback,
-                        const error::ErrorCallback& clear_callback) {
-                this->subscribe_error(req, type, callback, clear_callback);
-            };
-        this->req_error_managers[req] = std::make_shared<error::ErrorManagerReq>(
-            std::make_shared<error::ErrorTypeMap>(this->config.get_error_map()), error_database, allowed_error_types,
-            subscribe_error_func);
-
-        // setup error state monitor
-        this->req_error_state_monitors[req] = std::make_shared<error::ErrorStateMonitor>(error_database);
     }
 
     // register handler for global ready signal
@@ -252,6 +255,22 @@ void Everest::register_on_ready_handler(const std::function<void()>& handler) {
     this->on_ready = std::make_unique<std::function<void()>>(handler);
 }
 
+std::optional<ModuleTierMappings> Everest::get_3_tier_model_mapping() {
+    return this->module_tier_mappings;
+}
+
+std::optional<Mapping> Everest::get_3_tier_model_mapping(const std::string& impl_id) {
+    if (not this->module_tier_mappings.has_value()) {
+        return std::nullopt;
+    }
+    auto& mapping = this->module_tier_mappings.value();
+    if (mapping.implementations.find(impl_id) == mapping.implementations.end()) {
+        // if no specific implementation mapping is given, use the module mapping
+        return mapping.module;
+    }
+    return mapping.implementations.at(impl_id);
+}
+
 void Everest::check_code() {
     BOOST_LOG_FUNCTION();
 

lib/runtime.cpp

@@ -383,10 +383,12 @@ RuntimeSettings::RuntimeSettings(const std::string& prefix_, const std::string&
     }
 }
 
-ModuleCallbacks::ModuleCallbacks(const std::function<void(ModuleAdapter module_adapter)>& register_module_adapter,
-                                 const std::function<std::vector<cmd>(const json& connections)>& everest_register,
-                                 const std::function<void(ModuleConfigs module_configs, const ModuleInfo& info)>& init,
-                                 const std::function<void()>& ready) :
+ModuleCallbacks::ModuleCallbacks(
+    const std::function<void(ModuleAdapter module_adapter)>& register_module_adapter,
+    const std::function<std::vector<cmd>(
+        const std::map<std::string, std::vector<RequirementConnection>>& requirement_connections)>& everest_register,
+    const std::function<void(ModuleConfigs module_configs, const ModuleInfo& info)>& init,
+    const std::function<void()>& ready) :
     register_module_adapter(register_module_adapter), everest_register(everest_register), init(init), ready(ready) {
 }
 
@@ -495,11 +497,16 @@ int ModuleLoader::initialize() {
             return everest.telemetry_publish(category, subcategory, type, telemetry);
         };
 
+        module_adapter.get_mapping = [&everest]() { return everest.get_3_tier_model_mapping(); };
+
+        module_adapter.get_impl_mapping = [&everest](const std::string& impl_id) {
+            return everest.get_3_tier_model_mapping(impl_id);
+        };
+
         this->callbacks.register_module_adapter(module_adapter);
 
         // FIXME (aw): would be nice to move this config related thing toward the module_init function
-        std::vector<cmd> cmds =
-            this->callbacks.everest_register(config.get_main_config()[this->module_id]["connections"]);
+        std::vector<cmd> cmds = this->callbacks.everest_register(config.get_requirement_connections(this->module_id));
 
         for (auto const& command : cmds) {
             everest.provide_cmd(command);
@@ -509,6 +516,10 @@ int ModuleLoader::initialize() {
         auto module_info = config.get_module_info(this->module_id);
         populate_module_info_path_from_runtime_settings(module_info, rs);
         module_info.telemetry_enabled = everest.is_telemetry_enabled();
+        auto module_mappings = everest.get_3_tier_model_mapping();
+        if (module_mappings.has_value()) {
+            module_info.mapping = module_mappings.value().module;
+        }
 
         this->callbacks.init(module_configs, module_info);
 

lib/types.cpp

@@ -13,7 +13,8 @@ TypedHandler::TypedHandler(HandlerType type_, std::shared_ptr<Handler> handler_)
     TypedHandler("", "", type_, handler_) {
 }
 
-Requirement::Requirement(const std::string& requirement_id_, size_t index_) : id(requirement_id_), index(index_) {
+Requirement::Requirement(const std::string& requirement_id_, size_t index_, std::optional<Mapping> mapping) :
+    id(requirement_id_), index(index_), mapping(mapping) {
 }
 
 bool Requirement::operator<(const Requirement& rhs) const {