platform/include/pion/platform/ConfigManager.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_CONFIGMANAGER_HEADER__
#define __PION_CONFIGMANAGER_HEADER__

#include <string>
#include <libxml/tree.h>
#include <boost/noncopyable.hpp>
#include <boost/lexical_cast.hpp>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>
#include <pion/PionLogger.hpp>
#include <pion/PionId.hpp>


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


class PION_PLATFORM_API ConfigManager
    : public boost::noncopyable
{
public:

    class ConfigNotOpenException : public PionException {
    public:
        ConfigNotOpenException(const std::string& config_file)
            : PionException("Configuration file must be opened before making changes: ", config_file) {}
    };
    
    class ConfigAlreadyOpenException : public PionException {
    public:
        ConfigAlreadyOpenException(const std::string& file_name)
            : PionException("Configuration file is already open: ", file_name) {}
    };

    class ConfigFileExistsException : public PionException {
    public:
        ConfigFileExistsException(const std::string& file_name)
            : PionException("Configuration file already exists: ", file_name) {}
    };
    
    class MissingConfigFileException : public PionException {
    public:
        MissingConfigFileException(const std::string& file_name)
            : PionException("Unable to find configuration file: ", file_name) {}
    };

    class MissingRootElementException : public PionException {
    public:
        MissingRootElementException(const std::string& config_file)
        : PionException("Configuration file is missing the root config element: ", config_file) {}

        MissingRootElementException(const char* buffer)
        : PionException("Root config element not found in buffer: ", buffer) {}
    };

    class MissingResourceElementException : public PionException {
    public:
        MissingResourceElementException(const std::string& resource_name)
        : PionException("Could not find element for specified resource: ", resource_name) {}
    };

    class InitializeRootConfigException : public PionException {
    public:
        InitializeRootConfigException(const std::string& file_name)
            : PionException("Unable to initialize configuration file: ", file_name) {}
    };

    class ConfigFileVersionException : public PionException {
    public:
        ConfigFileVersionException(const std::string& file_name)
            : PionException("Incompatible configuration file (run pupgrade.py): ", file_name) {}
    };

    class WriteConfigException : public PionException {
    public:
        WriteConfigException(const std::string& file_name)
            : PionException("Unable to write config to file: ", file_name) {}
    };

    class UpdateConfigException : public PionException {
    public:
        UpdateConfigException(const std::string& element_name)
            : PionException("Unable to update configuration.  Element name: ", element_name) {}
    };

    class ReadConfigException : public PionException {
    public:
        ReadConfigException(const std::string& config_file)
        : PionException("Unable to read config file: ", config_file) {}
    };

    class BadXMLBufferException : public PionException {
    public:
        BadXMLBufferException(void)
        : PionException("NULL buffer pointer or buffer length is zero") {}
    };

    class XMLBufferParsingException : public PionException {
    public:
        XMLBufferParsingException(const char* buffer)
        : PionException("Unable to parse buffer: ", buffer) {}
    };

    class AddPluginConfigException : public PionException {
    public:
        AddPluginConfigException(const std::string& plugin_type)
            : PionException("Unable to add a plug-in to the configuration file: ", plugin_type) {}
    };
    
    class UpdatePluginConfigException : public PionException {
    public:
        UpdatePluginConfigException(const std::string& plugin_id)
            : PionException("Unable to update a plug-in in the configuration file: ", plugin_id) {}
    };
    
    class RemovePluginConfigException : public PionException {
    public:
        RemovePluginConfigException(const std::string& plugin_id)
            : PionException("Unable to remove a plug-in from the configuration file: ", plugin_id) {}
    };
    
    class EmptyPluginIdException : public PionException {
    public:
        EmptyPluginIdException(const std::string& config_file)
        : PionException("Configuration file includes a plug-in with an empty identifier: ", config_file) {}
    };
    
    class EmptyPluginElementException : public PionException {
    public:
        EmptyPluginElementException(const std::string& plugin_id)
            : PionException("Plug-in configuration does not contain a \"plugin\" element: ", plugin_id) {}
    };
    
    
    virtual ~ConfigManager() { closeConfigFile(); }
    
    virtual void createConfigFile(void);
    
    virtual void openConfigFile(void);

    static xmlDocPtr getConfigFromFile(const std::string& config_file, const std::string& root_element_name, xmlNodePtr& config_ptr, PionLogger& logger);

    inline void setConfigFile(const std::string& config_file) {
        m_config_file = config_file;
        resetDataDirectory();
    }
    
    inline const std::string& getConfigFile(void) const { return m_config_file; }

    inline bool configIsOpen(void) const { return m_config_doc_ptr != NULL; }
    
    inline void setLogger(PionLogger log_ptr) { m_logger = log_ptr; }
    
    inline PionLogger getLogger(void) { return m_logger; }
    
    inline void setDataDirectory(const std::string& dir) { m_data_directory = dir; }

    inline const std::string& getDataDirectory(void) const { return m_data_directory; }

    inline void resetDataDirectory(void) {
        m_data_directory = resolveRelativePath(m_config_file, "./");
    }

    inline void setDebugMode(bool b) { m_debug_mode = b; }

    inline bool getDebugMode(void) const { return m_debug_mode; }

    void removeConfigFile(void);
    
    virtual void writeConfigXML(std::ostream& out) const {
        writeConfigXML(out, m_config_node_ptr, true);
    }
    
    static void writeConfigXML(std::ostream& out,
                               xmlNodePtr config_node,
                               bool include_siblings = false);
    
    static void writeConfigXMLHeader(std::ostream& out);
    
    static void writeBeginPionConfigXML(std::ostream& out);
    
    static void writeEndPionConfigXML(std::ostream& out);
    
    static void writeBeginPionStatsXML(std::ostream& out);
    
    static void writeEndPionStatsXML(std::ostream& out);
    
    static std::string xml_encode(const std::string& str);
    
    inline std::string createUUID(void) { return m_id_gen().to_string(); }

    std::string createFilename(void);

    std::string createFilename(const std::string& file_path);
    
    static xmlNodePtr createPluginConfig(const std::string& plugin_type);
    
    static xmlNodePtr createResourceConfig(const std::string& resource_name,
                                           const char *buf, std::size_t len);
    
    static bool getNodeId(xmlNodePtr config_node, std::string& node_id);
    
    static xmlNodePtr findConfigNodeByName(const std::string& element_name,
                                           xmlNodePtr starting_node);
    
    static xmlNodePtr findConfigNodeByContent(const std::string& element_name,
                                              const std::string& content_value,
                                              xmlNodePtr starting_node);
    
    static xmlNodePtr findConfigNodeByAttr(const std::string& element_name,
                                           const std::string& attr_name,
                                           const std::string& attr_value,
                                           xmlNodePtr starting_node);
    
    static bool getConfigOption(const std::string& option_name,
                                std::string& option_value,
                                const xmlNodePtr starting_node);


    static bool getConfigOptionEmptyOk(const std::string& option_name,
                                std::string& option_value,
                                const xmlNodePtr starting_node);

    static std::string getAttribute(const char *name, const xmlNodePtr ptr);

    static std::string getAttribute(const std::string& name, const xmlNodePtr ptr)
    {
        return getAttribute(name.c_str(), ptr);
    }

    template <typename ValueType>
    static bool getConfigOption(const std::string& option_name,
                                ValueType& option_value,
                                const xmlNodePtr starting_node)
    {
        std::string value_str;
        if (getConfigOption(option_name, value_str, starting_node)) {
            option_value = boost::lexical_cast<ValueType>(value_str);
            return true;
        }
        return false;
    }

    template <typename ValueType>
    static bool getConfigOption(const std::string& option_name,
                                ValueType& option_value,
                                const ValueType& default_value,
                                const xmlNodePtr starting_node)
    {
        if (getConfigOption(option_name, option_value, starting_node))
            return true;
        option_value = default_value;
        return false;
    }
    
    static bool updateConfigOption(const std::string& option_name,
                                   const std::string& option_value,
                                   xmlNodePtr parent_node);

    static std::string resolveRelativePath(const std::string& base_path_to_file,
                                           const std::string& orig_path);
    
    inline std::string resolveRelativePath(const std::string& orig_path) const {
        return resolveRelativePath(getConfigFile(), orig_path);
    }

    std::string resolveRelativeDataPath(const std::string& orig_path);

    virtual bool creationAllowed(xmlNodePtr permission_config_ptr, xmlNodePtr config_ptr) const {
        // By default, permission is granted solely based on whether a Permission node of the appropriate type was found.
        return permission_config_ptr != NULL;
    }

    virtual bool updateAllowed(xmlNodePtr permission_config_ptr, const std::string& id, xmlNodePtr config_ptr) const {
        // By default, permission is granted solely based on whether a Permission node of the appropriate type was found.
        return permission_config_ptr != NULL;
    }

    virtual bool removalAllowed(xmlNodePtr permission_config_ptr, const std::string& id) const {
        // By default, permission is granted solely based on whether a Permission node of the appropriate type was found.
        return permission_config_ptr != NULL;
    }

    virtual bool accessAllowed(xmlNodePtr permission_config_ptr, const std::string& plugin_id) const {
        // By default, permission is granted solely based on whether a Permission node of the appropriate type was found.
        return permission_config_ptr != NULL;
    }

    virtual std::string getPermissionType(void) const { 
        // Returning an empty string means that UserManager::getPermissionNode() will always return NULL.
        // So, if this method is not overridden for a particular ConfigManager, then permission for that
        // ConfigManager will only be granted if the User has "Admin" permission.
        return "";
    }


protected:
    
    ConfigManager(const std::string& default_config_file)
        : m_logger(PION_GET_LOGGER("pion.platform.ConfigManager")),
        m_config_file(default_config_file), m_debug_mode(false),
        m_config_doc_ptr(NULL), m_config_node_ptr(NULL)
    {
        resetDataDirectory();
    }
    
    void closeConfigFile(void);
    
    void saveConfigFile(void);
    
    void backupConfigFile(void);
    
    void openPluginConfig(const std::string& plugin_name);
    
    bool setPluginConfig(xmlNodePtr plugin_node_ptr, xmlNodePtr config_ptr);
    
    void setPluginConfig(const std::string& plugin_name,
                         const std::string& plugin_id,
                         const xmlNodePtr config_ptr);
    
    void addPluginConfig(const std::string& plugin_name,
                         const std::string& plugin_id,
                         const std::string& plugin_type,
                         const xmlNodePtr config_ptr = NULL);
        
    void removePluginConfig(const std::string& plugin_name,
                            const std::string& plugin_id);

    virtual void addPluginNoLock(const std::string& plugin_id,
                                 const std::string& plugin_name,
                                 const xmlNodePtr config_ptr) {}

    
    static const std::string        XML_FILE_EXTENSION;
    
    static const std::string        BACKUP_FILE_EXTENSION;
    
    static const std::string        CONFIG_NAMESPACE_URL;

    static const std::string        ROOT_ELEMENT_NAME;
    
    static const std::string        STATS_ELEMENT_NAME;
    
    static const std::string        PLUGIN_ELEMENT_NAME;
    
    static const std::string        NAME_ELEMENT_NAME;
    
    static const std::string        COMMENT_ELEMENT_NAME;

    static const std::string        PION_VERSION_ATTRIBUTE_NAME;

    static const std::string        ID_ATTRIBUTE_NAME;

    
    PionLogger                      m_logger;
    
    PionIdGenerator                 m_id_gen;
    
    std::string                     m_config_file;
    
    std::string                     m_data_directory;

    bool                            m_debug_mode;

    xmlDocPtr                       m_config_doc_ptr;
    
    xmlNodePtr                      m_config_node_ptr;
};


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

#endif

---