17 #include <boost/algorithm/string.hpp> 18 #include <boost/foreach.hpp> 27 const time_t DatabaseConnection::MAX_DB_TIME = 2147483647;
30 DatabaseConnection::getParameter(
const std::string& name)
const {
31 ParameterMap::const_iterator param = parameters_.find(name);
32 if (param == parameters_.end()) {
35 return (param->second);
39 DatabaseConnection::parse(
const std::string& dbaccess) {
41 std::string dba = dbaccess;
49 std::string password_prefix =
"password='";
50 auto password_pos = dba.find(password_prefix);
51 if (password_pos != string::npos) {
53 auto password_end_pos = dba.find(
'\'', password_pos + password_prefix.length());
54 if (password_end_pos == string::npos) {
60 auto password = dba.substr(password_pos + password_prefix.length(),
61 password_end_pos - password_pos - password_prefix.length());
62 mapped_tokens.insert(make_pair(
"password", password));
67 dba.erase(password_pos, password_prefix.length() + password.length() + 2);
73 return (mapped_tokens);
81 boost::split(tokens, dba, boost::is_any_of(
string(
"\t ")));
82 BOOST_FOREACH(std::string token, tokens) {
83 size_t pos = token.find(
"=");
84 if (pos != string::npos) {
85 string name = token.substr(0, pos);
86 string value = token.substr(pos + 1);
87 mapped_tokens.insert(make_pair(name, value));
90 <<
", expected format is name=value");
93 }
catch (
const std::exception& ex) {
100 return (mapped_tokens);
104 DatabaseConnection::redactedAccessString(
const ParameterMap& parameters) {
108 for (DatabaseConnection::ParameterMap::const_iterator i = parameters.begin();
109 i != parameters.end(); ++i) {
112 if (!access.empty()) {
122 if (i->first == std::string(
"password")) {
133 DatabaseConnection::configuredReadOnly()
const {
134 std::string readonly_value =
"false";
136 readonly_value = getParameter(
"readonly");
137 boost::algorithm::to_lower(readonly_value);
143 if ((readonly_value !=
"false") && (readonly_value !=
"true")) {
145 <<
"' specified for boolean parameter 'readonly'");
148 return (readonly_value ==
"true");
152 DatabaseConnection::makeReconnectCtl(
const std::string& timer_name) {
153 string type =
"unknown";
154 unsigned int retries = 0;
155 unsigned int interval = 0;
159 type = getParameter(
"type");
164 std::string parm_str;
166 parm_str = getParameter(
"max-reconnect-tries");
167 retries = boost::lexical_cast<
unsigned int>(parm_str);
173 parm_str = getParameter(
"reconnect-wait-time");
174 interval = boost::lexical_cast<
unsigned int>(parm_str);
181 parm_str = getParameter(
"on-fail");
187 reconnect_ctl_ = boost::make_shared<ReconnectCtl>(type, timer_name, retries,
193 if (DatabaseConnection::db_lost_callback_) {
194 return (DatabaseConnection::db_lost_callback_(db_reconnect_ctl));
201 DatabaseConnection::invokeDbRecoveredCallback(
const ReconnectCtlPtr& db_reconnect_ctl) {
202 if (DatabaseConnection::db_recovered_callback_) {
203 return (DatabaseConnection::db_recovered_callback_(db_reconnect_ctl));
211 if (DatabaseConnection::db_failed_callback_) {
212 return (DatabaseConnection::db_failed_callback_(db_reconnect_ctl));
222 for (
auto param: params) {
223 std::string keyword = param.first;
224 std::string value = param.second;
226 if ((keyword ==
"lfc-interval") ||
227 (keyword ==
"connect-timeout") ||
228 (keyword ==
"reconnect-wait-time") ||
229 (keyword ==
"max-reconnect-tries") ||
230 (keyword ==
"port") ||
231 (keyword ==
"max-row-errors")) {
235 int_value = boost::lexical_cast<int64_t>(value);
239 .arg(
"integer").arg(keyword).arg(value);
241 }
else if ((keyword ==
"persist") ||
242 (keyword ==
"readonly")) {
243 if (value ==
"true") {
245 }
else if (value ==
"false") {
249 .arg(
"boolean").arg(keyword).arg(value);
251 }
else if ((keyword ==
"type") ||
252 (keyword ==
"user") ||
253 (keyword ==
"password") ||
254 (keyword ==
"host") ||
255 (keyword ==
"name") ||
256 (keyword ==
"on-fail") ||
257 (keyword ==
"trust-anchor") ||
258 (keyword ==
"cert-file") ||
259 (keyword ==
"key-file") ||
260 (keyword ==
"cipher-list")) {
264 .arg(
"unknown").arg(keyword).arg(value);
272 DatabaseConnection::toElementDbAccessString(
const std::string& dbaccess) {
274 return (toElement(params));
277 DbCallback DatabaseConnection::db_lost_callback_ = 0;
278 DbCallback DatabaseConnection::db_recovered_callback_ = 0;
279 DbCallback DatabaseConnection::db_failed_callback_ = 0;
We want to reuse the database backend connection and exchange code for other uses, in particular for hook libraries.
std::function< bool(util::ReconnectCtlPtr db_reconnect_ctl)> DbCallback
Defines a callback prototype for propagating events upward.
A generic exception that is thrown if a parameter given to a method or function is considered invalid...
boost::shared_ptr< ReconnectCtl > ReconnectCtlPtr
Pointer to an instance of ReconnectCtl.
const isc::log::MessageID DATABASE_TO_JSON_ERROR
#define LOG_ERROR(LOGGER, MESSAGE)
Macro to conveniently test error output and log it.
boost::shared_ptr< Element > ElementPtr
static ElementPtr createMap(const Position &pos=ZERO_POSITION())
Creates an empty MapElement type ElementPtr.
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
vector< string > tokens(const std::string &text, const std::string &delim, bool escape)
Split String into Tokens.
OnFailAction
Type of action to take on connection loss.
Defines the logger used by the top-level component of kea-lfc.
DB_LOG & arg(T first, Args... args)
Pass parameters to replace logger placeholders.
static ElementPtr create(const Position &pos=ZERO_POSITION())
Invalid 'readonly' value specification.
string trim(const string &instring)
Trim Leading and Trailing Spaces.
isc::log::Logger database_logger("database")
Common database library logger.
std::map< std::string, std::string > ParameterMap
Database configuration parameter map.
static OnFailAction onFailActionFromText(const std::string &text)
Convert string to action.