platform/server/PlatformConfig.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_PLATFORMCONFIG_HEADER__
#define __PION_PLATFORMCONFIG_HEADER__

#include <string>
#include <vector>
#include <libxml/tree.h>
#include <boost/cstdint.hpp>
#include <boost/thread/mutex.hpp>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>
#include <pion/platform/ConfigManager.hpp>
#include <pion/platform/VocabularyManager.hpp>
#include <pion/platform/ReactionEngine.hpp>
#include <pion/platform/CodecFactory.hpp>
#include <pion/platform/ProtocolFactory.hpp>
#include <pion/platform/DatabaseManager.hpp>
#include "ServiceManager.hpp"
#include "UserManager.hpp"


namespace pion {        // begin namespace pion
namespace server {      // begin namespace server (Pion Server)


class PION_SERVER_API PlatformConfig :
    public pion::platform::ConfigManager
{
public:
    
    class MissingVocabularyConfigException : public PionException {
    public:
        MissingVocabularyConfigException(const std::string& config_file)
            : PionException("Platform configuration file does not define a Vocabulary configuration file: ", config_file) {}
    };
    
    class MissingCodecConfigException : public PionException {
    public:
        MissingCodecConfigException(const std::string& config_file)
            : PionException("Platform configuration file does not define a Codec configuration file: ", config_file) {}
    };
    
    class MissingProtocolConfigException : public PionException {
    public:
        MissingProtocolConfigException(const std::string& config_file)
            : PionException("Platform configuration file does not define a Protocol configuration file: ", config_file) {}
    };
    
    class MissingDatabaseConfigException : public PionException {
    public:
        MissingDatabaseConfigException(const std::string& config_file)
            : PionException("Platform configuration file does not define a Database configuration file: ", config_file) {}
    };
    
    class MissingReactorConfigException : public PionException {
    public:
        MissingReactorConfigException(const std::string& config_file)
            : PionException("Platform configuration file does not define a Reactor configuration file: ", config_file) {}
    };
    
    class MissingServiceConfigException : public PionException {
    public:
        MissingServiceConfigException(const std::string& config_file)
            : PionException("Platform configuration file does not define a Service configuration file: ", config_file) {}
    };
    
    class MissingUserConfigException : public PionException {
    public:
        MissingUserConfigException(const std::string& config_file)
            : PionException("Platform configuration file does not define a User configuration file: ", config_file) {}
    };
    
    class EmptyPluginPathException : public PionException {
    public:
        EmptyPluginPathException(const std::string& config_file)
            : PionException("Platform configuration includes an empty plug-in path: ", config_file) {}
    };

    class MissingDataDirectoryException : public PionException {
    public:
        MissingDataDirectoryException(const std::string& config_file)
            : PionException("Platform configuration file does not define a data directory: ", config_file) {}
    };
    
    class DirectoryNotFoundException : public PionException {
    public:
        DirectoryNotFoundException(const std::string& dir)
            : PionException("Platform configuration DataDirectory not found: ", dir) {}
    };
    
    class NotADirectoryException : public PionException {
    public:
        NotADirectoryException(const std::string& dir)
            : PionException("Platform configuration DataDirectory is not a directory: ", dir) {}
    };
    
    PlatformConfig(void);
    
    virtual ~PlatformConfig() {
        // make sure that the ReactionEngine stops before the ServiceManager
        // This will cleanly terminate any temporary Reactor connections first
        m_reaction_engine.stop();
        // stop threads and release service plugins in ServiceManager because
        // they use other plugins types; otherwise, code referenced by them
        // may be released first which can potentitally cause crashes
        m_service_mgr.shutdown();
        // release reactor plugins next for same reasons
        m_reaction_engine.shutdown();
    }
    
    virtual void openConfigFile(void);
    
    virtual void writeConfigXML(std::ostream& out) const;

    inline pion::platform::VocabularyManager& getVocabularyManager(void) { return m_vocab_mgr; }
    
    inline pion::platform::CodecFactory& getCodecFactory(void) { return m_codec_factory; }
    
    inline pion::platform::ProtocolFactory& getProtocolFactory(void) { return m_protocol_factory; }

    inline pion::platform::DatabaseManager& getDatabaseManager(void) { return m_database_mgr; }

    inline pion::platform::ReactionEngine& getReactionEngine(void) { return m_reaction_engine; }

    inline const pion::platform::ReactionEngine& getReactionEngine(void) const { return m_reaction_engine; }

    inline ServiceManager& getServiceManager(void) { return m_service_mgr; }

    inline const UserManagerPtr getUserManagerPtr(void) const { return m_user_mgr_ptr; }

    inline const std::string& getLogConfigFile(void) const { return m_log_config_file; }

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

    
private:

    boost::int32_t findSystemId(const std::string& name, const std::string& file);

    void parseUser(void);
    
    void parseGroup(void);


    static const std::string        DEFAULT_CONFIG_FILE;

    static const std::string        VERSION_ELEMENT_NAME;

    static const std::string        PLATFORM_CONFIG_ELEMENT_NAME;

    static const std::string        VOCABULARY_CONFIG_ELEMENT_NAME;
    
    static const std::string        CODEC_CONFIG_ELEMENT_NAME;
    
    static const std::string        PROTOCOL_CONFIG_ELEMENT_NAME;
    
    static const std::string        DATABASE_CONFIG_ELEMENT_NAME;
    
    static const std::string        REACTOR_CONFIG_ELEMENT_NAME;
    
    static const std::string        SERVICE_CONFIG_ELEMENT_NAME;

    static const std::string        USER_CONFIG_ELEMENT_NAME;

    static const std::string        LOG_CONFIG_ELEMENT_NAME;

    static const std::string        VOCABULARY_PATH_ELEMENT_NAME;
    
    static const std::string        PLUGIN_PATH_ELEMENT_NAME;

    static const std::string        DATA_DIRECTORY_ELEMENT_NAME;

    static const std::string        DEBUG_MODE_ELEMENT_NAME;

    static const std::string        REACTION_ENGINE_ELEMENT_NAME;
    
    static const std::string        MAX_THREADS_ELEMENT_NAME;

    static const std::string        MULTITHREAD_BRANCHES_ELEMENT_NAME;

    static const std::string        USER_ELEMENT_NAME;

    static const std::string        GROUP_ELEMENT_NAME;

    
    pion::platform::VocabularyManager       m_vocab_mgr;
    
    pion::platform::CodecFactory            m_codec_factory;
    
    pion::platform::ProtocolFactory         m_protocol_factory;

    pion::platform::DatabaseManager         m_database_mgr;
    
    pion::platform::ReactionEngine          m_reaction_engine;
    
    ServiceManager                          m_service_mgr;

    UserManagerPtr                          m_user_mgr_ptr;

    std::string                             m_log_config_file;
    
    std::string                             m_data_directory;
    
    std::string                             m_user_name;

    std::string                             m_group_name;

    boost::int32_t                          m_user_id;

    boost::int32_t                          m_group_id;

    std::vector<std::string>                m_plugin_paths;
    
    bool                                    m_debug_mode;
    
    mutable boost::mutex                    m_mutex;    
};


}   // end namespace server
}   // end namespace pion

#endif

---