Plugin.h

Go to the documentation of this file.

 
#pragma once
 
#include "plugin_manager/PluginManifest.h"
#include "plugin_manager/Raii.h"
 
#include <cstddef>
#include <cstdint>
#include <initializer_list>
#include <memory>
#include <set>
#include <string>
#include <vector>
 
// Forward-declare WAMR types here so consumers of this header don't pull in
// wasm_export.h (which clashes with cdc_log's log_level_t).
struct WASMModuleCommon;
struct WASMModuleInstanceCommon;
struct WASMExecEnv;
 
namespace cdc::plugin_manager {
 
struct WasmModuleDeleter {
    void operator()(WASMModuleCommon* m) const noexcept;
};
struct WasmInstanceDeleter {
    void operator()(WASMModuleInstanceCommon* m) const noexcept;
};
struct WasmExecEnvDeleter {
    void operator()(WASMExecEnv* e) const noexcept;
};
 
using WasmModulePtr   = std::unique_ptr<WASMModuleCommon, WasmModuleDeleter>;
using WasmInstancePtr = std::unique_ptr<WASMModuleInstanceCommon, WasmInstanceDeleter>;
using WasmExecEnvPtr  = std::unique_ptr<WASMExecEnv, WasmExecEnvDeleter>;
 
class Plugin {
public:
    Plugin() noexcept;
    ~Plugin();
 
    Plugin(const Plugin&)            = delete;
    Plugin& operator=(const Plugin&) = delete;
    Plugin(Plugin&&) noexcept            = default;
    Plugin& operator=(Plugin&&) noexcept = default;

    [[nodiscard]] bool load(const std::string& id, const PluginManifest& manifest);

    void unload() noexcept;

    [[nodiscard]] bool callI(const char* name,
                             std::initializer_list<int32_t> args = {},
                             int32_t* out_i32 = nullptr);
 
    [[nodiscard]] bool hasExport(const char* name) const;

    [[nodiscard]] bool lastCallTrapped() const noexcept { return last_call_trapped_; }

    [[nodiscard]] const char* lastTrapMessage() const noexcept { return last_trap_; }
 
    [[nodiscard]] const PluginManifest& manifest() const noexcept { return manifest_; }
    [[nodiscard]] const std::string&    id()       const noexcept { return id_; }
    [[nodiscard]] bool                  isLoaded() const noexcept
    {
        return module_inst_ != nullptr;
    }

    bool loadLangOverlay(const char* path = nullptr);

    [[nodiscard]] const char* trKey(const char* key) const noexcept;
 
    // Resources acquired during prerequisite setup; released in reverse order
    // by PluginManager on exit. Stored as opaque prerequisite names for now.
    std::vector<std::string> acquired_prereqs;
 
private:
    struct OverlayEntry {
        std::string key;
        std::string value;
    };
 
    std::string             id_;
    PluginManifest          manifest_;
    PsramUniquePtr<uint8_t> bytecode_;
    std::size_t             bytecode_len_ = 0;
    WasmModulePtr           module_;
    WasmInstancePtr         module_inst_;
    WasmExecEnvPtr          exec_env_;
 
    // Per-plugin translation overlay, sorted by key. Loaded from `<id>.lang`.
    // Active language only; reload on language switch.
    std::vector<OverlayEntry> langOverlay_;
    std::string               langOverlayLang_;
 
    std::set<std::string>     missingExports_;
 
    bool last_call_trapped_ = false;
    char last_trap_[160]    = {0};
};
 
}  // namespace cdc::plugin_manager