platform/include/pion/platform/DatabaseManager.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_DATABASEMANAGER_HEADER__
#define __PION_DATABASEMANAGER_HEADER__

#include <string>
#include <libxml/tree.h>
#include <pion/PionConfig.hpp>
#include <pion/PionException.hpp>
#include <pion/platform/Database.hpp>
#include <pion/platform/PluginConfig.hpp>


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

class PION_PLATFORM_API DatabaseManager :
    public PluginConfig<Database>
{
public:

    class DatabaseNotFoundException : public PionException {
    public:
        DatabaseNotFoundException(const std::string& database_id)
            : PionException("No databases found for identifier: ", database_id) {}
    };
    

    virtual ~DatabaseManager() {}
    
    explicit DatabaseManager(const VocabularyManager& vocab_mgr);

    DatabasePtr getDatabase(const std::string& database_id);
        
    void setDatabaseConfig(const std::string& database_id,
                           const xmlNodePtr config_ptr);
    
    std::string addDatabase(const xmlNodePtr config_ptr);
    
    void removeDatabase(const std::string& database_id);

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

    void writeDatabaseEnginesXML(std::ostream& out);

    xmlDocPtr getDatabaseEngineConfig(const std::string& database_engine, xmlNodePtr& config_detail_ptr);

    std::string getPermissionType(void) const { return DATABASES_PERMISSION_TYPE; }


protected:
    
    virtual void addPluginNoLock(const std::string& plugin_id,
                                 const std::string& plugin_name,
                                 const xmlNodePtr config_ptr)
    {
        try {
            Database *new_plugin_ptr = m_plugins.load(plugin_id, plugin_name);
            new_plugin_ptr->setId(plugin_id);
            new_plugin_ptr->setDatabaseManager(*this);
            if (config_ptr != NULL) {
                VocabularyPtr vocab_ptr(m_vocab_mgr.getVocabulary());
                new_plugin_ptr->setConfig(*vocab_ptr, config_ptr);
            }
        } catch (PionPlugin::PluginNotFoundException&) {
            throw;
        } catch (std::exception& e) {
            throw PluginException(e.what());
        }
    }
    
    
private:
    
    static const std::string        DEFAULT_CONFIG_FILE;

    static const std::string        DATABASE_ELEMENT_NAME;

    static const std::string        DATABASES_PERMISSION_TYPE;

    static const std::string        TEMPLATE_FILE;

    static const std::string        DBENGINES_ROOT_ELEMENT_NAME;
    static const std::string        TEMPLATE_ELEMENT_NAME;
    static const std::string        ENGINE_ELEMENT_NAME;

    static const std::string        DEFAULT_DATABASE_TYPE;
};


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

#endif

---