Add basic entrypoint_API module

Signed-off-by: Christoph Burandt <christoph.burandt@pionix.de>

Author: cburandt

config/CMakeLists.txt

@@ -1,3 +1,4 @@
+generate_config_run_script(CONFIG EVerestAPI-entrypoint)
 generate_config_run_script(CONFIG sil)
 generate_config_run_script(CONFIG sil-rpcapi)
 generate_config_run_script(CONFIG sil-two-evse)

config/config-EVerestAPI-entrypoint.yaml

@@ -0,0 +1,52 @@
+settings:
+  telemetry_enabled: true
+active_modules:
+  api_entrypoint:
+    module: EVerest_API
+    mapping:
+      module:
+        evse: 1
+        connector: 2
+    access:
+      config:
+        allow_global_read: true
+        allow_global_write: false
+        allow_set_read_only: false
+        modules:
+          auth:
+            allow_read: true
+            allow_write: true
+            allow_set_read_only: true
+  dm_1:
+    module: display_message_API
+    config_module:
+      cfg_communication_check_to_s: 5
+    mapping:
+      module:
+        evse: 1
+        connector: 1
+      implementations:
+        main:
+          evse: 1
+          connector: 1
+  ps_dc_1:
+    module: power_supply_DC_API
+    config_module:
+      cfg_communication_check_to_s: 0
+      cfg_heartbeat_interval_ms: 10000
+    mapping:
+      module:
+        evse: 1
+        connector: 1
+  ps_dc_2:
+    module: power_supply_DC_API
+    config_module:
+      cfg_communication_check_to_s: 0
+      cfg_heartbeat_interval_ms: 10000
+    mapping:
+      module:
+        evse: 2
+        connector: 1
+
+# send "{"headers": { "replyTo": "my/reply/topic" } }" to "everest_api/1/entrypoint/api_entrypoint/m2e/discover"
+# and receive an array of (module_id, type, version[optional]) tuples on the reply topic

lib/everest/everest_api_types/include/everest_api_types/entrypoint/API.hpp

@@ -33,12 +33,11 @@ enum class ApiTypeEnum {
 struct ApiParameter {
     ApiTypeEnum type;
     std::string module_id;
-    std::optional<int> version;
+    std::optional<int32_t> version;
 };
 
 struct ApiDiscoverResponse {
     std::vector<ApiParameter> apis;
 };
 
-
 } // namespace everest::lib::API::V1_0::types::entrypoint

lib/everest/everest_api_types/src/everest_api_types/entrypoint/json_codec.cpp

@@ -170,7 +170,7 @@ void to_json(json& j, ApiParameter const& k) noexcept {
 }
 
 void from_json(const json& j, ApiParameter& k) {
-    k.type = j.at("message");
+    k.type = j.at("type");
     k.module_id = j.at("module_id");
     if (j.contains("version")) {
         k.version.emplace(j.at("version"));

modules/API/CMakeLists.txt

@@ -1,5 +1,6 @@
 ev_add_module(API)
 ev_add_module(EvAPI)
+ev_add_module(EVerest_API)
 ev_add_module(RpcApi)
 ev_add_module(auth_consumer_API)
 ev_add_module(auth_token_provider_API)

modules/API/EVerest_API/CMakeLists.txt

@@ -0,0 +1,35 @@
+#
+# AUTO GENERATED - MARKED REGIONS WILL BE KEPT
+# template version 3
+#
+
+# module setup:
+#   - ${MODULE_NAME}: module name
+ev_setup_cpp_module()
+
+# ev@bcc62523-e22b-41d7-ba2f-825b493a3c97:v1
+# insert your custom targets and additional config variables here
+
+target_compile_options(${MODULE_NAME}
+  PUBLIC  -Wall -Wextra -pedantic -Werror=switch)
+
+target_link_libraries(${MODULE_NAME}
+  PRIVATE
+    atomic
+    everest::everest_api_types
+)
+
+install(
+    FILES ${CMAKE_CURRENT_SOURCE_DIR}/apis.yaml
+    DESTINATION "${CMAKE_INSTALL_DATADIR}/everest/modules/${MODULE_NAME}/"
+)
+# ev@bcc62523-e22b-41d7-ba2f-825b493a3c97:v1
+
+target_sources(${MODULE_NAME}
+    PRIVATE
+        "main/generic_errorImpl.cpp"
+)
+
+# ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1
+# insert other things like install cmds etc here
+# ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1

modules/API/EVerest_API/EVerest_API.cpp

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+#include "EVerest_API.hpp"
+
+#include <everest_api_types/entrypoint/codec.hpp>
+#include <everest_api_types/entrypoint/json_codec.hpp>
+#include <everest_api_types/generic/codec.hpp>
+#include <everest_api_types/utilities/codec.hpp>
+#include <utils/yaml_loader.hpp>
+
+#include <map>
+#include <string>
+#include <utility>
+
+namespace {
+
+struct ApiModuleParameter {
+    std::string api_type{};
+    std::optional<int> api_version{};
+};
+
+std::map<std::string, ApiModuleParameter>
+get_all_ApiModuleParameters(Everest::config::ConfigServiceClient* config_service_client,
+                            const std::filesystem::path& api_details_filepath) {
+    std::map<std::string, ApiModuleParameter> api_modules;
+
+    json schema_data;
+    try {
+        schema_data = Everest::load_yaml(api_details_filepath);
+    } catch (const std::exception& err) {
+        EVLOG_error << "Error parsing YAML file at " << api_details_filepath << ": " << err.what();
+        return {};
+    }
+
+    const auto& module_configs = config_service_client->get_module_configs();
+
+    for (const auto& [config, _] : module_configs) {
+        if (schema_data.contains(config.module_type)) {
+            ApiModuleParameter module_parameters;
+            module_parameters.api_type = config.module_type;
+
+            // No mechanism to retreive the version yet
+
+            api_modules.emplace(config.module_id, module_parameters);
+        }
+    }
+
+    return api_modules;
+}
+
+std::string strip_suffix(const std::string& input, const std::string& suffix) {
+    if (input.size() >= suffix.size() && input.substr(input.size() - suffix.size()) == suffix) {
+        return input.substr(0, input.size() - suffix.size());
+    }
+    return input;
+}
+
+API_types_ext::ApiDiscoverResponse
+module_config_to_ApiDiscoverResponse(const std::map<std::string, ApiModuleParameter>& api_modules) {
+    API_types_ext::ApiDiscoverResponse response;
+
+    for (const auto& [name, parameter] : api_modules) {
+        API_types_ext::ApiTypeEnum type_as_enum;
+        json api_type_j = strip_suffix(parameter.api_type, "_API");
+        if (not ev_API::deserialize(api_type_j.dump(), type_as_enum)) {
+            EVLOG_error << "Could not deserialize API type for '" << parameter.api_type << "'";
+        }
+        API_types_ext::ApiParameter api_params;
+        api_params.type = type_as_enum;
+        api_params.module_id = name;
+        api_params.version = parameter.api_version;
+        response.apis.emplace_back(api_params);
+    }
+
+    return response;
+}
+} // namespace
+
+namespace module {
+
+namespace API_generic = API_types::generic;
+using ev_API::deserialize;
+
+void EVerest_API::init() {
+    invoke_init(*p_main);
+
+    topics.setup(info.id, "entrypoint", 1);
+}
+
+void EVerest_API::ready() {
+    invoke_ready(*p_main);
+
+    auto config_service_client = get_config_service_client();
+
+    const auto apis_details_path = info.paths.share / "apis.yaml";
+
+    auto api_modules = get_all_ApiModuleParameters(config_service_client.get(), apis_details_path);
+
+    api_discovery_response = module_config_to_ApiDiscoverResponse(api_modules);
+
+    generate_api_cmd_discover();
+
+    // Not calling start on comm_check - we only use the heartbeat functionality here
+    setup_heartbeat_generator();
+}
+
+void EVerest_API::generate_api_cmd_discover() {
+    subscribe_api_topic("discover", [this](std::string const& data) {
+        API_generic::RequestReply msg;
+        if (deserialize(data, msg)) {
+            mqtt.publish(msg.replyTo, API_types_ext::serialize(api_discovery_response));
+            return true;
+        }
+        return false;
+    });
+}
+
+void EVerest_API::subscribe_api_topic(std::string const& var, ParseAndPublishFtor const& parse_and_publish) {
+    auto topic = topics.extern_to_everest(var);
+    mqtt.subscribe(topic, [=](std::string const& data) {
+        try {
+            if (not parse_and_publish(data)) {
+                EVLOG_warning << "Invalid data: Deserialization failed.\n" << topic << "\n" << data;
+            }
+        } catch (const std::exception& e) {
+            EVLOG_warning << "Topic: '" << topic << "' failed with -> " << e.what() << "\n => " << data;
+        } catch (...) {
+            EVLOG_warning << "Invalid data: Failed to parse JSON or to get data from it.\n" << topic;
+        }
+    });
+}
+
+void EVerest_API::setup_heartbeat_generator() {
+    auto topic = topics.everest_to_extern("heartbeat");
+    auto action = [this, topic]() {
+        mqtt.publish(topic, API_generic::serialize(hb_id++));
+        return true;
+    };
+    comm_check.heartbeat(config.cfg_heartbeat_interval_ms, action);
+}
+
+} // namespace module

modules/API/EVerest_API/EVerest_API.hpp

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+#ifndef EVEREST_API_HPP
+#define EVEREST_API_HPP
+
+//
+// AUTO GENERATED - MARKED REGIONS WILL BE KEPT
+// template version 2
+//
+
+#include "ld-ev.hpp"
+
+// headers for provided interface implementations
+#include <generated/interfaces/generic_error/Implementation.hpp>
+
+// headers for required interface implementations
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#include <generated/interfaces/generic_error/Implementation.hpp>
+#pragma GCC diagnostic pop
+
+// ev@4bf81b14-a215-475c-a1d3-0a484ae48918:v1
+// insert your custom include headers here
+#include <everest_api_types/entrypoint/API.hpp>
+#include <everest_api_types/utilities/CommCheckHandler.hpp>
+#include <everest_api_types/utilities/Topics.hpp>
+
+namespace ev_API = everest::lib::API;
+namespace API_types = ev_API::V1_0::types;
+namespace API_types_ext = API_types::entrypoint;
+// ev@4bf81b14-a215-475c-a1d3-0a484ae48918:v1
+
+namespace module {
+
+struct Conf {
+    int cfg_communication_check_to_s;
+    int cfg_heartbeat_interval_ms;
+};
+
+class EVerest_API : public Everest::ModuleBase {
+public:
+    EVerest_API() = delete;
+    EVerest_API(const ModuleInfo& info, Everest::MqttProvider& mqtt_provider,
+                std::unique_ptr<generic_errorImplBase> p_main, Conf& config) :
+        ModuleBase(info),
+        mqtt(mqtt_provider),
+        p_main(std::move(p_main)),
+        config(config),
+        comm_check("generic/CommunicationFault", "Bridge to implementation connection lost", this->p_main){};
+
+    Everest::MqttProvider& mqtt;
+    const std::shared_ptr<generic_errorImplBase> p_main;
+    const Conf& config;
+
+    // ev@1fce4c5e-0ab8-41bb-90f7-14277703d2ac:v1
+    // insert your public definitions here
+    // ev@1fce4c5e-0ab8-41bb-90f7-14277703d2ac:v1
+
+protected:
+    // ev@4714b2ab-a24f-4b95-ab81-36439e1478de:v1
+    // insert your protected definitions here
+    // ev@4714b2ab-a24f-4b95-ab81-36439e1478de:v1
+
+private:
+    friend class LdEverest;
+    void init();
+    void ready();
+
+    // ev@211cfdbe-f69a-4cd6-a4ec-f8aaa3d1b6c8:v1
+    // insert your private definitions here
+    using ParseAndPublishFtor = std::function<bool(std::string const&)>;
+    void subscribe_api_topic(std::string const& var, ParseAndPublishFtor const& parse_and_publish);
+
+    void generate_api_cmd_discover();
+
+    void setup_heartbeat_generator();
+
+    ev_API::Topics topics;
+    ev_API::CommCheckHandler<generic_errorImplBase> comm_check;
+    size_t hb_id{0};
+
+    API_types_ext::ApiDiscoverResponse api_discovery_response;
+    // ev@211cfdbe-f69a-4cd6-a4ec-f8aaa3d1b6c8:v1
+};
+
+// ev@087e516b-124c-48df-94fb-109508c7cda9:v1
+// insert other definitions here
+// ev@087e516b-124c-48df-94fb-109508c7cda9:v1
+
+} // namespace module
+
+#endif // EVEREST_API_HPP