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 ==
"read-timeout") ||
229 (keyword ==
"write-timeout") ||
230 (keyword ==
"tcp-user-timeout") ||
231 (keyword ==
"reconnect-wait-time") ||
232 (keyword ==
"max-reconnect-tries") ||
233 (keyword ==
"port") ||
234 (keyword ==
"max-row-errors")) {
238 int_value = boost::lexical_cast<int64_t>(value);
242 .arg(keyword).arg(value);
244 }
else if ((keyword ==
"persist") ||
245 (keyword ==
"readonly")) {
246 if (value ==
"true") {
248 }
else if (value ==
"false") {
252 .arg(keyword).arg(value);
254 }
else if ((keyword ==
"type") ||
255 (keyword ==
"user") ||
256 (keyword ==
"password") ||
257 (keyword ==
"host") ||
258 (keyword ==
"name") ||
259 (keyword ==
"on-fail") ||
260 (keyword ==
"trust-anchor") ||
261 (keyword ==
"cert-file") ||
262 (keyword ==
"key-file") ||
263 (keyword ==
"cipher-list")) {
267 .arg(keyword).arg(value);
275 DatabaseConnection::toElementDbAccessString(
const std::string& dbaccess) {
277 return (toElement(params));
280 DbCallback DatabaseConnection::db_lost_callback_ = 0;
281 DbCallback DatabaseConnection::db_recovered_callback_ = 0;
282 DbCallback DatabaseConnection::db_failed_callback_ = 0;
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
A generic exception that is thrown if a parameter given to a method or function is considered invalid...
static ElementPtr create(const Position &pos=ZERO_POSITION())
static ElementPtr createMap(const Position &pos=ZERO_POSITION())
Creates an empty MapElement type ElementPtr.
std::map< std::string, std::string > ParameterMap
Database configuration parameter map.
Invalid 'readonly' value specification.
static OnFailAction onFailActionFromText(const std::string &text)
Convert string to action.
We want to reuse the database backend connection and exchange code for other uses,...
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
#define LOG_ERROR(LOGGER, MESSAGE)
Macro to conveniently test error output and log it.
boost::shared_ptr< Element > ElementPtr
isc::log::Logger database_logger("database")
Common database library logger.
const isc::log::MessageID DATABASE_TO_JSON_UNKNOWN_TYPE_ERROR
const isc::log::MessageID DATABASE_TO_JSON_INTEGER_ERROR
std::function< bool(util::ReconnectCtlPtr db_reconnect_ctl)> DbCallback
Defines a callback prototype for propagating events upward.
const isc::log::MessageID DATABASE_TO_JSON_BOOLEAN_ERROR
string trim(const string &instring)
Trim Leading and Trailing Spaces.
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.
boost::shared_ptr< ReconnectCtl > ReconnectCtlPtr
Pointer to an instance of ReconnectCtl.
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.