platform/include/pion/platform/PluginConfig.hpp

// ------------------------------------------------------------------------
// Pion is a development platform for building Reactors that process Events
// ------------------------------------------------------------------------
// Copyright (C) 2007-2008 Atomic Labs, Inc.  (http://www.atomiclabs.com)
//
// Pion is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// Pion is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for
// more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with Pion.  If not, see <http://www.gnu.org/licenses/>.
//

#ifndef __PION_PLUGINCONFIG_HEADER__
#define __PION_PLUGINCONFIG_HEADER__

#include <libxml/tree.h>
#include <boost/bind.hpp>
#include <boost/signal.hpp>
#include <boost/thread/mutex.hpp>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>
#include <pion/PluginManager.hpp>
#include <pion/platform/Vocabulary.hpp>
#include <pion/platform/VocabularyManager.hpp>
#include <pion/platform/ConfigManager.hpp>


namespace pion {        // begin namespace pion
namespace platform {    // begin namespace platform (Pion Platform Library)

template <typename PluginType>
class PluginConfig :
    public ConfigManager
{
public:

    class PluginException : public PionException {
    public:
        PluginException(const std::string& error_msg)
            : PionException(error_msg)
        {}
    };
    

    virtual ~PluginConfig() {}
    
    virtual void createConfigFile(void) {
        boost::mutex::scoped_lock plugins_lock(m_mutex);
        // just return if it's already open
        if (ConfigManager::configIsOpen())
            return;
        // create the file with "config" root element
        ConfigManager::createConfigFile();
        PION_LOG_INFO(m_logger, "Initializing new " << m_plugin_element
                      << " configuration file: " << ConfigManager::getConfigFile());
    }       
    
    virtual void openConfigFile(void) {
        boost::mutex::scoped_lock plugins_lock(m_mutex);
        // just return if it's already open
        if (ConfigManager::configIsOpen())
            return;
        // open the plug-in config file and load plug-ins
        ConfigManager::openPluginConfig(m_plugin_element);
        PION_LOG_INFO(m_logger, "Loaded " << m_plugin_element
                      << " configuration file: " << ConfigManager::getConfigFile());
    }
        
    virtual void writeConfigXML(std::ostream& out) const {
        boost::mutex::scoped_lock plugins_lock(m_mutex);
        ConfigManager::writeConfigXMLHeader(out);
        ConfigManager::writeConfigXML(out, m_config_node_ptr, true);
    }
    
    inline bool writeConfigXML(std::ostream& out, const std::string& plugin_id) const;
    
    inline xmlNodePtr getPluginConfig(const std::string& plugin_id);
    
    inline bool hasPlugin(const std::string& plugin_id) const {
        return (m_plugins.get(plugin_id) != NULL);
    }
    
    template <typename PluginUpdateFunction>
    inline boost::signals::connection registerForUpdates(PluginUpdateFunction f) const {
        boost::mutex::scoped_lock signal_lock(m_signal_mutex);
        return m_signal_plugins_updated.connect(f);
    }

    inline void updateVocabulary(void) {
        VocabularyPtr vocab_ptr(m_vocab_mgr.getVocabulary());
        m_plugins.run(boost::bind(&PluginType::updateVocabulary, _1,
                                  boost::cref(*vocab_ptr)));
    }

    inline VocabularyPtr getVocabulary(void) const { return m_vocab_mgr.getVocabulary(); }

    inline const VocabularyManager& getVocabularyManager(void) const { return m_vocab_mgr; }
    
    
protected:

    inline void releasePlugins(void) { m_plugins.clear(); }

    PluginConfig(const VocabularyManager& vocab_mgr,
                 const std::string& config_file,
                 const std::string& plugin_element)
        : ConfigManager(config_file),
        m_vocab_mgr(vocab_mgr),
        m_plugin_element(plugin_element)
    {
        m_vocab_connection = vocab_mgr.registerForUpdates(boost::bind(&PluginConfig::updateVocabulary, this));
        setLogger(PION_GET_LOGGER("pion.platform.PluginConfig"));
    }

    inline void setPluginConfig(const std::string& plugin_id,
                                const xmlNodePtr config_ptr);

    inline std::string addPlugin(const xmlNodePtr config_ptr);
    
    inline void removePlugin(const std::string& plugin_id);
    
    virtual void addPluginNoLock(const std::string& plugin_id,
                                 const std::string& plugin_name,
                                 const xmlNodePtr config_ptr) = 0;
    
    
    const VocabularyManager&        m_vocab_mgr;

    const std::string               m_plugin_element;
    
    PluginManager<PluginType>       m_plugins;

    boost::signals::scoped_connection   m_vocab_connection;
    
    mutable boost::signal0<void>    m_signal_plugins_updated;

    mutable boost::mutex            m_signal_mutex; 

    mutable boost::mutex            m_mutex;    
};

    
// inline member functions for PluginConfig

template <typename PluginType>
inline bool PluginConfig<PluginType>::writeConfigXML(std::ostream& out,
                                                     const std::string& plugin_id) const
{
    // find the plug-in element in the XML config document
    boost::mutex::scoped_lock plugins_lock(m_mutex);
    xmlNodePtr plugin_node = findConfigNodeByAttr(m_plugin_element,
                                                  ID_ATTRIBUTE_NAME,
                                                  plugin_id,
                                                  m_config_node_ptr->children);
    if (plugin_node == NULL)
        return false;
    
    // found it
    ConfigManager::writeBeginPionConfigXML(out);
    ConfigManager::writeConfigXML(out, plugin_node, false);
    ConfigManager::writeEndPionConfigXML(out);

    return true;
}

template <typename PluginType>
inline xmlNodePtr PluginConfig<PluginType>::getPluginConfig(const std::string& plugin_id)
{
    // find the plug-in element in the XML config document
    boost::mutex::scoped_lock plugins_lock(m_mutex);
    xmlNodePtr plugin_node = findConfigNodeByAttr(m_plugin_element,
                                                  ID_ATTRIBUTE_NAME,
                                                  plugin_id,
                                                  m_config_node_ptr->children);
    if (plugin_node == NULL)
        throw typename PluginManager<PluginType>::PluginNotFoundException(plugin_id);
    
    // copy the plugin configuration
    return xmlCopyNodeList(plugin_node);
}
    
template <typename PluginType>
inline void PluginConfig<PluginType>::setPluginConfig(const std::string& plugin_id,
                                                      const xmlNodePtr config_ptr)
{
    // make sure that the plug-in configuration file is open
    if (! configIsOpen())
        throw ConfigNotOpenException(getConfigFile());
    
    VocabularyPtr vocab_ptr(m_vocab_mgr.getVocabulary());

    // update it within memory and the configuration file
    boost::mutex::scoped_lock plugins_lock(m_mutex);
    m_plugins.run(plugin_id, boost::bind(&PluginType::setConfig, _1,
                                         boost::cref(*vocab_ptr), config_ptr));
    ConfigManager::setPluginConfig(m_plugin_element, plugin_id, config_ptr);
    
    // unlock class mutex to prevent deadlock
    plugins_lock.unlock();

    // send notifications
    PION_LOG_DEBUG(m_logger, "Updated " << m_plugin_element << " configuration (" << plugin_id << ')');
    boost::mutex::scoped_lock signal_lock(m_signal_mutex);
    m_signal_plugins_updated();
}

template <typename PluginType>
inline std::string PluginConfig<PluginType>::addPlugin(const xmlNodePtr config_ptr)
{
    // make sure that the plug-in configuration file is open
    if (! configIsOpen())
        throw ConfigNotOpenException(getConfigFile());

    // find the plug-in type within the XML configuration
    std::string plugin_type;
    const std::string plugin_id(ConfigManager::createUUID());
    if (config_ptr == NULL || ! getConfigOption(PLUGIN_ELEMENT_NAME, plugin_type, config_ptr))
        throw EmptyPluginElementException(plugin_id);
    
    // create the new plug-in and add it to the config file
    boost::mutex::scoped_lock plugins_lock(m_mutex);
    addPluginNoLock(plugin_id, plugin_type, config_ptr);
    addPluginConfig(m_plugin_element, plugin_id, plugin_type, config_ptr);
    
    // unlock class mutex to prevent deadlock
    plugins_lock.unlock();

    // send notifications
    PION_LOG_DEBUG(m_logger, "Loaded " << m_plugin_element << " (" << plugin_type << "): " << plugin_id);
    boost::mutex::scoped_lock signal_lock(m_signal_mutex);
    m_signal_plugins_updated();
    signal_lock.unlock();
    
    // return the plug-in's (new) identifier
    return plugin_id;
}

template <typename PluginType>
inline void PluginConfig<PluginType>::removePlugin(const std::string& plugin_id)
{
    // make sure that the plug-in configuration file is open
    if (! configIsOpen())
        throw ConfigNotOpenException(getConfigFile());

    // first store a smart pointer to the shared library code
    // this guarantees it will not be released until after the updated signal
    // has been called, and all users of these types of plugins have released them
    boost::mutex::scoped_lock plugins_lock(m_mutex);
    PionPluginPtr<PluginType> plugin_lib_ptr(m_plugins.getLibPtr(plugin_id));

    // remove it from memory and the configuration file
    m_plugins.remove(plugin_id);
    removePluginConfig(m_plugin_element, plugin_id);
    
    // unlock class mutex to prevent deadlock
    plugins_lock.unlock();

    // send notifications
    PION_LOG_DEBUG(m_logger, "Removed " << m_plugin_element << ": " << plugin_id);
    boost::mutex::scoped_lock signal_lock(m_signal_mutex);
    m_signal_plugins_updated();
}


}   // end namespace platform
}   // end namespace pion

#endif

---