platform/server/ServiceManager.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_SERVICEMANAGER_HEADER__
#define __PION_SERVICEMANAGER_HEADER__

#include <list>
#include <string>
#include <boost/thread/mutex.hpp>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>
#include <pion/PionScheduler.hpp>
#include <pion/PluginManager.hpp>
#include <pion/net/HTTPServer.hpp>
#include <pion/net/WebService.hpp>
#include <pion/platform/ConfigManager.hpp>
#include "PlatformService.hpp"
#include <pion/platform/PluginConfig.hpp>


namespace pion {        // begin namespace pion
namespace server {      // begin namespace server (Pion Server)
    
    
// forward declarations to avoid header dependencies
class PlatformConfig;
    

class PION_SERVER_API ServiceManager :
    public pion::platform::PluginConfig<PlatformService>
{
public:
    
    class EmptyServerIdException : public PionException {
    public:
        EmptyServerIdException(const std::string& config_file)
            : PionException("Service configuration file includes a Server without a unique identifier: ", config_file) {}
    };

    class EmptyServiceIdException : public PionException {
    public:
        EmptyServiceIdException(const std::string& server_id)
            : PionException("Server configuration includes a Service without a unique identifier: ", server_id) {}
    };
    
    class EmptyServicePluginTypeException : public PionException {
    public:
        EmptyServicePluginTypeException(const std::string& service_id)
            : PionException("Service configuration does not define a plug-in type: ", service_id) {}
    };
    
    class EmptyServiceResourceException : public PionException {
    public:
        EmptyServiceResourceException(const std::string& service_id)
            : PionException("Service configuration does not define a resource: ", service_id) {}
    };

    class EmptyServiceServerIdException : public PionException {
    public:
        EmptyServiceServerIdException(const std::string& config_file)
            : PionException("Service configuration file includes a Service without a Server identifier: ", config_file) {}
    };

    class EmptyOptionNameException : public PionException {
    public:
        EmptyOptionNameException(const std::string& service_id)
            : PionException("Service configuration option does not define a name: ", service_id) {}
    };
    
    class MissingPortException : public PionException {
    public:
        MissingPortException(const std::string& server_id)
            : PionException("Server configuration does not define a port number: ", server_id) {}
    };

    class UnknownAuthTypeException : public PionException {
    public:
        UnknownAuthTypeException(const std::string& server_id)
            : PionException("Server configuration has unknown AuthType parameter: ", server_id) {}
    };

    class SSLKeyException : public PionException {
    public:
        SSLKeyException(const std::string& key_file)
            : PionException("Unable to load SSL key file: ", key_file) {}
    };

    class RedirectMissingSourceException : public PionException {
    public:
        RedirectMissingSourceException(const std::string& server_id)
            : PionException("Service configuration Redirect element does not specify a Source: ", server_id) {}
    };

    class RedirectMissingTargetException : public PionException {
    public:
        RedirectMissingTargetException(const std::string& server_id)
            : PionException("Service configuration Redirect element does not specify a Target: ", server_id) {}
    };

    class WebServiceException : public PionException {
    public:
        WebServiceException(const std::string& service_id, const std::string& error_msg)
            : PionException(std::string("Service (") + service_id,
                            std::string("): ") + error_msg)
        {}
    };

    class PlatformServiceNotFoundException : public PionException {
    public:
        PlatformServiceNotFoundException(const std::string& service_id)
            : PionException("No platform service found for identifier: ", service_id) {}
    };

    ServiceManager(const pion::platform::VocabularyManager& vocab_mgr, PlatformConfig& platform_config);
    
    virtual ~ServiceManager() { shutdown(); }
    
    void shutdown(void);
    
    virtual void openConfigFile(void);

    virtual void writeServersXML(std::ostream& out) const;
    
    bool writeServerXML(std::ostream& out, const std::string& server_id) const;

    template<typename WorkFunction>
    inline void post(WorkFunction work_func) { m_scheduler.getIOService().post(work_func); }
    
    inline boost::asio::io_service& getIOService(void) { return m_scheduler.getIOService(); }
    
    inline boost::uint32_t getNumThreads(void) const { return m_scheduler.getNumThreads(); }
    
    inline void setNumThreads(const boost::uint32_t n) { m_scheduler.setNumThreads(n); }
        
    void updateCodecs(void);

    void updateDatabases(void);

    void updateReactors(void);
    
    unsigned int getPort(void) const;

    std::string addPlatformService(const xmlNodePtr config_ptr);

    void removePlatformService(const std::string& service_id);

    static xmlNodePtr createPlatformServiceConfig(const char *buf, std::size_t len) {
        return ConfigManager::createResourceConfig(PLATFORM_SERVICE_ELEMENT_NAME, buf, len);
    }

protected:

    virtual void addPluginNoLock(const std::string& plugin_id,
                                 const std::string& plugin_name,
                                 const xmlNodePtr config_ptr)
    {
        try {
            PlatformService *new_plugin_ptr = m_plugins.load(plugin_id, plugin_name);
            new_plugin_ptr->setId(plugin_id);
            new_plugin_ptr->setServiceManager(*this);
            new_plugin_ptr->setPlatformConfig(m_platform_config);
            if (config_ptr != NULL) {
                pion::platform::VocabularyPtr vocab_ptr(m_vocab_mgr.getVocabulary());
                new_plugin_ptr->setConfig(*vocab_ptr, config_ptr);
            }

            pion::net::HTTPServerPtr server_ptr = m_servers[new_plugin_ptr->getServerId()];
            server_ptr->addResource(new_plugin_ptr->getResource(), boost::ref(*new_plugin_ptr));
        } catch (PionPlugin::PluginNotFoundException&) {
            throw;
        } catch (std::exception& e) {
            throw PluginException(e.what());
        }
    }

private:

    void getWebServiceConfig(xmlNodePtr service_node, const std::string& server_id,
                             std::string& service_id, std::string& plugin_type,
                             std::string& http_resource);
    
    static void handleServerError(pion::net::HTTPRequestPtr& http_request,
                                  pion::net::TCPConnectionPtr& tcp_conn,
                                  const std::string& error_msg);

    void addWebService(xmlNodePtr service_node, const std::string& server_id);

    
    typedef std::map<std::string, pion::net::HTTPServerPtr>     ServerMap;
    
    typedef PluginManager<pion::net::WebService>    WebServiceManager;
    
    typedef PluginManager<PlatformService>          PlatformServiceManager;
    
    
    static const boost::uint32_t    DEFAULT_NUM_THREADS;
    
    static const std::string        DEFAULT_CONFIG_FILE;

    static const std::string        SERVER_ELEMENT_NAME;

    static const std::string        WEB_SERVICE_ELEMENT_NAME;
    
    static const std::string        PLATFORM_SERVICE_ELEMENT_NAME;
    
    static const std::string        PORT_ELEMENT_NAME;

    static const std::string        SSL_KEY_ELEMENT_NAME;

    static const std::string        REDIRECT_ELEMENT_NAME;

    static const std::string        REDIRECT_SOURCE_ELEMENT_NAME;

    static const std::string        REDIRECT_TARGET_ELEMENT_NAME;

    static const std::string        WEB_SERVICE_RESOURCE_ELEMENT_NAME;

    static const std::string        WEB_SERVICE_SERVER_ELEMENT_NAME;

    static const std::string        OPTION_ELEMENT_NAME;
    
    static const std::string        AUTH_ELEMENT_NAME;
    
    static const std::string        AUTH_RESTRICT_ELEMENT_NAME;

    static const std::string        AUTH_PERMIT_ELEMENT_NAME;

    static const std::string        AUTH_TYPE_ELEMENT_NAME;

    static const std::string        AUTH_LOGIN_ELEMENT_NAME;

    static const std::string        AUTH_LOGOUT_ELEMENT_NAME;

    static const std::string        AUTH_REDIRECT_ELEMENT_NAME;

    static const std::string        NAME_ATTRIBUTE_NAME;

    PlatformConfig &                m_platform_config;
    
    PionSingleServiceScheduler      m_scheduler;

    ServerMap                       m_servers;

    WebServiceManager               m_web_services;

    mutable boost::mutex            m_mutex;
};


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

#endif

---