PluginLoader.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPLv3-or-later
//
// SPDX-FileCopyrightText: Louis Moureaux <louis.moureaux@cern.ch>
// SPDX-FileCopyrightText: Patrick L.S. Connor <patrick.connor@cern.ch>
 
#pragma once
 
// STD
#include <algorithm>
#include <dlfcn.h>
#include <filesystem>
#include <iostream>
#include <memory>
#include <ranges>
#include <string>
#include <type_traits>
#include <vector>
 
// BOOST
#include <boost/exception/all.hpp>
 
// Darwin
#include "IPlugin.h"
#include "Options.h"
#include "colours.h"
#include "exceptions.h"
 
namespace Darwin::Tools {
 
class PluginLoader {
 
    std::filesystem::path file; 
    std::vector<std::unique_ptr<IPlugin>> plugins; 
    void * handle; 
    int steering; 
 
public:
 
    PluginLoader (const std::filesystem::path& file, 
                  int steering = none
                 )
    try : file(file)
        , handle(nullptr)
        , steering(steering)
    {
        using namespace std;
 
        if (steering & verbose)
            cout << "PluginLoader: Loading plugin from " << file << endl;
 
        handle = dlopen(file.c_str(), RTLD_LAZY);
        if (!handle) {
            string what = file.string() + " could not be loaded"s;
            const char * error = dlerror();
            if (error != nullptr)
                what += ": "s + error;
            BOOST_THROW_EXCEPTION( invalid_argument(what) );
        }
 
        typedef vector<unique_ptr<IPlugin>> * create_t();
        auto CreatePlugin = (create_t *) dlsym(handle, "CreatePlugin");
        if (!CreatePlugin) {
            string what = "`CreatePlugin` could not be found"s;
            const char * error = dlerror();
            if (error != nullptr)
                what += ": "s + error;
            BOOST_THROW_EXCEPTION( runtime_error(what) );
        }
        vector<unique_ptr<IPlugin>> * iplugins = CreatePlugin();
        if (iplugins == nullptr)
            BOOST_THROW_EXCEPTION( runtime_error("`CreatePlugin` returns a nullptr") );
        plugins = std::move(*iplugins);
        ranges::for_each(plugins, [file](unique_ptr<IPlugin>& p) { p->SetPath(file); });
    }
    catch (boost::exception& e) {
        namespace DE = Darwin::Exceptions;
        BOOST_THROW_EXCEPTION( DE::PluginException(file, e) );
    }
 
    PluginLoader (PluginLoader&& other)
        : file(other.file)
        , plugins(std::move(other.plugins))
        , handle(std::move(other.handle))
    {
        using namespace std;
 
        if (steering & verbose)
            cout << "PluginLoader: Moving plugin from " << file << endl;
 
        other.file.clear();
        other.plugins.clear();
        other.handle = nullptr;
    }
 
    ~PluginLoader () noexcept
    {
        using namespace std;
 
        if (steering & verbose)
            cout << "PluginLoader: Closing plugin from " << file << endl;
 
        plugins.clear(); // Delete plugins _before_ closing the handle.
 
        if (!handle) return;
        int code = dlclose(handle);
        if (code != 0)
            cerr << orange << "The plugin(s) loaded from " << file
                 << " closed with error " << code << def << '\n';
    }
 
    std::filesystem::path Which () const { return file; }
 
    template<Plugin P> auto Get () const
    {
        using namespace std;
        auto convert = [this](IPlugin * plugin) -> P * {
            auto ptr = dynamic_cast<P*>(plugin);
            if (ptr == nullptr) {
                string what = "Invalid plugin type for ";
                what += file;
                BOOST_THROW_EXCEPTION( logic_error(what) );
            }
            return ptr;
        };
        return plugins | views::transform(&unique_ptr<IPlugin>::get)
                       | views::transform(convert);
    }
};
 
} // end of Darwin::Tools namespace