base_config_backend_mgr.h

Go to the documentation of this file.

// Copyright (C) 2018-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef BASE_CONFIG_BACKEND_MGR_H
#define BASE_CONFIG_BACKEND_MGR_H
 
#include <config_backend/base_config_backend.h>
#include <database/database_connection.h>
#include <database/backend_selector.h>
#include <database/db_log.h>
#include <database/db_messages.h>
#include <exceptions/exceptions.h>
#include <boost/shared_ptr.hpp>
#include <functional>
#include <map>
#include <string>
 
namespace isc {
namespace cb {
 
template<typename ConfigBackendPoolType>
class BaseConfigBackendMgr {
public:
 
    typedef boost::shared_ptr<ConfigBackendPoolType> ConfigBackendPoolPtr;
 
    typedef std::function<typename ConfigBackendPoolType::ConfigBackendTypePtr
                          (const db::DatabaseConnection::ParameterMap&)> Factory;
 
    BaseConfigBackendMgr()
        : factories_(), pool_(new ConfigBackendPoolType()) {
    }
 
    bool registerBackendFactory(const std::string& db_type,
                                const Factory& factory) {
        // Check if this backend has been already registered.
        if (factories_.count(db_type)) {
            return (false);
        }
 
        // Register the new backend.
        factories_.insert(std::make_pair(db_type, factory));
        return (true);
    }
 
    bool unregisterBackendFactory(const std::string& db_type) {
        // Look for it.
        auto index = factories_.find(db_type);
 
        // If it's there remove it
        if (index != factories_.end()) {
            factories_.erase(index);
            pool_->delAllBackends(db_type);
            return (true);
 
        }
 
        return (false);
    }
 
    void addBackend(const std::string& dbaccess) {
        // Parse the access string into a map of parameters.
        db::DatabaseConnection::ParameterMap parameters =
            db::DatabaseConnection::parse(dbaccess);
 
        // Get the database type to locate a factory function.
        db::DatabaseConnection::ParameterMap::iterator it = parameters.find("type");
        if (it == parameters.end()) {
            isc_throw(InvalidParameter, "Config backend specification lacks the "
                      "'type' keyword");
        }
 
        std::string db_type = it->second;
        auto index = factories_.find(db_type);
 
        // No match?
        if (index == factories_.end()) {
            if ((db_type == "mysql") || (db_type == "postgresql")) {
                std::string with = (db_type == "postgresql" ? "pgsql" : db_type);
                isc_throw(db::InvalidType, "The Kea server has not been compiled with "
                          "support for configuration database type: " << db_type
                          << ". Did you forget to use --with-"
                          << with << " during compilation or to load libdhcp_"
                          << with << " hook library?");
            }
            isc_throw(db::InvalidType, "The type of the configuration backend: '" <<
                      db_type << "' is not supported");
        }
 
        // Call the factory and push the pointer on sources.
        auto backend = index->second(parameters);
        if (!backend) {
            isc_throw(Unexpected, "Config database " << db_type <<
                      " factory returned NULL");
        }
 
        // Backend instance created successfully.
        pool_->addBackend(backend);
    }
 
    void delAllBackends() {
        pool_->delAllBackends();
    }
 
    bool delBackend(const std::string& db_type, const std::string& dbaccess,
                    bool if_unusable) {
        return (pool_->del(db_type, dbaccess, if_unusable));
    }
 
    ConfigBackendPoolPtr getPool() const {
        return (pool_);
    }
 
    void logRegistered() {
        std::stringstream txt;
 
        for (auto const& x : factories_) {
            if (!txt.str().empty()) {
                txt << " ";
            }
            txt << x.first;
        }
 
        LOG_INFO(isc::db::database_logger, isc::db::CONFIG_BACKENDS_REGISTERED)
            .arg(txt.str());
    }
 
protected:
 
    std::map<std::string, Factory> factories_;
 
    ConfigBackendPoolPtr pool_;
};
 
} // end of namespace isc::cb
} // end of namespace isc
 
#endif // BASE_CONFIG_BACKEND_MGR_H