Add extracted tools: CitrineOS, OpenOCPP, ShapeShifter

- CitrineOS core extracted (CSMS OCPP 2.0.1)
- OpenOCPP extracted (firmware OCPP 1.6J/2.0.1)
- ShapeShifter library installed (pip install -e)
- ShapeShifter specification extracted
- EVerest extracted

TODO updated with progress

tools/EVerest-main/modules/Misc/PersistentStore/BUILD.bazel

@@ -0,0 +1,9 @@
+load("//modules:module.bzl", "cc_everest_module")
+
+cc_everest_module(
+    name = "PersistentStore",
+    impls = ["main"],
+    deps = [
+        "@sqlite3",
+    ],
+)

tools/EVerest-main/modules/Misc/PersistentStore/CMakeLists.txt

@@ -0,0 +1,27 @@
+#
+# 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
+find_package(SQLite3 REQUIRED)
+
+target_link_libraries(${MODULE_NAME}
+    PRIVATE
+        SQLite::SQLite3
+)
+# ev@bcc62523-e22b-41d7-ba2f-825b493a3c97:v1
+
+target_sources(${MODULE_NAME}
+    PRIVATE
+        "main/kvsImpl.cpp"
+)
+
+# ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1
+# insert other things like install cmds etc here
+# ev@c55432ab-152c-45a9-9d2e-7281d50c69c3:v1

tools/EVerest-main/modules/Misc/PersistentStore/PersistentStore.cpp

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2022 - 2022 Pionix GmbH and Contributors to EVerest
+#include "PersistentStore.hpp"
+
+namespace module {
+
+void PersistentStore::init() {
+    invoke_init(*p_main);
+}
+
+void PersistentStore::ready() {
+    invoke_ready(*p_main);
+}
+
+} // namespace module

tools/EVerest-main/modules/Misc/PersistentStore/PersistentStore.hpp

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+#ifndef PERSISTENT_STORE_HPP
+#define PERSISTENT_STORE_HPP
+
+//
+// AUTO GENERATED - MARKED REGIONS WILL BE KEPT
+// template version 2
+//
+
+#include "ld-ev.hpp"
+
+// headers for provided interface implementations
+#include <generated/interfaces/kvs/Implementation.hpp>
+
+// ev@4bf81b14-a215-475c-a1d3-0a484ae48918:v1
+// insert your custom include headers here
+// ev@4bf81b14-a215-475c-a1d3-0a484ae48918:v1
+
+namespace module {
+
+struct Conf {
+    std::string sqlite_db_file_path;
+};
+
+class PersistentStore : public Everest::ModuleBase {
+public:
+    PersistentStore() = delete;
+    PersistentStore(const ModuleInfo& info, std::unique_ptr<kvsImplBase> p_main, Conf& config) :
+        ModuleBase(info), p_main(std::move(p_main)), config(config){};
+
+    const std::unique_ptr<kvsImplBase> 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
+    // 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 // PERSISTENT_STORE_HPP

tools/EVerest-main/modules/Misc/PersistentStore/main/kvsImpl.cpp

@@ -0,0 +1,258 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2022 - 2022 Pionix GmbH and Contributors to EVerest
+
+#include "kvsImpl.hpp"
+
+#include <filesystem>
+
+namespace fs = std::filesystem;
+
+namespace module {
+namespace main {
+
+/**
+ * Wrapper class around a sqlite3_stmt pointer to ensure it is always
+ * finalised via sqlite3_finalize()
+ */
+class Sqlite3_Stmt {
+private:
+    sqlite3_stmt* m_statement_ptr = nullptr;
+
+public:
+    void finalize(const char* error_message = nullptr) {
+        const auto res = sqlite3_finalize(m_statement_ptr);
+        m_statement_ptr = nullptr; // prevent double free
+        if (res != SQLITE_OK) {
+            if (error_message != nullptr) {
+                EVLOG_error << error_message;
+            }
+            throw std::runtime_error("PersistentStore db access error");
+        }
+    }
+
+    ~Sqlite3_Stmt() {
+        (void)sqlite3_finalize(m_statement_ptr);
+    }
+
+    constexpr operator sqlite3_stmt*() {
+        return m_statement_ptr;
+    }
+
+    constexpr operator sqlite3_stmt**() {
+        return &m_statement_ptr;
+    }
+
+    constexpr sqlite3_stmt** operator&() {
+        return &m_statement_ptr;
+    }
+};
+
+void kvsImpl::init() {
+    // open and initialize database
+    fs::path sqlite_db_path = fs::absolute(fs::path(mod->config.sqlite_db_file_path));
+    fs::path database_directory = sqlite_db_path.parent_path();
+    if (!fs::exists(database_directory)) {
+        fs::create_directories(database_directory);
+    }
+
+    int ret = sqlite3_open(sqlite_db_path.c_str(), &this->db);
+
+    if (ret != SQLITE_OK) {
+        EVLOG_error << "Error opening PersistentStore database '" << sqlite_db_path << "': " << sqlite3_errmsg(db);
+        throw std::runtime_error("Could not open PersistentStore database at provided path.");
+    }
+
+    EVLOG_debug << "Using SQLite version " << sqlite3_libversion();
+
+    // prepare the database
+    std::string create_sql = "CREATE TABLE IF NOT EXISTS KVS ("
+                             "KEY   TEXT UNIQUE,"
+                             "VALUE TEXT,"
+                             "TYPE  TEXT);";
+
+    Sqlite3_Stmt create_statement;
+    sqlite3_prepare_v2(this->db, create_sql.c_str(), create_sql.size(), &create_statement, NULL);
+    int res = sqlite3_step(create_statement);
+    if (res != SQLITE_DONE) {
+        EVLOG_error << "Could not create KVS table: " << res << sqlite3_errmsg(this->db);
+        throw std::runtime_error("PersistentStore db access error");
+    }
+
+    create_statement.finalize("Error creating KVS table");
+}
+
+void kvsImpl::ready() {
+}
+
+class TypeNameVisitor {
+public:
+    std::string operator()(std::nullptr_t t) const {
+        return "nullptr_t";
+    }
+
+    std::string operator()(const Array& t) const {
+        return "Array";
+    }
+
+    std::string operator()(const Object& t) const {
+        return "Object";
+    }
+
+    std::string operator()(const bool& t) const {
+        return "bool";
+    }
+
+    std::string operator()(const double& t) const {
+        return "double";
+    }
+
+    std::string operator()(const int& t) const {
+        return "int";
+    }
+
+    std::string operator()(const std::string& t) const {
+        return "std::string";
+    }
+};
+
+class StringValueVisitor {
+public:
+    std::string operator()(std::nullptr_t t) const {
+        return "";
+    }
+
+    std::string operator()(Array t) const {
+        json a = t;
+        return a.dump();
+    }
+
+    std::string operator()(Object t) const {
+        json o = t;
+        return o.dump();
+    }
+
+    std::string operator()(bool t) const {
+        if (t) {
+            return "true";
+        }
+        return "false";
+    }
+
+    std::string operator()(double t) const {
+        return std::to_string(t);
+    }
+
+    std::string operator()(int t) const {
+        return std::to_string(t);
+    }
+
+    std::string operator()(std::string t) const {
+        return t;
+    }
+};
+
+void kvsImpl::handle_store(std::string& key,
+                           std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string>& value) {
+    std::string type = std::visit(TypeNameVisitor(), value);
+    std::string string_value = std::visit(StringValueVisitor(), value);
+    ;
+
+    std::string insert_sql_str = "INSERT OR REPLACE INTO KVS (KEY, VALUE, TYPE) VALUES "
+                                 "(@key, @value, @type)";
+    Sqlite3_Stmt insert_statement;
+    sqlite3_prepare_v2(db, insert_sql_str.c_str(), insert_sql_str.size(), &insert_statement, NULL);
+
+    sqlite3_bind_text(insert_statement, 1, key.c_str(), -1, NULL);
+    sqlite3_bind_text(insert_statement, 2, string_value.c_str(), -1, NULL);
+    sqlite3_bind_text(insert_statement, 3, type.c_str(), -1, NULL);
+
+    int res = sqlite3_step(insert_statement);
+    if (res != SQLITE_DONE) {
+        EVLOG_error << "Could not insert into KVS table: " << res << sqlite3_errmsg(db);
+        throw std::runtime_error("PersistentStore db access error");
+    }
+
+    insert_statement.finalize("Error inserting into KVS table");
+};
+
+std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string> kvsImpl::handle_load(std::string& key) {
+    std::string select_sql_str = "SELECT KEY, VALUE, TYPE FROM KVS WHERE KEY = @key";
+    Sqlite3_Stmt select_statement;
+    sqlite3_prepare_v2(db, select_sql_str.c_str(), select_sql_str.size(), &select_statement, NULL);
+
+    sqlite3_bind_text(select_statement, 1, key.c_str(), -1, NULL);
+
+    int res = sqlite3_step(select_statement);
+    if (res != SQLITE_ROW) {
+        // no key with that name exists in the database
+        return {};
+    }
+
+    std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string> value;
+
+    auto value_ptr = sqlite3_column_text(select_statement, 1);
+    if (value_ptr != nullptr) {
+        std::string value_str = std::string(reinterpret_cast<const char*>(value_ptr));
+        auto type_ptr = sqlite3_column_text(select_statement, 2);
+        if (type_ptr != nullptr) {
+            std::string type_str = std::string(reinterpret_cast<const char*>(type_ptr));
+            if (type_str == "Array") {
+                Array value_array = json::parse(value_str);
+                value = value_array;
+            } else if (type_str == "Object") {
+                Object value_object = json::parse(value_str);
+                value = value_object;
+            } else if (type_str == "bool") {
+                if (value_str == "true") {
+                    value = true;
+                } else {
+                    value = false;
+                }
+            } else if (type_str == "double") {
+                value = std::stod(value_str);
+            } else if (type_str == "int") {
+                value = std::stoi(value_str);
+            } else if (type_str == "std::string") {
+                value = value_str;
+            }
+        }
+    }
+
+    select_statement.finalize("Error selecting from KVS table");
+    return value;
+};
+
+void kvsImpl::handle_delete(std::string& key) {
+    std::string delete_sql_str = "DELETE FROM KVS WHERE KEY = @key";
+    Sqlite3_Stmt delete_statement;
+    sqlite3_prepare_v2(db, delete_sql_str.c_str(), delete_sql_str.size(), &delete_statement, NULL);
+
+    sqlite3_bind_text(delete_statement, 1, key.c_str(), -1, NULL);
+
+    int res = sqlite3_step(delete_statement);
+    if (res != SQLITE_DONE) {
+        EVLOG_error << "Could not delete from KVS table: " << res << sqlite3_errmsg(db);
+        throw std::runtime_error("PersistentStore db access error");
+    }
+
+    delete_statement.finalize("Error deleting from KVS table");
+};
+
+bool kvsImpl::handle_exists(std::string& key) {
+    std::string select_sql_str = "SELECT KEY FROM KVS WHERE KEY = @key";
+    Sqlite3_Stmt select_statement;
+    sqlite3_prepare_v2(db, select_sql_str.c_str(), select_sql_str.size(), &select_statement, NULL);
+
+    sqlite3_bind_text(select_statement, 1, key.c_str(), -1, NULL);
+
+    int res = sqlite3_step(select_statement);
+    if (res != SQLITE_ROW) {
+        // no key with that name exists in the database
+        return false;
+    }
+
+    return true;
+};
+
+} // namespace main
+} // namespace module

tools/EVerest-main/modules/Misc/PersistentStore/main/kvsImpl.hpp

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+#ifndef MAIN_KVS_IMPL_HPP
+#define MAIN_KVS_IMPL_HPP
+
+//
+// AUTO GENERATED - MARKED REGIONS WILL BE KEPT
+// template version 3
+//
+
+#include <generated/interfaces/kvs/Implementation.hpp>
+
+#include "../PersistentStore.hpp"
+
+// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
+// insert your custom include headers here
+#include <mutex>
+#include <sqlite3.h>
+// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
+
+namespace module {
+namespace main {
+
+struct Conf {};
+
+class kvsImpl : public kvsImplBase {
+public:
+    kvsImpl() = delete;
+    kvsImpl(Everest::ModuleAdapter* ev, const Everest::PtrContainer<PersistentStore>& mod, Conf& config) :
+        kvsImplBase(ev, "main"), mod(mod), config(config){};
+
+    // ev@8ea32d28-373f-4c90-ae5e-b4fcc74e2a61:v1
+    // insert your public definitions here
+    // ev@8ea32d28-373f-4c90-ae5e-b4fcc74e2a61:v1
+
+protected:
+    // command handler functions (virtual)
+    virtual void
+    handle_store(std::string& key,
+                 std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string>& value) override;
+    virtual std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string>
+    handle_load(std::string& key) override;
+    virtual void handle_delete(std::string& key) override;
+    virtual bool handle_exists(std::string& key) override;
+
+    // ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1
+    // insert your protected definitions here
+    // ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1
+
+private:
+    const Everest::PtrContainer<PersistentStore>& mod;
+    const Conf& config;
+
+    virtual void init() override;
+    virtual void ready() override;
+
+    // ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
+    // insert your private definitions here
+    sqlite3* db;
+    std::mutex db_mutex;
+    // ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
+};
+
+// ev@3d7da0ad-02c2-493d-9920-0bbbd56b9876:v1
+// insert other definitions here
+// ev@3d7da0ad-02c2-493d-9920-0bbbd56b9876:v1
+
+} // namespace main
+} // namespace module
+
+#endif // MAIN_KVS_IMPL_HPP

tools/EVerest-main/modules/Misc/PersistentStore/manifest.yaml

@@ -0,0 +1,14 @@
+description: Simple implementation of a SQLite backed persistent key-value store
+config:
+  sqlite_db_file_path:
+    description: Path to the SQLite db file.
+    type: string
+    default: everest_persistent_store.db
+provides:
+  main:
+    interface: kvs
+    description: This implements a persistent key-value store
+metadata:
+  license: https://opensource.org/licenses/Apache-2.0
+  authors:
+    - Kai-Uwe Hermann