file src/plugin_loader.cpp

[No description available] More…

Namespaces

Name
Gambit
TODO: see if we can use this one:
Gambit::Scanner
Gambit::Scanner::Plugins

Detailed Description

Loader singleton class for scanner plugins


Authors (add name and date if you modify):

Source code

//  GAMBIT: Global and Modular BSM Inference Tool
//  *********************************************
///  \file
///
///  Loader singleton class for scanner plugins
///
///  *********************************************
///
///  Authors (add name and date if you modify):
//
///  \author Gregory Martinez
///          (gregory.david.martinez@gmail.com)
///  \date 2013 August
///  \date 2014 Feb
///
///  \author Pat Scott
///          (p.scott@imperial.ac.uk)
///  \date 2014 Dec
///  \date 2017 Jun
///
///  \author Ben Farmer
///          (benjamin.farmer@fysik.su.se)
///  \date 2016 Aug
///
///  *********************************************

#include <cstdlib>
#include <iomanip>
#include <unistd.h>
#include <iostream>
#include <fstream>
#include <stdio.h>

#include "gambit/ScannerBit/scanner_utils.hpp"
#include "gambit/ScannerBit/plugin_comparators.hpp"
#include "gambit/ScannerBit/plugin_loader.hpp"
#include "gambit/cmake/cmake_variables.hpp"
#include "gambit/Utils/table_formatter.hpp"
#include "gambit/Utils/screen_print_utils.hpp"
#include "gambit/Utils/mpiwrapper.hpp"
#include "gambit/Utils/util_functions.hpp"
#include "gambit/ScannerBit/priors_rollcall.hpp"

#ifdef HAVE_PYBIND11
  #include "gambit/Utils/begin_ignore_warnings_pybind11.hpp"
  #include <pybind11/embed.h>
  #include "gambit/Utils/end_ignore_warnings.hpp"

  namespace py = pybind11;
#endif

namespace Gambit
{

    namespace Scanner
    {

        namespace Plugins
        {

            /*********************************************/
            /************** PYTHON STUFF *****************/
            /*********************************************/

        #ifdef HAVE_PYBIND11
            void pluginInfo::load_python_plugins()
            {
                plugins.Load_PyPlugins();
            }

            std::string PyPlugin_Details::print() const
            {
                std::stringstream out;
                out << "\n\x1b[01m\x1b[04mGENERAL PLUGIN INFO\x1b[0m" << std::endl;
                out << "\nname:     " << plugin_name;
                out << "\ntype:     python " << type;
                out << "\nversion:  " << version;
                out << "\npackage:  " << package;
                out << "\nstatus:   ";
                if (status == "ok")
                    out << "\x1b[32;01m" << status << "\x1b[0m";
                else
                    out << "\x1b[31;01m" << status << "\x1b[0m";

                out << "\nlocation: " << loc << std::endl;
                if (error != "")
                    out << "\x1b[31;01m" << "error output: " << "\x1b[0m" << error << std::endl;

                out << std::endl;

                out << "\n\x1b[01m\x1b[04mDESCRIPTION\x1b[0m\n" << std::endl;
                out << class_doc << std::endl << std::endl;

                if (init_doc != "")
                {
                    out << "\n\x1b[01m\x1b[04mINIT DESCRIPTION\x1b[0m\n" << std::endl;
                    out << init_doc << std::endl << std::endl;
                }

                if (run_doc != "")
                {
                    out << "\n\x1b[01m\x1b[04mRUN DESCRIPTION\x1b[0m\n" << std::endl;
                    out << run_doc << std::endl << std::endl;
                }

                return out.str();
            }

            void Plugin_Loader::Load_PyPlugins()
            {
                if (python_plugin_map.size() == 0)
                {
                    std::vector<std::string> types = {"objective", "scanner"};
                    for (auto &&type : types)
                        Load_PyPlugins(type);
                }
            }

            void Plugin_Loader::Load_PyPlugins(const std::string &type)
            {
                py::scoped_interpreter *guard;
                try
                {
                    guard = new py::scoped_interpreter();
                }
                catch(std::exception &)
                {
                    guard = nullptr;
                }
                {
                    std::string path = std::string(GAMBIT_DIR "/ScannerBit/src/") + type + "s/python/plugins";
                    auto sys_list = py::list(py::module::import("sys").attr("path"));
                    sys_list.append(py::cast(path));

                    if (FILE* p_f = popen((std::string("ls ") + path).c_str(), "r"))
                    {
                        char path_buffer[1024];
                        int p_n;
                        std::string fname;
                        std::stringstream ss;

                        while ((p_n = fread(path_buffer, 1, sizeof path_buffer, p_f)) > 0)
                        {
                            ss << std::string(path_buffer, p_n);
                        }
                        while (ss >> fname)
                        {
                            std::string loc = path + "/" + fname;
                            if (fname.substr(fname.size() - 3) == ".py")
                                fname = fname.substr(0, fname.size() - 3);
                            else if (fname.substr(fname.size() - 4) == ".pyc")
                                fname = fname.substr(0, fname.size() - 4);
                            try
                            {
                                auto file = py::module::import(fname.c_str());
                                if (py::hasattr(file, "__plugins__") && py::isinstance<py::dict>(file.attr("__plugins__")))
                                {
                                    py::dict plugins = file.attr("__plugins__");
                                    for (auto &&plug : plugins)
                                    {

                                        std::string plug_name = plug.first.cast<std::string>();
                                        py::handle plug_class = plug.second;
                                        if (python_plugin_map[type].find(plug_name) == python_plugin_map[type].end())
                                        {
                                            PyPlugin_Details detail;
                                            detail.plugin_name = plug_name;
                                            detail.package = fname;
                                            detail.type = type;
                                            detail.loc = path;

                                            try
                                            {
                                                if (py::hasattr(plug_class, "run") && py::isinstance<py::function>(plug_class.attr("run")))
                                                {
                                                    auto run = plug_class.attr("run");
                                                    if (py::hasattr(run, "__doc__") && py::isinstance<py::str>(run.attr("__doc__")))
                                                    {
                                                        detail.run_doc = run.attr("__doc__").cast<std::string>();
                                                    }
                                                }
                                                else
                                                {
                                                    detail.status = "\"run\" not defined";
                                                }

                                                if (py::hasattr(plug_class, "__init__") && py::isinstance<py::function>(plug_class.attr("__init__")))
                                                {
                                                    auto init = plug_class.attr("__init__");
                                                    if (py::hasattr(init, "__doc__")&& py::isinstance<py::str>(init.attr("__doc__")))
                                                    {
                                                        detail.init_doc = init.attr("__doc__").cast<std::string>();
                                                    }
                                                }
                                                else
                                                {
                                                    detail.status = "\"__init__\" not defined";
                                                }

                                                if (py::hasattr(file, "__error__"))
                                                {
                                                    if (py::isinstance<py::str>(file.attr("__error__")))
                                                        detail.status = file.attr("__error__").cast<std::string>();
                                                    else
                                                        detail.status = "error thrown";
                                                }

                                                if (py::hasattr(plug_class, "__version__") && py::isinstance<py::str>(plug_class.attr("__version__")))
                                                {
                                                    detail.version = plug_class.attr("__version__").cast<std::string>();
                                                }

                                                if (py::hasattr(plug_class, "__doc__")&& py::isinstance<py::str>(plug_class.attr("__doc__")))
                                                {
                                                    detail.class_doc = plug_class.attr("__doc__").cast<std::string>();
                                                }
                                            }
                                            catch(std::exception &ex)
                                            {
                                                detail.status = "plugin not loaded";
                                                detail.error = ex.what();
                                            }

                                            python_plugin_map[type][plug_name] = detail;
                                            //detail.debug();
                                        }
                                        else
                                        {
                                            scan_warn << "PYthon plugin \"" << plug_name << "\" of type \"" << type << "\" has multiple definitions.  Ignoring all but one." << scan_end;
                                        }
                                    }
                                }
                            }
                            catch (std::exception &ex)
                            {
                                if (fname != "utils")
                                    scan_warn << "\"" << fname << "\" was not loaded: " << ex.what() << scan_end;
                            }

                        }
                    }

                    sys_list.attr("pop")();
                    }
                if (guard != nullptr)
                {
                    delete guard;
                }
            }

            PyPlugin_Details &Plugin_Loader::find_python_plugin(const std::string &type, const std::string &plugin)
            {
                std::map<std::string, std::map<std::string, PyPlugin_Details>>::iterator find;
                std::map<std::string, PyPlugin_Details>::iterator find2;

                if (((find = python_plugin_map.find(type)) != python_plugin_map.end()) &&
                    ((find2 = find->second.find(plugin)) != find->second.end()))
                {
                    return find2->second;
                }
                else
                {
                    scan_err << "Plugin \"" << plugin << "\" of type \"" << type << "\" is not found." << scan_end;
                    return find2->second;
                }
            }

            PyPlugin_Details &pluginInfo::load_python_plugin(const std::string &type, const std::string &plugin)
            {
                return plugins.find_python_plugin(type, plugin);
            }

            inline std::string print_plugins(std::map<std::string, std::map<std::string, std::vector<Plugin_Details>>>::const_iterator plugins,
                                             const std::map< std::string, std::map<std::string, PyPlugin_Details>> &pyplugins)
            {
                table_formatter table(plugins->first + " PLUGINS", "VERSION", "STATUS");
                table.capitalize_title();
                table.padding(1);

                std::map<std::string, std::vector<std::pair<std::string, std::string>>> temp;

                for (auto it = plugins->second.begin(); it != plugins->second.end(); ++it)
                {
                    for (auto jt = it->second.begin(); jt != it->second.end(); ++jt)
                    {
                        temp[it->first].emplace_back(jt->version, jt->status);
                    }
                }

                if (pyplugins.find(plugins->first) != pyplugins.end())
                    for (auto &&elem : pyplugins.at(plugins->first))
                    {
                        temp[elem.first].emplace_back(elem.second.version, elem.second.status);
                    }

                for (auto&& elem : temp)
                {
                    for (auto it = elem.second.begin(); it != elem.second.end(); ++it)
                    {
                        if (it == elem.second.begin())
                            table << elem.first;
                        else
                            table << "";
                        table << it->first;
                        if (it->second == "ok")
                            table.green() << it->second;
                        else
                            table.red() << it->second;
                    }
                }

                return table.str();
            }
        #endif

            /*************************************************/
            /************** END PYTHON STUFF *****************/
            /*************************************************/

            inline std::string print_plugins(std::map< std::string, std::map<std::string, std::vector<Plugin_Details> > >::const_iterator plugins)
            {
                table_formatter table(plugins->first + " PLUGINS", "VERSION", "STATUS");
                table.capitalize_title();
                table.padding(1);

                std::map<std::string, std::vector<std::pair<std::string, std::string>>> temp;

                for (auto it = plugins->second.begin(); it != plugins->second.end(); ++it)
                {
                    for (auto jt = it->second.begin(); jt != it->second.end(); ++jt)
                    {
                        const str firstentry = (jt == it->second.begin() ? it->first : "");
                        table << firstentry;
                        table << jt->version;
                        if (jt->status == "ok")
                            table.green() << jt->status;
                        else
                            table.red() << jt->status;
                    }
                }

                return table.str();
            }

            Plugin_Loader::Plugin_Loader() : path(GAMBIT_DIR "/ScannerBit/lib/")//, python_plugin_map(pyplugin_info())
            {
                std::string p_str;
                std::ifstream lib_list(path + "plugin_libraries.list");
                if (lib_list.is_open())
                {
                    while (lib_list >> p_str)
                    {
                        //if (p_str.find(".so") != std::string::npos && p_str.find(".so.") == std::string::npos)
                        p_str = path + p_str;
                        if(access(p_str.c_str(), F_OK) != -1) //can use R_OK|W_OK|X_OK also
                            loadLibrary (p_str);
                        else
                            scan_warn << "Could not find plugin library \"" << p_str << "\"." << scan_end;
                    }

                    auto excluded_plugins = loadExcluded(Utils::buildtime_scratch+"scanbit_excluded_libs.yaml");
                    const str linked_libs(Utils::buildtime_scratch+"scanbit_linked_libs.yaml");
                    const str reqd_entries(Utils::buildtime_scratch+"scanbit_reqd_entries.yaml");
                    const str flags(Utils::buildtime_scratch+"scanbit_flags.yaml");
                    process(linked_libs, reqd_entries, flags, excluded_plugins);
                }
                else
                {
                    scan_err << "Cannot open ./ScannerBit/lib/plugin_libraries.list" << scan_end;
                }

            }

            /// Check a plugin map and return a flag indicating if a candidate plugin is already in the map or not.
            bool is_new_plugin(std::map<str, std::map<str, std::vector<Plugin_Details>>>& pmap, Plugin_Details& cand)
            {
                bool new_plugin_type = pmap.find(cand.type) == pmap.end();
                bool new_plugin_name = new_plugin_type || pmap.at(cand.type).find(cand.plugin) == pmap.at(cand.type).end();
                bool new_plugin_version = true;
                if (not new_plugin_name)
                {
                    for (auto x : pmap.at(cand.type).at(cand.plugin))
                        if (x.version == cand.version) new_plugin_version = false;
                }
                return new_plugin_version;
            }

            void Plugin_Loader::process(const std::string& libFile, const std::string& plugFile, const std::string& flagFile, std::vector<Plugin_Details>& excluded_plugins)
            {
                YAML::Node libNode = YAML::LoadFile(libFile);
                YAML::Node plugNode = YAML::LoadFile(plugFile);
                YAML::Node flagNode = YAML::LoadFile(flagFile);

                for (auto it = excluded_plugins.begin(), end = excluded_plugins.end(); it != end; it++)
                {
                    if (is_new_plugin(total_plugin_map, *it))
                    {
                        it->get_status(libNode, plugNode, flagNode);
                        excluded_plugin_map[it->type][it->plugin].push_back(*it);
                        total_plugin_map[it->type][it->plugin].push_back(*it);
                    }
                }

                for (auto it = plugins.begin(), end = plugins.end(); it != end; it++)
                {
                    if (is_new_plugin(total_plugin_map, *it))
                    {
                        it->get_status(libNode, plugNode, flagNode);
                        plugin_map[it->type][it->plugin].push_back(*it);
                        total_plugin_map[it->type][it->plugin].push_back(*it);
                    }
                }
            }

            std::vector<Plugin_Details> Plugin_Loader::loadExcluded (const std::string& file)
            {
                std::vector<Plugin_Details> excluded_plugins;
                YAML::Node node = YAML::LoadFile(file);

                if (node.IsMap())
                {
                    for (auto it = node.begin(), end = node.end(); it != end; it++)
                    {
                        std::string lib = it->first.as<std::string>();
                        std::vector<Plugin_Details> excluded_plugins_temp;
                        std::vector<std::string> reason;
                        if (it->second.IsMap())
                        {
                            if (it->second["plugins"])
                            {
                                for (auto it2 = it->second["plugins"].begin(), end2 = it->second["plugins"].end(); it2 != end2; ++it2)
                                {
                                    Plugin_Details temp(it2->as<std::string>());

                                    temp.path = path + lib;
                                    temp.status = "excluded";
                                    excluded_plugins_temp.push_back(temp);
                                }
                            }

                            if (it->second["reason"])
                            {
                                for (auto rea : it->second["reason"])
                                {
                                    if(rea.IsScalar())
                                    {
                                        reason.push_back(rea.as<std::string>());
                                    }
                                    if(rea.IsMap())
                                    {
                                        for (auto it2 = rea.begin(), end2 = rea.end(); it2 != end2; ++it2)
                                        {
                                            reason.push_back(it2->first.as<std::string>() + ":  " + it2->second.as<std::string>());
                                        }
                                    }
                                }
                            }

                            for (auto it2 = excluded_plugins_temp.begin(), end2 = excluded_plugins_temp.end(); it2 != end2; ++it2)
                            {
                                it2->status = "excluded";
                                it2->reason.insert(it2->reason.end(), reason.begin(), reason.end());
                            }

                            excluded_plugins.insert(excluded_plugins.end(), excluded_plugins_temp.begin(), excluded_plugins_temp.end());
                            total_plugins.insert(total_plugins.end(), excluded_plugins_temp.begin(), excluded_plugins_temp.end());

                        }
                    }
                }
                return excluded_plugins;
            }

            void Plugin_Loader::loadLibrary (const std::string &p_str, const std::string &plug)
            {
                std::string str;
                if (FILE* f = popen((std::string("nm ") + p_str + std::string(" | grep \"__gambit_plugin_pluginInit_\"")).c_str(), "r"))
                {
                    char buffer[1024];
                    int n;
                    std::stringstream ss;

                    while ((n = fread(buffer, 1, sizeof buffer, f)) > 0)
                    {
                        ss << std::string(buffer, n);
                    }

                    while(std::getline(ss, str))
                    {
                        std::string::size_type pos = str.find("__gambit_plugin_pluginInit_");

                        if (pos != std::string::npos &&
                                (str.rfind(" T ", pos) != std::string::npos || str.rfind(" t ", pos) != std::string::npos))
                        {
                            Plugin_Details temp(str.substr(pos + 27, str.rfind("__") - pos - 27));

                            if (plug == "" || temp.plugin == plug)
                            {
                                temp.path = p_str;
                                plugins.push_back(temp);
                                total_plugins.push_back(temp);
                            }
                        }
                    }

                    pclose(f);
                }
            }

            std::vector<std::string> Plugin_Loader::print_plugin_names(const std::string &plug_type) const
            {
                std::vector<std::string> vec;
            #ifdef HAVE_PYBIND11
                plugin_info.load_python_plugins();
            #endif

                if (plug_type != "")
                {
                    auto plugins = total_plugin_map.find(plug_type);
                    if (plugins == total_plugin_map.end())
                    {
                        return vec;
                    }
                    else
                    {
                        for (auto it = plugins->second.begin(), end = plugins->second.end(); it != end; ++it)
                        {
                            vec.push_back(it->first);
                        }

                    #ifdef HAVE_PYBIND11
                        if (python_plugin_map.find(plug_type) != python_plugin_map.end())
                            for (auto &&elem : python_plugin_map.at(plug_type))
                                vec.push_back(elem.first);
                    #endif
                    }
                }
                else
                {
                    for (auto it = total_plugin_map.begin(), end = total_plugin_map.end(); it != end; it++)
                    {
                        for (auto it2 = it->second.begin(), end2 = it->second.end(); it2 != end2; ++it2)
                        {
                            vec.push_back(it2->first);
                        }

                    #ifdef HAVE_PYBIND11
                        if (python_plugin_map.find(it->first) != python_plugin_map.end())
                            for (auto &&elem : python_plugin_map.at(it->first))
                                vec.push_back(elem.first);
                    #endif
                    }
                }

                return vec;
            }

            std::vector<std::string> Plugin_Loader::list_prior_groups() const
            {
                YAML::Node node = YAML::LoadFile(GAMBIT_DIR "/config/priors.dat");
                std::vector<std::string> vec;

                for(auto &&n : node)
                {
                    if (n.second.IsSequence())
                        vec.push_back(n.first.as<std::string>());
                }

                vec.push_back("priors");

                return vec;
            }

            std::string Plugin_Loader::print_priors(const std::string &prior_group) const
            {
                YAML::Node node = YAML::LoadFile(GAMBIT_DIR "/config/priors.dat");
                std::stringstream out;

                if (prior_group == "priors")
                {
                    table_formatter table("Prior Name", "Prior Group");
                    //table.top_line(true);
                    table.bottom_line(true);
                    std::unordered_set<std::string> prior_set;
                    for(auto &&n : node)
                    {
                        if (n.second.IsSequence())
                        {
                            for(auto &&v : n.second.as<std::vector<std::string>>())
                            {
                                prior_set.insert(v);
                                if (Gambit::Priors::prior_creators.find(v) != Gambit::Priors::prior_creators.end())
                                table.no_newline() << v << n.first.as<std::string>();
                            }
                        }
                    }

                    for (auto &&v : Gambit::Priors::prior_creators)
                    {
                        if (prior_set.find(v.first) == prior_set.end())
                        {
                            table.no_newline() << v.first << "none";
                        }
                    }

                    table.no_newline() << "" << "";
                    out << "\x1b[01m\x1b[04mPRIOR LIST\x1b[0m\n" << std::endl;
                    out << format_for_screen("For information on a specific prior, see its prior group's diagnostic via \"./gambit group_name\".");
                    out << table.str() << std::endl;
                    out << "\x1b[01m\x1b[04mDESCRIPTION\x1b[0m\n" << std::endl;
                    if (node["priors"])
                        out << format_for_screen(node["priors"].as<std::string>()) << std::endl;
                }
                else
                {
                    std::vector<std::string> prior_names;
                    std::string description;
                    for(auto &&n : node)
                    {
                        if (n.first.as<std::string>() == prior_group)
                        {
                            if (n.second.IsSequence())
                            {
                                prior_names = n.second.as<decltype(prior_names)>();
                            }
                            else if (n.second.IsScalar())
                            {
                                description = n.second.as<std::string>();
                            }
                        }
                    }

                    if (prior_names.size() >0 || description != "")
                    {
                        out << "\x1b[01m\x1b[04mPRIORS INFO\x1b[0m\n" << std::endl;
                        out << "\x1b[01mprior group name:  \x1b[0m" << prior_group << std::endl;
                        out << "\x1b[01mpriors:  \x1b[0m" << prior_names << "\n" << std::endl;
                        out << "\x1b[01m\x1b[04mDESCRIPTION\x1b[0m\n\n" << description << std::endl;
                    }
                }

                return out.str();
            }

            std::string Plugin_Loader::print_all(const std::string &plug_type) const
            {
            #ifdef HAVE_PYBIND11
                plugin_info.load_python_plugins();
            #endif

                if (plug_type != "")
                {
                    auto plugins = total_plugin_map.find(plug_type);
                    if (plugins == total_plugin_map.end())
                    {
                        return "";
                    }
                    else
                    {
                    #ifdef HAVE_PYBIND11
                        return print_plugins(plugins, python_plugin_map);
                    #else
                        return print_plugins(plugins);
                    #endif
                    }
                }
                else
                {
                    std::string ret = "";
                    for (auto it = total_plugin_map.begin(), end = total_plugin_map.end(); it != end; it++)
                    {
                    #ifdef HAVE_PYBIND11
                        ret += print_plugins(it, python_plugin_map);
                    #else
                        ret += print_plugins(it);
                    #endif
                    }

                    return ret;
                }

                return "";
            }

            int Plugin_Loader::print_all_to_screen (const std::string &name) const
            {
                std::string output = print_all(name);
                if (output == "")
                    return 1;

                print_to_screen(output, name);
                return 0;
            }

            std::string Plugin_Loader::print_plugin(const std::string &name) const
            {
                std::unordered_map<std::string, std::vector<const Scanner::Plugins::Plugin_Details*>> vec;
                std::stringstream output;

                for (auto it_map = getPluginsMap().begin(), end = getPluginsMap().end(); it_map!= end; it_map++)
                {
                    auto it = it_map->second.find(name);
                    if (it != it_map->second.end())
                    {
                        for (auto &&plug : it->second)
                        {
                            vec[it_map->first].push_back(&plug);
                        }
                    }
                }

                if (vec.size() == 0)
                {
                    return ""; //NOTE: Need to add python scanners here.
                }
                else
                {
                    for (auto it = vec.begin(), end = vec.end(); it != end; it++)
                    {
                        output << Plugin_Details::printMultiPlugins(it->second) << std::endl;
                    }
                }

                return output.str();
            }

            std::string Plugin_Loader::print_plugin(const std::string &type, const std::string &plugin) const
            {
                std::vector<const Scanner::Plugins::Plugin_Details *> vec;
                if((getPluginsMap().find(type) == getPluginsMap().end()) || (getPluginsMap().at(type).find(plugin) == getPluginsMap().at(type).end()))
                {
                #ifdef HAVE_PYBIND11
                    plugin_info.load_python_plugins();
                    std::map<std::string, std::map<std::string, PyPlugin_Details>>::const_iterator find;
                    std::map<std::string, PyPlugin_Details>::const_iterator find2;

                    if (((find = python_plugin_map.find(type)) != python_plugin_map.end()) &&
                        ((find2 = find->second.find(plugin)) != find->second.end()))
                    {
                        return find2->second.print();
                    }
                    else
                    {
                        return "";
                    }
                #else
                    return "";
                #endif
                }

                for (auto it = getPluginsMap().at(type).at(plugin).begin(), end = getPluginsMap().at(type).at(plugin).end(); it != end; it++)
                {
                    vec.push_back(&(*it));
                }

                return Plugin_Details::printMultiPlugins(vec) + "\n";
            }

            int Plugin_Loader::print_plugin_to_screen (const std::string &name) const
            {
                std::string output = print_plugin(name);
                if (output == "")
                    return 1;

                print_to_screen(output, name);
                return 0;
            }

            int Plugin_Loader::print_plugin_to_screen (const std::string &type, const std::string &name) const
            {
                std::string output = print_plugin(type, name);
                if (output == "")
                    return 1;

                print_to_screen(output, name);
                return 0;
            }

            int Plugin_Loader::print_plugin_to_screen (const std::vector<std::string> &names) const
            {
                std::string output;
                for (auto it = names.begin(), end = names.end(); it != end; ++it)
                {
                    output += print_plugin(*it) + "\n";
                }

                if (output == "")
                    return 1;

                print_to_screen(output, names[0]);
                return 0;
            }

            Plugin_Details &Plugin_Loader::find (const std::string &type, std::string plugin, const std::string &version, const std::string &lib) const
            {
                std::vector<Plugin_Details_Ref> plugins;

                if((plugin_map.find(type) == plugin_map.end()) || (plugin_map.at(type).find(plugin) == plugin_map.at(type).end()))
                {
                #ifdef HAVE_PYBIND11
                    plugin = "python";
                #else
                    scan_err << "There is no plugin named \"" << plugin <<"\" of type \"" << type << "\"" << scan_end;
                #endif
                }

                for (auto it = plugin_map.at(type).at(plugin).begin(), end = plugin_map.at(type).at(plugin).end(); it != end; it++)
                {
                    if (VersionCompare(version)(*it) && (lib == "" || lib == it->path) and it->status == "ok")
                        plugins.push_back(*it);
                }

                if (plugins.size() > 1)
                {
                    std::sort(plugins.begin(), plugins.end(), Plugin_Version_Supersedes);
                    auto it2 = plugins.begin();
                    std::vector<Plugin_Details_Ref> matches;
                    for (auto it = it2 + 1, end = plugins.end(); it != end; it++)
                    {
                        if (*it == *it2) matches.push_back(*it);
                    }
                    if (not matches.empty())
                    {
                      scan_err << "More than one plugin met the input criteria in the YAML file:\n\n" << static_cast<Plugin_Details &>(*it2).print() << "\n";
                      for (auto it = matches.begin(); it != matches.end(); it++)
                      {
                        scan_err << static_cast<Plugin_Details &>(*it).print() << "\n";
                      }
                      scan_err << "To indicate to ScannerBit which of these plugins should be used, please"
                               << "\nadd more specific information in the Scanners section of your YAML file." << scan_end;
                    }
                }
                else if (plugins.size() == 0)
                {
                    scan_err << "Plugin \"" << plugin << "\" of type \"" << type << "\" and "
                            << " version \"" << version << "\" is not found." << scan_end;
                    plugins.resize(1);
                }

                return plugins[0];
            }

            void pluginInfo::iniFile(const Options &options_in)
            {
                options = options_in;

                if (options.getNode().IsMap())
                {
                    if (options.hasKey("default_output_path"))
                        def_out_path = options.getValue<std::string>("default_output_path");
                    else
                        scan_err << "\"default output path\" must be specified in KeyValues section." << scan_end;

                    for (auto it = options.getNode().begin(), end = options.getNode().end(); it != end; it++)
                    {
                        std::string plug_type = it->first.as<std::string>();

                        if (it->second.IsMap() && plug_type[plug_type.length()-1] == 's' && plug_type != "priors" && plug_type != "parameters")
                        {
                            for (auto it_p = it->second.begin(), end = it->second.end(); it_p != end; it_p++)
                            {
                                std::string plug_tag = it_p->first.as<std::string>();

                                Proto_Plugin_Details temp;

                                if (it_p->second["plugin"])
                                {
                                    temp.plugin = it_p->second["plugin"].as<std::string>();
                                }
                                else
                                {
                                    scan_warn << "Plugin name is not defined under the \"" << it->first << "\" tag.  "
                                                << "using the tag \"" << it_p->first.as<std::string>()
                                                << "\" as the plugin name." << scan_end;
                                    temp.plugin = it_p->first.as<std::string>();
                                }

                                if (it_p->second["version"])
                                    temp.version = it_p->second["version"].as<std::string>();

                                if (it_p->second["plugin_path"])
                                {
                                    temp.path = it_p->second["plugin_path"].as<std::string>();
                                    plugins.loadLibrary(temp.path, temp.plugin);
                                }

                                selectedPlugins[plug_type.substr(0, plug_type.length()-1)][plug_tag] = temp;
                            }
                        }
                    }
                }
                else
                {
                    scan_err << "Plugins subsection is not of the \"Map\" YAML format." << scan_end;
                }
            }

            void pluginInfo::printer_prior(printer_interface &printerIn, Priors::BasePrior &prior_in)
            {
                printer = &printerIn;
                prior = &prior_in;
            }

            Plugins::Plugin_Interface_Details pluginInfo::operator()(const std::string &type, const std::string &tag)
            {
                if (selectedPlugins.find(type) != selectedPlugins.end() && selectedPlugins[type].find(tag) != selectedPlugins[type].end())
                {
                    Proto_Plugin_Details &detail = selectedPlugins[type][tag];
                    YAML::Node plugin_options = options.getNode(type + "s", tag);

                    plugin_options["default_output_path"] = options.getValue<std::string>("default_output_path");
                    plugin_options["print_timing_data"] = options.getValue<std::string>("print_timing_data");

                    if (!plugin_options["likelihood: model_invalid_for_lnlike_below"])
                        plugin_options["likelihood: model_invalid_for_lnlike_below"] = options.getValue<double>("model_invalid_for_lnlike_below");

                    if (!plugin_options["likelihood: lnlike_offset"] and options.hasKey("lnlike_offset"))
                        plugin_options["likelihood: lnlike_offset"] = options.getValue<double>("lnlike_offset");

                    return Plugin_Interface_Details(plugins.find(type, detail.plugin, detail.version, detail.path), printer, prior, plugin_options);
                }
                else
                {
                    scan_err << "Plugin \"" << tag << "\" of type \"" << type << "\" is not defined under the \"Scanner\""
                            << " subsection in the inifile" << scan_end;

                    return Plugin_Interface_Details(plugins.find(type, "", "", ""), printer, prior, options.getOptions(type + "s", tag).getNode());
                }
            }

            void pluginInfo::dump()
            {
                for (auto it = resume_data.begin(), end = resume_data.end(); it != end; ++it)
                {
                    std::string path = Gambit::Utils::ensure_path_exists(def_out_path + "/temp_files/" + it->first);
                    std::ofstream out((path).c_str(), std::ofstream::binary);
                    for (auto v_it = it->second.begin(), v_end = it->second.end(); v_it != v_end; ++v_it)
                    {
                        (*v_it)->print(out);
                    }
                }

                printer->finalise(true); //"true" flag for "abnormal" stop; i.e. run is not completely finished
                // Debugging output
                // #ifdef WITH_MPI
                //   std::cout << "rank " << getRank() <<": ";
                // #endif
                // std::cout << "Gambit has written resume data to disk, preparing to stop!" << std::endl;
            }

            void pluginInfo::dump(const std::string &name)
            {
                auto it = resume_data.find(name);
                if (it != resume_data.end())
                {
                    std::string path = Gambit::Utils::ensure_path_exists(def_out_path + "/temp_files/" + name);
                    std::ofstream out((path).c_str(), std::ofstream::binary);
                    for (auto v_it = it->second.begin(), v_end = it->second.end(); v_it != v_end; ++v_it)
                    {
                        (*v_it)->print(out);
                    }
                }
            }

            /// Save persistence file to record that the alternative min_LogL value is in use for this scan
            void pluginInfo::save_alt_min_LogL_state() const
            {
                std::string state_fname(def_out_path+"/ALT_MIN_LOGL_IN_USE");
                std::ofstream outfile(state_fname);
                outfile.close();
            }

            /// Delete the persistence file if it exists (e.g. when starting a new run)
            void pluginInfo::clear_alt_min_LogL_state() const
            {
                if(check_alt_min_LogL_state())
                {
                    std::string state_fname(def_out_path+"/ALT_MIN_LOGL_IN_USE");
                    // Persistence file exists: delete it
                    if (remove(state_fname.c_str())) scan_err << "Failed to delete alternative min_LogL persistence file '" << state_fname << "'! Error was: " << strerror(errno) << scan_end;
                }
            }

            /// Check persistence file to see if we should be using the alternative min_LogL value
            bool pluginInfo::check_alt_min_LogL_state() const
            {
                return Utils::file_exists(def_out_path+"/ALT_MIN_LOGL_IN_USE");
            }

            pluginInfo::~pluginInfo()
            {
                for (auto it = resume_streams.begin(), end = resume_streams.end(); it != end; ++it)
                {
                    delete it->second;
                }
            }

            pluginInfo::pluginInfo()
              : keepRunning(true), funcCalculating(false), MPIrank(0)
              #ifdef WITH_MPI
              , scannerComm(NULL), MPIdata_is_init(false)
              #endif
              , earlyShutdownInProgress(false)
            {}

            #ifdef WITH_MPI
            ///Initialise any MPI functionality (currently just used to provide a communicator object to ScannerBit)
            void pluginInfo::initMPIdata(GMPI::Comm* newcomm)
            {
               scannerComm = newcomm;
               MPIdata_is_init = true;
               MPIrank = scanComm().Get_rank();
            }

            GMPI::Comm& pluginInfo::scanComm()
            {
               if(not MPIdata_is_init)
               {
                  std::cerr << "Tried to retrieve scanComm MPI communicator (in ScannerBit), but it has not been initialised! Please be sure to call 'initMPIdata' and provide a communicator before allowing any scans to commence." << std::endl;
                  exit(1); //TODO not sure if this should be a standard GAMBIT error or not. Going with 'not' for now.
               }
               return *scannerComm;
            }
            #endif

            pluginInfo plugin_info;
        }
    }
}

Updated on 2024-07-18 at 13:53:33 +0000