Kea: cfg_db_access.cc Source File

| Kea 2.2.0

cfg_db_access.cc
Go to the documentation of this file.
1// Copyright (C) 2016-2020 Internet Systems Consortium, Inc. ("ISC")
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7#include <config.h>
8#include <dhcpsrv/cfg_db_access.h>
9#include <dhcpsrv/db_type.h>
10#include <dhcpsrv/host_data_source_factory.h>
11#include <dhcpsrv/host_mgr.h>
12#include <dhcpsrv/lease_mgr_factory.h>
13#include <boost/algorithm/string.hpp>
14#include <boost/foreach.hpp>
15#include <boost/lexical_cast.hpp>
16#include <sstream>
17#include <vector>
18
19using namespace isc::data;
20
21namespace isc {
22namespace dhcp {
23
24CfgDbAccess::CfgDbAccess()
25 : appended_parameters_(), lease_db_access_("type=memfile"),
26 host_db_access_(), ip_reservations_unique_(true) {
27}
28
29std::string
30CfgDbAccess::getLeaseDbAccessString() const {
31 return (getAccessString(lease_db_access_));
32}
33
34
35std::string
36CfgDbAccess::getHostDbAccessString() const {
37 if (host_db_access_.empty()) {
38 return ("");
39 } else {
40 return (getAccessString(host_db_access_.front()));
41 }
42}
43
44std::list<std::string>
45CfgDbAccess::getHostDbAccessStringList() const {
46 std::list<std::string> ret;
47 for (const std::string& dbaccess : host_db_access_) {
48 if (!dbaccess.empty()) {
49 ret.push_back(getAccessString(dbaccess));
50 }
51 }
52 return (ret);
53}
54
55void
56CfgDbAccess::createManagers() const {
57 // Recreate lease manager.
58 LeaseMgrFactory::destroy();
59 LeaseMgrFactory::create(getLeaseDbAccessString());
60
61 // Recreate host data source.
62 HostMgr::create();
63
64 // Restore the host cache.
65 if (HostDataSourceFactory::registeredFactory("cache")) {
66 HostMgr::addBackend("type=cache");
67 }
68
69 // Add database backends.
70 std::list<std::string> host_db_access_list = getHostDbAccessStringList();
71 for (std::string& hds : host_db_access_list) {
72 HostMgr::addBackend(hds);
73 }
74
75 // Check for a host cache.
76 HostMgr::checkCacheBackend(true);
77
78 // Populate the ip-reservations-unique global setting to HostMgr.
79 // This operation may fail if any of the host backends does not support
80 // the new setting. We throw an exception here to signal configuration
81 // error. The exception does not contain the backend name but the called
82 // function in HostMgr logs a warning message that contains the name of
83 // the backend.
84 if (!HostMgr::instance().setIPReservationsUnique(ip_reservations_unique_)) {
85 isc_throw(InvalidOperation, "unable to configure the server to allow "
86 "non unique IP reservations (ip-reservations-unique=false) "
87 "because some host backends in use do not support this "
88 "setting");
89 }
90}
91
92std::string
93CfgDbAccess::getAccessString(const std::string& access_string) const {
94 std::ostringstream s;
95 s << access_string;
96 // Only append additional parameters if any parameters are specified
97 // in a configuration. For host database, no parameters mean that
98 // database access is disabled and thus we don't want to append any
99 // parameters.
100 if ((s.tellp() != std::streampos(0)) && (!appended_parameters_.empty())) {
101 s << " " << appended_parameters_;
102 }
103
104 return (s.str());
105}
106
107} // end of isc::dhcp namespace
108} // end of isc namespace
cfg_db_access.h
isc::InvalidOperation
A generic exception that is thrown if a function is called in a prohibited way.
Definition: exceptions/exceptions.h:143
isc::dhcp::CfgDbAccess::ip_reservations_unique_
bool ip_reservations_unique_
Holds the setting whether IP reservations should be unique or can be non-unique.
Definition: cfg_db_access.h:126
isc::dhcp::CfgDbAccess::getAccessString
std::string getAccessString(const std::string &access_string) const
Returns lease or host database access string.
Definition: cfg_db_access.cc:93
isc::dhcp::CfgDbAccess::createManagers
void createManagers() const
Creates instance of lease manager and host data sources according to the configuration specified.
Definition: cfg_db_access.cc:56
isc::dhcp::CfgDbAccess::getHostDbAccessString
std::string getHostDbAccessString() const
Retrieves host database access string.
Definition: cfg_db_access.cc:36
isc::dhcp::CfgDbAccess::host_db_access_
std::list< std::string > host_db_access_
Holds host database access strings.
Definition: cfg_db_access.h:122
isc::dhcp::CfgDbAccess::appended_parameters_
std::string appended_parameters_
Parameters to be appended to the database access strings.
Definition: cfg_db_access.h:116
isc::dhcp::CfgDbAccess::CfgDbAccess
CfgDbAccess()
Constructor.
Definition: cfg_db_access.cc:24
isc::dhcp::CfgDbAccess::getHostDbAccessStringList
std::list< std::string > getHostDbAccessStringList() const
Retrieves host database access string.
Definition: cfg_db_access.cc:45
isc::dhcp::CfgDbAccess::setIPReservationsUnique
void setIPReservationsUnique(const bool unique)
Modifies the setting imposing whether the IP reservations are unique or can be non unique.
Definition: cfg_db_access.h:90
isc::dhcp::CfgDbAccess::lease_db_access_
std::string lease_db_access_
Holds lease database access string.
Definition: cfg_db_access.h:119
isc::dhcp::CfgDbAccess::getLeaseDbAccessString
std::string getLeaseDbAccessString() const
Retrieves lease database access string.
Definition: cfg_db_access.cc:30
isc::dhcp::HostDataSourceFactory::registeredFactory
static bool registeredFactory(const std::string &db_type)
Check if a host data source factory was registered.
Definition: host_data_source_factory.cc:162
isc::dhcp::HostMgr::create
static void create()
Creates new instance of the HostMgr.
Definition: host_mgr.cc:43
isc::dhcp::HostMgr::addBackend
static void addBackend(const std::string &access)
Add an alternate host backend (aka host data source).
Definition: host_mgr.cc:48
isc::dhcp::HostMgr::checkCacheBackend
static bool checkCacheBackend(bool logging=false)
Check for the cache host backend.
Definition: host_mgr.cc:83
isc::dhcp::HostMgr::instance
static HostMgr & instance()
Returns a sole instance of the HostMgr.
Definition: host_mgr.cc:105
isc::dhcp::LeaseMgrFactory::create
static void create(const std::string &dbaccess)
Create an instance of a lease manager.
Definition: lease_mgr_factory.cc:42
isc::dhcp::LeaseMgrFactory::destroy
static void destroy()
Destroy lease manager.
Definition: lease_mgr_factory.cc:94
db_type.h
isc_throw
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
Definition: exceptions/exceptions.h:210
host_data_source_factory.h
host_mgr.h
lease_mgr_factory.h
isc::data
Definition: base_stamped_element.cc:12
isc
Defines the logger used by the top-level component of kea-lfc.
Definition: agent_parser.cc:143