base_config_backend_pool.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_POOL_H
#define BASE_CONFIG_BACKEND_POOL_H
 
#include <cc/data.h>
#include <config_backend/base_config_backend.h>
#include <database/backend_selector.h>
#include <database/database_connection.h>
#include <database/db_exceptions.h>
#include <database/server_selector.h>
#include <functional>
#include <list>
#include <string>
 
namespace isc {
namespace cb {
 
 
template<typename ConfigBackendType>
class BaseConfigBackendPool {
public:
 
    typedef boost::shared_ptr<ConfigBackendType> ConfigBackendTypePtr;
 
    virtual ~BaseConfigBackendPool() { }
 
    void addBackend(ConfigBackendTypePtr backend) {
        backends_.push_back(backend);
    }
 
    void delAllBackends() {
        backends_.clear();
    }
 
    void delAllBackends(const std::string& db_type) {
        typename std::list<ConfigBackendTypePtr>::iterator backend = backends_.begin();
 
        while (backend != backends_.end()) {
            if ((*backend)->getType() == db_type) {
                backend = backends_.erase(backend);
            } else {
                ++backend;
            }
        }
    }
 
    bool del(const std::string& db_type, const std::string& dbaccess,
             bool if_unusable) {
        isc::db::DatabaseConnection::ParameterMap parameters =
            isc::db::DatabaseConnection::parse(dbaccess);
        bool deleted = false;
        if (if_unusable) {
            deleted = true;
        }
 
        typename std::list<ConfigBackendTypePtr>::iterator backend = backends_.begin();
 
        while (backend != backends_.end()) {
            if ((*backend)->getType() != db_type || (*backend)->getParameters() != parameters) {
                ++backend;
            } else if (if_unusable && (!(*backend)->isUnusable())) {
                deleted = false;
                ++backend;
            } else {
                backends_.erase(backend);
                return (true);
            }
        }
        return (deleted);
    }
 
protected:
 
    template<typename PropertyType, typename... FnPtrArgs, typename... Args>
    void getPropertyPtrConst(PropertyType (ConfigBackendType::*MethodPointer)
                             (const db::ServerSelector&, FnPtrArgs...) const,
                             const db::BackendSelector& backend_selector,
                             const db::ServerSelector& server_selector,
                             PropertyType& property,
                             Args... input) const {
 
        // If no particular backend is selected, call each backend and return
        // the first non-null (non zero) value.
        if (backend_selector.amUnspecified()) {
            for (auto const& backend : backends_) {
                property = ((*backend).*MethodPointer)(server_selector, input...);
                if (property) {
                    break;
                }
            }
 
        } else {
            // Backend selected, find the one that matches selection.
            auto backends = selectBackends(backend_selector);
            if (!backends.empty()) {
                for (auto const& backend : backends) {
                    property = ((*backend).*MethodPointer)(server_selector, input...);
                    if (property) {
                        break;
                    }
                }
 
            } else {
                isc_throw(db::NoSuchDatabase, "no such database found for selector: "
                          << backend_selector.toText());
            }
        }
    }
 
    template<typename PropertyType, typename... FnPtrArgs, typename... Args>
    void getBackendPropertyPtrConst(PropertyType (ConfigBackendType::*MethodPointer)
                                    (FnPtrArgs...) const,
                                    const db::BackendSelector& backend_selector,
                                    PropertyType& property,
                                    Args... input) const {
        auto backends = selectBackends(backend_selector);
        if (backends.empty()) {
            isc_throw(db::NoSuchDatabase, "no such database found for selector: "
                      << backend_selector.toText());
 
        } else if (backends.size() > 1) {
            isc_throw(db::AmbiguousDatabase, "more than one database found for "
                      "selector: " << backend_selector.toText());
        }
 
        property = ((*(*(backends.begin())).*MethodPointer)(input...));
    }
 
    template<typename PropertyCollectionType, typename... FnPtrArgs, typename... Args>
    void getMultiplePropertiesConst(PropertyCollectionType (ConfigBackendType::*MethodPointer)
                                    (const db::ServerSelector&, FnPtrArgs...) const,
                                    const db::BackendSelector& backend_selector,
                                    const db::ServerSelector& server_selector,
                                    PropertyCollectionType& properties,
                                    Args... input) const {
        if (backend_selector.amUnspecified()) {
            for (auto const& backend : backends_) {
                properties = ((*backend).*MethodPointer)(server_selector, input...);
                if (!properties.empty()) {
                    break;
                }
            }
 
        } else {
            auto backends = selectBackends(backend_selector);
            if (!backends.empty()) {
                for (auto const& backend : backends) {
                    properties = ((*backend).*MethodPointer)(server_selector, input...);
                    if (!properties.empty()) {
                        break;
                    }
                }
 
            } else {
                isc_throw(db::NoSuchDatabase, "no such database found for selector: "
                          << backend_selector.toText());
            }
        }
    }
 
    template<typename PropertyCollectionType>
    void getAllPropertiesConst(PropertyCollectionType (ConfigBackendType::*MethodPointer)
                               (const db::ServerSelector&) const,
                               const db::BackendSelector& backend_selector,
                               const db::ServerSelector& server_selector,
                               PropertyCollectionType& properties) const {
        if (backend_selector.amUnspecified()) {
            for (auto const& backend : backends_) {
                properties = ((*backend).*MethodPointer)(server_selector);
                if (!properties.empty()) {
                    break;
                }
            }
 
        } else {
            auto backends = selectBackends(backend_selector);
            if (!backends.empty()) {
                for (auto const& backend : backends) {
                    properties = ((*backend).*MethodPointer)(server_selector);
                    if (!properties.empty()) {
                        break;
                    }
                }
 
            } else {
                isc_throw(db::NoSuchDatabase, "no such database found for selector: "
                          << backend_selector.toText());
            }
        }
    }
 
    template<typename PropertyCollectionType>
    void getAllBackendPropertiesConst(PropertyCollectionType (ConfigBackendType::*MethodPointer)() const,
                                      const db::BackendSelector& backend_selector,
                                      PropertyCollectionType& properties) const {
        auto backends = selectBackends(backend_selector);
        if (backends.empty()) {
            isc_throw(db::NoSuchDatabase, "no such database found for selector: "
                      << backend_selector.toText());
 
        } else if (backends.size() > 1) {
            isc_throw(db::AmbiguousDatabase, "more than one database found for "
                      "selector: " << backend_selector.toText());
        }
 
        properties = (*(*(backends.begin())).*MethodPointer)();
    }
 
    template<typename ReturnValue, typename... FnPtrArgs, typename... Args>
    ReturnValue createUpdateDeleteProperty(ReturnValue (ConfigBackendType::*MethodPointer)
                                           (const db::ServerSelector&, FnPtrArgs...),
                                           const db::BackendSelector& backend_selector,
                                           const db::ServerSelector& server_selector,
                                           Args... input) {
        auto backends = selectBackends(backend_selector);
        if (backends.empty()) {
            isc_throw(db::NoSuchDatabase, "no such database found for selector: "
                      << backend_selector.toText());
 
        } else if (backends.size() > 1) {
            isc_throw(db::AmbiguousDatabase, "more than one database found for "
                      "selector: " << backend_selector.toText());
        }
 
        return ((*(*(backends.begin())).*MethodPointer)(server_selector, input...));
    }
 
    template<typename ReturnValue, typename... FnPtrArgs, typename... Args>
    ReturnValue createUpdateDeleteBackendProperty(ReturnValue (ConfigBackendType::*MethodPointer)
                                                  (FnPtrArgs...),
                                                  const db::BackendSelector& backend_selector,
                                                  Args... input) {
        auto backends = selectBackends(backend_selector);
        if (backends.empty()) {
            isc_throw(db::NoSuchDatabase, "no such database found for selector: "
                      << backend_selector.toText());
 
        } else if (backends.size() > 1) {
            isc_throw(db::AmbiguousDatabase, "more than one database found for "
                      "selector: " << backend_selector.toText());
        }
 
        return ((*(*(backends.begin())).*MethodPointer)(input...));
    }
 
    std::list<ConfigBackendTypePtr>
    selectBackends(const db::BackendSelector& backend_selector) const {
 
        std::list<ConfigBackendTypePtr> selected;
 
        // In case there is only one backend and the caller hasn't specified
        // any particular backend, simply return it.
        if ((backends_.size() == 1) && backend_selector.amUnspecified()) {
            selected.push_back(*backends_.begin());
            return (selected);
        }
 
        // For other cases we return empty list.
        if (backends_.empty() || backend_selector.amUnspecified()) {
            return (selected);
        }
 
        // Go over all backends.
        for (auto const& backend : backends_) {
            // If backend type is specified and it is not matching,
            // do not select this backend.
            if ((backend_selector.getBackendType() != db::BackendSelector::Type::UNSPEC) &&
                (backend_selector.getBackendType() !=
                 db::BackendSelector::stringToBackendType(backend->getType()))) {
                continue;
            }
 
            // If the host has been specified by the backend's host is not
            // matching, do not select this backend.
            if ((!backend_selector.getBackendHost().empty()) &&
                (backend_selector.getBackendHost() != backend->getHost())) {
                continue;
            }
 
            // If the port has been specified by the backend's port is not
            // matching, do not select this backend.
            if ((backend_selector.getBackendPort() != 0) &&
                (backend_selector.getBackendPort() != backend->getPort())) {
                continue;
            }
 
            // Passed all checks, so the backend is matching. Add it to the list.
            selected.push_back(backend);
        }
 
        return (selected);
    }
 
    std::list<ConfigBackendTypePtr> backends_;
};
 
} // end of namespace isc::cb
} // end of namespace isc
 
#endif // BASE_CONFIG_BACKEND_POOL_H