plugin_server.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/interfaces/i_mcp_server.h>
 
#include <filesystem>
#include <memory>
#include <mutex>
#include <string>
 
namespace entropic {
 
class PluginServer {
public:
    static entropic_error_t load(const std::filesystem::path& path,
                                 std::unique_ptr<PluginServer>& out);
 
    ~PluginServer();
 
    PluginServer(const PluginServer&) = delete;
    PluginServer& operator=(const PluginServer&) = delete;
    PluginServer(PluginServer&&) = delete;
    PluginServer& operator=(PluginServer&&) = delete;
 
    const std::string& name() const { return name_; }
 
    const std::filesystem::path& path() const { return path_; }
 
    std::string list_tools() const;
 
    std::string execute(const std::string& tool_name,
                        const std::string& args_json);
 
    entropic_error_t configure(const std::string& config_json);
 
    entropic_error_t set_working_dir(const std::string& dir);
 
private:
    /* Signatures of the plugin-side entry points (see i_mcp_server.h). */
    using version_fn_t = int (*)();
    using create_fn_t = entropic_mcp_server_t (*)();
    using name_fn_t = const char* (*)(entropic_mcp_server_t);
    using list_tools_fn_t = char* (*)(entropic_mcp_server_t);
    using execute_fn_t = char* (*)(entropic_mcp_server_t, const char*,
                                   const char*);
    using configure_fn_t = entropic_error_t (*)(entropic_mcp_server_t,
                                                const char*);
    using set_dir_fn_t = entropic_error_t (*)(entropic_mcp_server_t,
                                              const char*);
    using destroy_fn_t = void (*)(entropic_mcp_server_t);
    using free_fn_t = void (*)(void*);
 
    PluginServer(void* handle, std::filesystem::path path);
 
    entropic_error_t resolve_and_init();
 
    entropic_error_t resolve_and_check_version();
 
    entropic_error_t create_instance();
 
    bool resolve_symbols();
 
    void* resolve_one(const char* symbol_name, bool& ok) const;
 
    bool resolve_factory_symbols();
 
    bool resolve_instance_symbols();
 
    std::string take_string(char* raw) const;
 
    void* handle_{nullptr};                  
    std::filesystem::path path_;             
    std::string name_;                       
    entropic_mcp_server_t instance_{nullptr};
 
    version_fn_t version_fn_{nullptr};       
    create_fn_t create_fn_{nullptr};         
    name_fn_t name_fn_{nullptr};             
    list_tools_fn_t list_tools_fn_{nullptr}; 
    execute_fn_t execute_fn_{nullptr};       
    configure_fn_t configure_fn_{nullptr};   
    set_dir_fn_t set_dir_fn_{nullptr};       
    destroy_fn_t destroy_fn_{nullptr};       
    free_fn_t free_fn_{nullptr};             
 
    mutable std::mutex call_mutex_;
};
 
} // namespace entropic