plugin_loader.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <memory>
#include <mutex>
#include <string>
#include <string_view>
#include <unordered_map>
 
#include "collector_plugin.h"
#include "plugin_api.h"
 
namespace kcenon {
namespace monitoring {
 
enum class plugin_load_error {
    none = 0,
    file_not_found,
    library_load_failed,
    symbol_not_found,
    incompatible_api_version,
    create_function_failed,
    plugin_unavailable,
    already_loaded,
    not_loaded,
    invalid_metadata
};
 
auto to_string(plugin_load_error error) -> std::string;
 
class plugin_loader {
public:
    virtual ~plugin_loader() = default;
 
    virtual auto load_plugin(std::string_view path)
        -> std::unique_ptr<collector_plugin> = 0;
 
    virtual auto unload_plugin(std::string_view plugin_name) -> bool = 0;
 
    virtual auto get_last_error() const -> plugin_load_error = 0;
 
    virtual auto get_last_error_message() const -> std::string = 0;
 
    virtual auto is_plugin_loaded(std::string_view plugin_name) const -> bool = 0;
 
    virtual auto get_loaded_plugins() const -> std::vector<std::string> = 0;
};
 
class dynamic_plugin_loader : public plugin_loader {
public:
    dynamic_plugin_loader();
    ~dynamic_plugin_loader() override;
 
    // Disable copy
    dynamic_plugin_loader(const dynamic_plugin_loader&) = delete;
    dynamic_plugin_loader& operator=(const dynamic_plugin_loader&) = delete;
 
    // Enable move
    dynamic_plugin_loader(dynamic_plugin_loader&&) noexcept;
    dynamic_plugin_loader& operator=(dynamic_plugin_loader&&) noexcept;
 
    auto load_plugin(std::string_view path)
        -> std::unique_ptr<collector_plugin> override;
 
    auto unload_plugin(std::string_view plugin_name) -> bool override;
 
    auto get_last_error() const -> plugin_load_error override;
    auto get_last_error_message() const -> std::string override;
    auto is_plugin_loaded(std::string_view plugin_name) const -> bool override;
    auto get_loaded_plugins() const -> std::vector<std::string> override;
 
private:
    struct library_handle;
 
    struct plugin_entry {
        std::string name;
        std::string path;
        std::unique_ptr<library_handle> handle;
        destroy_plugin_fn destroy_fn;
        plugin_api_metadata metadata;
    };
 
    auto load_library(std::string_view path) -> std::unique_ptr<library_handle>;
 
    void unload_library(std::unique_ptr<library_handle> handle);
 
    template <typename T>
    auto resolve_symbol(library_handle* handle, const char* symbol_name) -> T;
 
    auto verify_api_version(const plugin_api_metadata& metadata) const -> bool;
 
    void set_error(plugin_load_error error, std::string message);
 
    // Loaded plugins tracking
    std::unordered_map<std::string, plugin_entry> loaded_plugins_;
 
    // Error state
    plugin_load_error last_error_{plugin_load_error::none};
    std::string last_error_message_;
 
    // Thread safety
    mutable std::mutex mutex_;
};
 
} // namespace monitoring
} // namespace kcenon