[#28,!20] Moved backend and server selector classes to database library.

Author: msiodelski

src/lib/config_backend/base_config_backend.h

@@ -15,112 +15,6 @@
 namespace isc {
 namespace cb {
 
-/// @brief Server selector for associating objects in a database with
-/// specific servers.
-///
-/// Configuration information stored in the configuration backends can be
-/// associated with selected servers, all servers or no particular server.
-/// For example: a particular subnet definition in the database may be
-/// associated with one server or can be shared by multiple servers.
-/// In the latter case, a subnet may be associated with a subset of
-/// servers or all servers. An administrator may also add the
-/// configuration data into the database and do not associate this data
-/// with any patrticular server.
-///
-/// When fetching the configuration data from a databse or when storing
-/// data in the database there is a need to specify which servers this
-/// data is associated with. The @c ServerSelector class represents
-/// such associations.
-///
-/// It includes three modes of selection: UNASSIGNED, ALL and SUBSET and
-/// several factory functions making associations described above.
-///
-/// The @c ServerSelector class should be used in objects derived from
-/// @c BaseConfigBackendPool and in objects derived from
-/// @c BaseConfigBackend to indicate which servers the specific calls
-/// exposed by these objects refer to.
-class ServerSelector {
-public:
-
-    /// @brief Type of the server selection.
-    enum class Type {
-        UNASSIGNED,
-        ALL,
-        SUBSET
-    };
-
-    /// @brief Factory returning "unassigned" server selector.
-    static ServerSelector& UNASSIGNED() {
-        static ServerSelector selector(Type::UNASSIGNED);
-        return (selector);
-    }
-
-    /// @brief Factory returning "all servers" selector.
-    static ServerSelector& ALL() {
-        static ServerSelector selector(Type::ALL);
-        return (selector);
-    }
-
-    /// @brief Factory returning selector of one server.
-    ///
-    /// @param server_tag tag of the single server to be selected.
-    static ServerSelector& ONE(const std::string& server_tag) {
-        static ServerSelector selector(server_tag);
-        return (selector);
-    }
-
-    /// @brief Factory returning "multiple servers" selector.
-    ///
-    /// @param server_tags set of server tags to be selected.
-    static ServerSelector& MULTIPLE(const std::set<std::string>& server_tags) {
-        static ServerSelector selector(server_tags);
-        return (selector);
-    }
-
-    /// @brief Returns type of the selector.
-    Type getType() const {
-        return (type_);
-    }
-
-    /// @brief Returns tags associated with the selector.
-    ///
-    /// @return server tags for mutliple selections and for one server,
-    /// empty set for all servers and and unassigned.
-    std::set<std::string> getTags() const {
-        return (tags_);
-    }
-
-private:
-
-    /// @brief Constructor used for "unassigned" and "all" slection types.
-    ///
-    /// @param type selector type.
-    explicit ServerSelector(const Type& type)
-        : type_(type), tags_() {
-    }
-
-    /// @brief Constructor used for selecting a single server.
-    ///
-    /// @param server_tag tag of the server to be selected.
-    explicit ServerSelector(const std::string& server_tag)
-        : type_(Type::SUBSET), tags_() {
-        tags_.insert(server_tag);
-    }
-
-    /// @brief Constructor used for selecting multiple servers.
-    ///
-    /// @param server_tags set of server tags.
-    explicit ServerSelector(const std::set<std::string>& server_tags)
-        : type_(Type::SUBSET), tags_(server_tags) {
-    }
-
-    /// @brief Selection type used.
-    Type type_;
-
-    /// @brief Holds tags of explicitly selected servers.
-    std::set<std::string> tags_;
-};
-
 /// @brief Base class for server specific configuration backends.
 class BaseConfigBackend {
 public:

src/lib/config_backend/base_config_backend_pool.cc

@@ -5,148 +5,10 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 #include <config_backend/base_config_backend_pool.h>
-#include <exceptions/exceptions.h>
-#include <climits>
-#include <sstream>
-
-using namespace isc::data;
 
 namespace isc {
 namespace cb {
 
-BackendSelector::BackendSelector()
-    : backend_type_(BackendSelector::Type::UNSPEC),
-      host_(), port_(0) {
-}
-
-BackendSelector::BackendSelector(const Type& backend_type)
-    : backend_type_(backend_type),
-      host_(), port_(0) {
-}
-
-BackendSelector::BackendSelector(const std::string& host,
-                                             const uint16_t port)
-    : backend_type_(BackendSelector::Type::UNSPEC),
-      host_(host), port_(port) {
-    validate();
-}
-
-BackendSelector::BackendSelector(const data::ConstElementPtr& access_map)
-    : backend_type_(BackendSelector::Type::UNSPEC),
-      host_(), port_(0) {
-    if (access_map->getType() != Element::map) {
-        isc_throw(BadValue, "database access information must be a map");
-    }
-
-    ConstElementPtr t = access_map->get("type");
-    if (t) {
-        if (t->getType() != Element::string) {
-            isc_throw(BadValue, "'type' parameter must be a string");
-        }
-        backend_type_ = stringToBackendType(t->stringValue());
-    }
-
-    ConstElementPtr h = access_map->get("host");
-    if (h) {
-        if (h->getType() != Element::string) {
-            isc_throw(BadValue, "'host' parameter must be a string");
-        }
-        host_ = h->stringValue();
-    }
-
-    ConstElementPtr p = access_map->get("port");
-    if (p) {
-        if ((p->getType() != Element::integer) ||
-            (p->intValue() < 0) ||
-            (p->intValue() > std::numeric_limits<uint16_t>::max())) {
-            isc_throw(BadValue, "'port' parameter must be a number in range from 0 "
-                      "to " << std::numeric_limits<uint16_t>::max());
-        }
-        port_ = static_cast<uint16_t>(p->intValue());
-    }
-
-    validate();
-}
-
-const BackendSelector&
-BackendSelector::BackendSelector::UNSPEC() {
-    static BackendSelector selector;
-    return (selector);
-}
-
-bool
-BackendSelector::amUnspecified() const {
-    return ((backend_type_ == BackendSelector::Type::UNSPEC) &&
-            (host_.empty()) &&
-            (port_ == 0));
-}
-
-std::string
-BackendSelector::toText() const {
-    std::ostringstream s;
-    if (amUnspecified()) {
-        s << "unspecified";
-
-    } else {
-        if (backend_type_ != BackendSelector::Type::UNSPEC) {
-            s << "type=" << backendTypeToString(backend_type_) << ",";
-        }
-
-        if (!host_.empty()) {
-            s << "host=" << host_ << ",";
-
-            if (port_ > 0) {
-                s << "port=" << port_ << ",";
-            }
-        }
-    }
-
-    std::string text = s.str();
-    if ((!text.empty() && (text.back() == ','))) {
-        text.pop_back();
-    }
-
-    return (text);
-}
-
-BackendSelector::Type
-BackendSelector::stringToBackendType(const std::string& type) {
-    if (type == "mysql") {
-        return (BackendSelector::Type::MYSQL);
-
-    } else if (type == "pgsql") {
-        return (BackendSelector::Type::PGSQL);
-
-    } else if (type == "cql") {
-        return (BackendSelector::Type::CQL);
-
-    } else {
-        isc_throw(BadValue, "unsupported configuration backend type '" << type << "'");
-    }
-}
-
-std::string
-BackendSelector::backendTypeToString(const BackendSelector::Type& type) {
-    switch (type) {
-    case BackendSelector::Type::MYSQL:
-        return ("mysql");
-    case BackendSelector::Type::PGSQL:
-        return ("pgsql");
-    case BackendSelector::Type::CQL:
-        return ("cql");
-    default:
-        ;
-    }
-
-    return (std::string());
-}
-
-void
-BackendSelector::validate() const {
-    if ((port_ != 0) && (host_.empty())) {
-        isc_throw(BadValue, "'host' must be specified along with 'port' parameter");
-    }
-}
 
 
 } // end of namespace isc::cb