Robotics Systems Commons

                  "rsc/threading/*.cpp"

                  "rsc/plugins/*.cpp")

                  "rsc/threading/*.h"

                  "rsc/plugins/*.h")

TARGET_LINK_LIBRARIES(${RSC_NAME} ${Boost_LIBRARIES}

                                  ${CMAKE_THREAD_LIBS_INIT}

                                  dl)

/* ============================================================

 *

 * This file is part of the RSB project.

 *

 * Copyright (C) 2012 Jan Moringen <jmoringe@techfak.uni-bielefeld.de>

 *

 * This file may be licensed under the terms of the

 * GNU Lesser General Public License Version 3 (the ``LGPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the LGPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the LGPL along with this

 * program. If not, go to http://www.gnu.org/licenses/lgpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by:

 *   CoR-Lab, Research Institute for Cognition and Robotics

 *     Bielefeld University

 *

 * ============================================================  */

#include "Configurator.h"

#include <boost/format.hpp>

#include <boost/tokenizer.hpp>

#include "../runtime/ContainerIO.h"

#include "../logging/LoggerFactory.h"

using namespace std;

using namespace boost;

using namespace boost::filesystem;

namespace rsc {

namespace plugins {

Configurator::Configurator(const vector<path>& defaultPath)

    : logger(logging::LoggerFactory::getInstance()

             .getLogger("rsc.plugins.Configurator")),

      manager(Manager::getInstance()),

      pathSet(false),

      defaultPath(defaultPath) {

}

Configurator::~Configurator() {

    // If a searchpath has not been set via configuration options, use

    // the default.

    if (!this->pathSet) {

        RSCINFO(this->logger, "No searchpath configured; using default: "

                << this->defaultPath);

        addDefaultPath();

    }

    // Load all requested plugins.

    for (vector<string>::const_iterator it = this->load.begin();

         it != this->load.end(); ++it) {

        string name = *it;

        try {

            this->manager.getPlugin(name)->load();

        } catch (const std::exception& e) {

            throw runtime_error(str(format("Failed to load plugin `%1%' as requested via configuration: %2%")

                                    % name

                                    % e.what()));

        }

    }

}

void Configurator::handleOption(const vector<string>& key,

                                const string& value) {

    RSCDEBUG(this->logger, "Processing option " << key << " = `" << value << "'");

    // Ignore other options.

    if (!((key.size() == 3)

          && (key[0] == "plugins")

          && (key[1] == "cpp"))) {

        return;

    }

    // Process plugins.cpp.{path,load} options.

    if (key[2] == "path") {

        // Split value at ":" tokens. Each substring is a searchpath

        // entry.

        vector<string> paths = splitValue(value);

        // Add all specified paths. The empty string, produced by "::"

        // means that the default searchpath should be spliced in.

        for (vector<string>::const_iterator it = paths.begin();

             it != paths.end(); ++it) {

            string path = *it;

            try {

                if (path.empty()) {

                    path = "<default path>"; // for exception message

                    addDefaultPath();

                } else {

                    this->manager.addPath(path);

                }

            } catch (const std::exception& e) {

                throw runtime_error(str(format("Failed to add path `%1%' as requested via configuration: %2%")

                                        % path

                                        % e.what()));

            }

        }

        this->pathSet = true;

    } else if (key[2] == "load") {

        vector<string> temp = splitValue(value);

        copy(temp.begin(), temp.end(), back_inserter(this->load));

    } else {

        throw invalid_argument(str(format("Invalid option key `%1%'; plugin related option keys are `path' and `load'.")

                                   % key));

    }

}

void Configurator::addDefaultPath() {

    for (vector<path>::const_iterator it = this->defaultPath.begin();

         it != this->defaultPath.end(); ++it) {

        this->manager.addPath(*it);

    }

}

vector<string> Configurator::splitValue(const string& value) const {

    vector<string> result;

    boost::escaped_list_separator<char> sep('\\', ':');

    boost::tokenizer< boost::escaped_list_separator<char> > tok(value, sep);

    copy(tok.begin(), tok.end(), back_inserter(result));

    return result;

}

}

}

/* ============================================================

 *

 * This file is part of the RSB project.

 *

 * Copyright (C) 2012 Jan Moringen <jmoringe@techfak.uni-bielefeld.de>

 *

 * This file may be licensed under the terms of the

 * GNU Lesser General Public License Version 3 (the ``LGPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the LGPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the LGPL along with this

 * program. If not, go to http://www.gnu.org/licenses/lgpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by:

 *   CoR-Lab, Research Institute for Cognition and Robotics

 *     Bielefeld University

 *

 * ============================================================  */

#pragma once

#include <string>

#include <vector>

#include "../config/OptionHandler.h"

#include "../logging/Logger.h"

#include "Manager.h"

#include <rsc/rscexports.h>

namespace rsc {

namespace plugins {

/**

 * Instances of this class can be used to configure the #Manager based

 * on configuration options.

 *

 * Note that the configuration may be performed when the object is

 * destructed.

 *

 * @author jmoringe

 */

class RSC_EXPORT Configurator : public config::OptionHandler {

public:

    /**

     * Constructs a @c Configurator with default plugin search path @a

     * defaultPath.

     *

     * @param defaultPath A #vector of #boost::filesystem::path

     *                    objects which should be installed as plugin

     *                    search path in case no plugin search path is

     *                    configured.

     */

    Configurator(const std::vector<boost::filesystem::path>& defaultPath);

    virtual ~Configurator();

private:

    logging::LoggerPtr logger;

    Manager& manager;

    bool                                 pathSet;

    std::vector<boost::filesystem::path> defaultPath;

    std::vector<std::string>             load;

    void handleOption(const std::vector<std::string>& key,

                      const std::string& value);

    void addDefaultPath();

    std::vector<std::string> splitValue(const std::string& value) const;

};

}

}

/* ============================================================

 *

 * This file is part of the RSB project.

 *

 * Copyright (C) 2012 Jan Moringen <jmoringe@techfak.uni-bielefeld.de>

 *

 * This file may be licensed under the terms of the

 * GNU Lesser General Public License Version 3 (the ``LGPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the LGPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the LGPL along with this

 * program. If not, go to http://www.gnu.org/licenses/lgpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by:

 *   CoR-Lab, Research Institute for Cognition and Robotics

 *     Bielefeld University

 *

 * ============================================================  */

#include "Manager.h"

#include <stdexcept>

#include <algorithm>

#include <boost/filesystem/operations.hpp>

#include <boost/regex.hpp>

#include <boost/format.hpp>

#include "../runtime/NoSuchObject.h"

#include "../logging/LoggerFactory.h"

using namespace std;

using namespace boost;

using namespace boost::filesystem;

namespace rsc {

namespace plugins {

Manager::Manager()

  : logger(logging::LoggerFactory::getInstance()

           .getLogger("rsc.plugins.Manager")) {

}

Manager::~Manager() {

}

vector<path> Manager::getPath() const {

  return this->path;

}

void Manager::addPath(const boost::filesystem::path& path) {

    // Ignore duplicates.

    if (find(this->path.begin(), this->path.end(), path)

        != this->path.end()) {

        return;

    }

    // Search specified directory for plugins.

    RSCINFO(this->logger, "Adding path `" << path << "'");

    for (directory_iterator it = directory_iterator(path);

         it != directory_iterator(); ++it) {

        if (!is_regular_file(it->path())) {

            continue;

        }

        // Extract the plugin name from the library name.

        string name = it->path().stem();

        // Strip leading "lib"

        if (name.substr(0, 3) == "lib") {

            name = name.substr(3);

        }

        // Strip trailing ".so*"

        for (unsigned int i = 0; i <= 2; ++i) {

            if (name.substr(name.size() - (3 + i)).substr(0, 3) == ".so") {

                name = name.substr(0, name.size() - (3 + i));

                break;

            }

        }

        boost::filesystem::path library = it->path();

        // If there is not yet an entry for the given name, add a new

        // plugin entry. Otherwise, ignore the plugin. This logic

        // implements precedence of searchpath entries.

        RSCINFO(this->logger, "Found plugin `"

                << name << "' [" << library << "]");

        if (this->plugins.find(name) == this->plugins.end()) {

            this->plugins[name] = Plugin::create(name, library.native_file_string());

        }

    }

    this->path.push_back(path);

}

set<PluginPtr> Manager::getPlugins() const {

    set<PluginPtr> result;

    for (PluginMap::const_iterator it = this->plugins.begin();

         it != this->plugins.end(); ++it) {

        result.insert(it->second);

    }

    return result;

  }

PluginPtr Manager::getPlugin(const string& name) const {

    PluginMap::const_iterator it;

    if ((it = this->plugins.find(name)) == this->plugins.end()) {

      throw runtime::NoSuchObject(name);

    }

    return it->second;

}

}

}

/* ============================================================

 *

 * This file is part of the RSB project.

 *

 * Copyright (C) 2012 Jan Moringen <jmoringe@techfak.uni-bielefeld.de>

 *

 * This file may be licensed under the terms of the

 * GNU Lesser General Public License Version 3 (the ``LGPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the LGPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the LGPL along with this

 * program. If not, go to http://www.gnu.org/licenses/lgpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by:

 *   CoR-Lab, Research Institute for Cognition and Robotics

 *     Bielefeld University

 *

 * ============================================================  */

#pragma once

#include <vector>

#include <set>

#include <map>

#include <boost/filesystem/path.hpp>

#include "../patterns/Singleton.h"

#include "../logging/Logger.h"

#include "Plugin.h"

#include "rsc/rscexports.h"

namespace rsc {

namespace plugins {

/**

 * The singleton instance of this class manages plugin search path

 * entries and plugins.

 *

 * Plugins can be retrieved as #Plugin objects, loaded and unloaded.

 *

 * @author jmoringe

 */

class RSC_EXPORT Manager : public patterns::Singleton<Manager> {

public:

    virtual ~Manager();

    /**

     * Returns the current plugin search path.

     *

     * @return A #std::vector of #boost::filesystem::path objects.

     */

    std::vector<boost::filesystem::path> getPath() const;

    /**

     * Adds @a path to the list of search path entries.

     *

     * @param path A #boost::filesystem::path designating a directory

     *             which should be searched for plugins.

     * @throw exception If @a path does not exist or is otherwise

     *                  inaccessible.

     */

    void addPath(const boost::filesystem::path& path);

    /**

     * Returns the set of known plugins.

     *

     * @return A copy of the set of known plugins.

     */

    std::set<PluginPtr> getPlugins() const;

    /**

     * Return the plugin designated by @a name.

     *

     * @param name The name of the plugin which should be returned.

     * @return The requested plugin.

     * @throw NoSuchObject If @a name does not designate a plugin.

     */

    PluginPtr getPlugin(const std::string& name) const;

private:

    friend class patterns::Singleton<Manager>;

    typedef std::vector<boost::filesystem::path> PathList;

    typedef std::map<std::string, PluginPtr>     PluginMap;

    logging::LoggerPtr logger;

    PathList  path;

    PluginMap plugins;

    Manager();

};

}

}

/* ============================================================

 *

 * This file is part of the RSB project.

 *

 * Copyright (C) 2012 Jan Moringen <jmoringe@techfak.uni-bielefeld.de>

 *

 * This file may be licensed under the terms of the

 * GNU Lesser General Public License Version 3 (the ``LGPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the LGPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the LGPL along with this

 * program. If not, go to http://www.gnu.org/licenses/lgpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by:

 *   CoR-Lab, Research Institute for Cognition and Robotics

 *     Bielefeld University

 *

 * ============================================================  */

#include "Plugin.h"

#include <errno.h>

#include <string.h>

#include <dlfcn.h>

#include <stdexcept>

#include <boost/format.hpp>

#include "../logging/Logger.h"

#include "../logging/LoggerFactory.h"

using namespace std;

using namespace boost;

namespace rsc {

namespace plugins {

const std::string PLUGIN_INIT_SYMBOL     = "rsc_plugin_init";

const std::string PLUGIN_SHUTDOWN_SYMBOL = "rsc_plugin_shutdown";

class Impl {

public:

    Impl(const std::string& name,

         const std::string& library)

        : logger(logging::LoggerFactory::getInstance()

                 .getLogger(str((format("rsc.plugins.Plugin[%1%]")

                                 % name)))),

          name(name), library(library),

          handle(NULL) {

    }

    const string& getName() const {

        return this->name;

    }

    void load() {

        RSCINFO(this->logger, "Trying to load library `" << this->library << "'");

        // Load the library containing the plugin.

        if (!(this->handle = dlopen(this->library.c_str(), RTLD_NOW))) {

            char buffer[4096];

            const char* result = strerror_r(errno, buffer, 4096);

            throw runtime_error(str(format("Failed to load plugin `%1%' from shared object `%2%': %3%.")

                                    % this->name

                                    % this->library

                                    % (result ? result : "<unknown error>")));

        }

        // Lookup init and shutdown functions in the plugin library.

        this->init

            = reinterpret_cast<InitFunction>(resolveSymbol(PLUGIN_INIT_SYMBOL));

        this->shutdown

            = reinterpret_cast<ShutdownFunction>(resolveSymbol(PLUGIN_SHUTDOWN_SYMBOL));

        // Initialize the plugin.

        RSCINFO(this->logger, "Initializing");

        try {

            this->init();

        } catch (const std::exception& e) {

            throw runtime_error(str(format("Plugin `%1%' failed to initialize: %2%")

                                    % this->name

                                    % e.what()));

        } catch (...) {

            throw runtime_error(str(format("Plugin `%1%' failed to initialize due to unknown error.")

                                    % this->name));

        }

    }

    void unload() {

        // Shut the plugin down.

        RSCINFO(this->logger, "Shutting down");

        try {

            this->shutdown();

        } catch (const std::exception& e) {

            throw runtime_error(str(format("Plugin `%1%' failed to shutdown: %2%")

                                    % this->name

                                    % e.what()));

        } catch (...) {

            throw runtime_error(str(format("Plugin `%1%' failed to shutdown due to unknown error.")

                                    % this->name));

        }

    }

private:

    typedef void (*InitFunction)();

    typedef void (*ShutdownFunction)();

    rsc::logging::LoggerPtr logger;

    string name;

    string library;

    void*            handle;

    InitFunction     init;

    ShutdownFunction shutdown;

    void* resolveSymbol(const string& name) {

        RSCINFO(this->logger, "Resolving symbol `"

                << name

                << "' in library `" << this->library << "'");

        assert(this->handle);

        void *address;

        if (!(address = dlsym(this->handle, name.c_str()))) {

            char buffer[4096];

            const char* result = strerror_r(errno, buffer, 4096);

            throw runtime_error(str(format("Plugin `%1%' failed to define function `%2%': %3%")

                                    % this->name

                                    % name

                                    % (result ? result : "<unknown error>")));

        }

        return address;

    }

};

Plugin::Plugin(Impl* impl)

    : impl(impl) {

}

Plugin::~Plugin() {

}

const string& Plugin::getName() const {

    return this->impl->getName();

}

void Plugin::load() {

    this->impl->load();

}

PluginPtr Plugin::create(const std::string& name, const std::string& library) {

    return PluginPtr(new Plugin(new Impl(name, library)));

}

}

}

/* ============================================================

 *

 * This file is part of the RSB project.

 *

 * Copyright (C) 2012 Jan Moringen <jmoringe@techfak.uni-bielefeld.de>

 *

 * This file may be licensed under the terms of the

 * GNU Lesser General Public License Version 3 (the ``LGPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the LGPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the LGPL along with this

 * program. If not, go to http://www.gnu.org/licenses/lgpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by:

 *   CoR-Lab, Research Institute for Cognition and Robotics

 *     Bielefeld University

 *

 * ============================================================  */

#pragma once

#include <string>

#include <boost/noncopyable.hpp>

#include <boost/scoped_ptr.hpp>

#include <boost/shared_ptr.hpp>

#include "rsc/rscexports.h"

namespace rsc {

namespace plugins {

extern const std::string PLUGIN_INIT_SYMBOL;

extern const std::string PLUGIN_SHUTDOWN_SYMBOL;

class Impl;

/**

 * Instances of this class represent pieces of RSB-related

 * functionality which can be loaded into a program at runtime.

 *

 * @author jmoringe

 */

class RSC_EXPORT Plugin : boost::noncopyable {

public:

    virtual ~Plugin();

    /**

     * Returns the name of the plugin.

     *

     * @return The name of the plugin.

     */

    const std::string& getName() const;

    /**

     * Tries to load the functionality of the plugin into the current

     * process.

     *

     * @throw runtime_error If the plugin cannot be loaded for some

     *                      reason.

     */

    void load();

    /**

     * Tries to unload the functionality of the plugin.

     *

     * @throw runtime_error If the plugin cannot be unloaded for some

     *                      reason.

     */

    void unload();

private:

    friend class Manager;

    boost::scoped_ptr<Impl> impl;

    Plugin(Impl* impl);

    static boost::shared_ptr<Plugin> create(const std::string& name,

                                            const std::string& library);

};

typedef boost::shared_ptr<Plugin> PluginPtr;

}

}

/* ============================================================

 *

 * This file is part of the RSB project.

 *

 * Copyright (C) 2012 Jan Moringen <jmoringe@techfak.uni-bielefeld.de>

 *

 * This file may be licensed under the terms of the

 * GNU Lesser General Public License Version 3 (the ``LGPL''),

 * or (at your option) any later version.

 *

 * Software distributed under the License is distributed

 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

 * express or implied. See the LGPL for the specific language

 * governing rights and limitations.

 *

 * You should have received a copy of the LGPL along with this

 * program. If not, go to http://www.gnu.org/licenses/lgpl.html

 * or write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * The development of this software was supported by:

 *   CoR-Lab, Research Institute for Cognition and Robotics

 *     Bielefeld University

 *

 * ============================================================  */

#pragma once

#include <string>

#define RSC_PLUGIN_INIT_SYMBOL     rsc_plugin_init

#define RSC_PLUGIN_SHUTDOWN_SYMBOL rsc_plugin_shutdown