libkea_dhcpsrv_la_SOURCES += daemon.cc daemon.h
libkea_dhcpsrv_la_SOURCES += database_connection.cc database_connection.h
libkea_dhcpsrv_la_SOURCES += db_exceptions.h
+libkea_dhcpsrv_la_SOURCES += db_log.cc db_log.h
libkea_dhcpsrv_la_SOURCES += dhcp4o6_ipc.cc dhcp4o6_ipc.h
libkea_dhcpsrv_la_SOURCES += dhcpsrv_log.cc dhcpsrv_log.h
+libkea_dhcpsrv_la_SOURCES += dhcpsrv_db_log.cc dhcpsrv_db_log.h
libkea_dhcpsrv_la_SOURCES += host.cc host.h
libkea_dhcpsrv_la_SOURCES += host_container.h
libkea_dhcpsrv_la_SOURCES += host_data_source_factory.cc host_data_source_factory.h
-// Copyright (C) 2015-2017 Deutsche Telekom AG.
+// Copyright (C) 2015-2018 Deutsche Telekom AG.
//
// Authors: Razvan Becheriu <razvan.becheriu@qualitance.com>
// Andrei Pavel <andrei.pavel@qualitance.com>
#include <dhcpsrv/cql_connection.h>
#include <dhcpsrv/cql_exchange.h>
#include <dhcpsrv/db_exceptions.h>
-#include <dhcpsrv/dhcpsrv_log.h>
+#include <dhcpsrv/db_log.h>
namespace isc {
namespace dhcp {
if (rc != CASS_OK) {
// We're closing the connection anyway. Let's not throw at this stage.
- LOG_ERROR(dhcpsrv_logger, DHCPSRV_CQL_DEALLOC_ERROR).arg(error);
+ DB_LOG_ERROR(CQL_DEALLOC_ERROR).arg(error);
}
}
void
CqlConnection::startTransaction() {
- LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE_DETAIL,
- DHCPSRV_CQL_CONNECTION_BEGIN_TRANSACTION);
+ DB_LOG_DEBUG(DB_DBG_TRACE_DETAIL, CQL_CONNECTION_BEGIN_TRANSACTION);
}
void
CqlConnection::commit() {
- LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE_DETAIL,
- DHCPSRV_CQL_CONNECTION_COMMIT);
+ DB_LOG_DEBUG(DB_DBG_TRACE_DETAIL, CQL_CONNECTION_COMMIT);
}
void
CqlConnection::rollback() {
- LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE_DETAIL,
- DHCPSRV_CQL_CONNECTION_ROLLBACK);
+ DB_LOG_DEBUG(DB_DBG_TRACE_DETAIL, CQL_CONNECTION_ROLLBACK);
}
const std::string
-// Copyright (C) 2015-2016 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2015-2018 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
#include <dhcpsrv/database_connection.h>
#include <dhcpsrv/db_exceptions.h>
-#include <dhcpsrv/dhcpsrv_log.h>
+#include <dhcpsrv/db_log.h>
#include <exceptions/exceptions.h>
#include <boost/algorithm/string.hpp>
string value = token.substr(pos + 1);
mapped_tokens.insert(make_pair(name, value));
} else {
- LOG_ERROR(dhcpsrv_logger, DHCPSRV_INVALID_ACCESS).arg(dbaccess);
+ DB_LOG_ERROR(DB_INVALID_ACCESS).arg(dbaccess);
isc_throw(InvalidParameter, "Cannot parse " << token
<< ", expected format is name=value");
}
--- /dev/null
+// Copyright (C) 2018 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/.
+
+/// Defines the logger used by the NSAS
+
+#include <exceptions/exceptions.h>
+#include <dhcpsrv/db_log.h>
+#include <dhcpsrv/dhcpsrv_db_log.h>
+
+using namespace isc::log;
+
+namespace isc {
+namespace dhcp {
+
+const MessageID&
+DbLogger::translateMessage(const DbMessageID& id) const {
+ try {
+ return (map_.at(id));
+ } catch (const std::out_of_range&) {
+ isc_throw(isc::Unexpected, "can't map message: " << id);
+ }
+}
+
+void checkDbLoggerStack() {
+ if (db_logger_stack.empty()) {
+ isc_throw(isc::Unexpected, "database logger stack is empty");
+ }
+}
+
+} // namespace dhcp
+} // namespace isc
--- /dev/null
+// Copyright (C) 2018 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 DB_LOG_H
+#define DB_LOG_H
+
+#include <log/macros.h>
+
+#include <map>
+#include <list>
+
+namespace isc {
+namespace dhcp {
+
+///@{
+/// @brief Database logging levels
+///
+/// Defines the levels used to output debug messages in the database
+/// support. Note that higher numbers equate to more verbose (and detailed)
+/// output.
+
+/// @brief Additional information
+///
+/// Record detailed tracing. This is generally reserved for tracing access to
+/// the lease database.
+const int DB_DBG_TRACE_DETAIL = isc::log::DBGLVL_TRACE_DETAIL;
+
+///@}
+
+///@{
+/// @brief Database messages
+///
+enum DbMessageID {
+ DB_INVALID_ACCESS,
+
+ PGSQL_DEALLOC_ERROR,
+ PGSQL_FATAL_ERROR,
+ PGSQL_START_TRANSACTION,
+ PGSQL_COMMIT,
+ PGSQL_ROLLBACK,
+
+ MYSQL_FATAL_ERROR,
+ MYSQL_START_TRANSACTION,
+ MYSQL_COMMIT,
+ MYSQL_ROLLBACK,
+
+ CQL_DEALLOC_ERROR,
+ CQL_CONNECTION_BEGIN_TRANSACTION,
+ CQL_CONNECTION_COMMIT,
+ CQL_CONNECTION_ROLLBACK
+};
+///@}
+
+/// @brief Database logger class
+///
+class DbLogger {
+public:
+ /// @brief Translation map type
+ typedef std::map<DbMessageID, isc::log::MessageID> MessageMap;
+
+ /// @brief Constructor
+ ///
+ /// @param logger logger which will be called
+ DbLogger(isc::log::Logger& logger, const MessageMap& map)
+ : logger_(logger), map_(map) {
+ }
+
+ /// @brief Translate message
+ ///
+ /// @param id database message id
+ /// @return logger message
+ /// @throw Unexpected if the id is not in the message map
+ const isc::log::MessageID& translateMessage(const DbMessageID& id) const;
+
+ /// @brief The logger
+ isc::log::Logger& logger_;
+
+ /// @brief The translation map
+ const MessageMap& map_;
+};
+
+/// @brief Database logger stack
+typedef std::list<DbLogger> DbLoggerStack;
+
+/// @brief Global database logger stack (initialized to dhcpsrv logger)
+extern DbLoggerStack db_logger_stack;
+
+/// @brief Check database logger stack
+///
+/// @throw Unexpected if the stack is empty
+void checkDbLoggerStack();
+
+///@{
+/// @brief Macros
+
+#define DB_LOG_DEBUG(LEVEL, MESSAGE) \
+ checkDbLoggerStack(); \
+ if (!db_logger_stack.back().logger_.isDebugEnabled((LEVEL))) { \
+ } else \
+ db_logger_stack.back().logger_.debug((LEVEL), \
+ db_logger_stack.back().translateMessage((MESSAGE)))
+
+
+#define DB_LOG_INFO(MESSAGE) \
+ checkDbLoggerStack(); \
+ if (!db_logger_stack.back().logger_.isInfoEnabled()) { \
+ } else \
+ db_logger_stack.back().logger_.info( \
+ db_logger_stack.back().translateMessage((MESSAGE)))
+
+#define DB_LOG_WARN(MESSAGE) \
+ checkDbLoggerStack(); \
+ if (!db_logger_stack.back().logger_.isWarnEnabled()) { \
+ } else \
+ db_logger_stack.back().logger_.warn( \
+ db_logger_stack.back().translateMessage((MESSAGE)))
+
+#define DB_LOG_ERROR(MESSAGE) \
+ checkDbLoggerStack(); \
+ if (!db_logger_stack.back().logger_.isErrorEnabled()) { \
+ } else \
+ db_logger_stack.back().logger_.error( \
+ db_logger_stack.back().translateMessage((MESSAGE)))
+
+#define DB_LOG_FATAL(MESSAGE) \
+ checkDbLoggerStack(); \
+ if (!db_logger_stack.back().logger_.isFatalEnabled()) { \
+ } else \
+ db_logger_stack.back().logger_.fatal( \
+ db_logger_stack.back().translateMessage((MESSAGE)))
+
+///@}
+
+} // namespace dhcp
+} // namespace isc
+
+#endif // DB_LOG_H
--- /dev/null
+// Copyright (C) 2018 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/.
+
+/// Defines the logger used by the NSAS
+
+#include <dhcpsrv/dhcpsrv_db_log.h>
+#include <dhcpsrv/dhcpsrv_log.h>
+
+namespace isc {
+namespace dhcp {
+
+const DbLogger::MessageMap dhcpsrv_db_message_map = {
+ { DB_INVALID_ACCESS, DHCPSRV_INVALID_ACCESS },
+
+ { PGSQL_DEALLOC_ERROR, DHCPSRV_PGSQL_DEALLOC_ERROR },
+ { PGSQL_FATAL_ERROR, DHCPSRV_PGSQL_FATAL_ERROR },
+ { PGSQL_START_TRANSACTION, DHCPSRV_PGSQL_START_TRANSACTION },
+ { PGSQL_COMMIT, DHCPSRV_PGSQL_COMMIT },
+ { PGSQL_ROLLBACK, DHCPSRV_PGSQL_ROLLBACK },
+
+ { MYSQL_FATAL_ERROR, DHCPSRV_MYSQL_FATAL_ERROR },
+ { MYSQL_START_TRANSACTION, DHCPSRV_MYSQL_START_TRANSACTION },
+ { MYSQL_COMMIT, DHCPSRV_MYSQL_COMMIT },
+ { MYSQL_ROLLBACK, DHCPSRV_MYSQL_ROLLBACK },
+
+ { CQL_DEALLOC_ERROR, DHCPSRV_CQL_DEALLOC_ERROR },
+ { CQL_CONNECTION_BEGIN_TRANSACTION,
+ DHCPSRV_CQL_CONNECTION_BEGIN_TRANSACTION },
+ { CQL_CONNECTION_COMMIT, DHCPSRV_CQL_CONNECTION_COMMIT },
+ { CQL_CONNECTION_ROLLBACK, DHCPSRV_CQL_CONNECTION_ROLLBACK }
+};
+
+DbLogger dhcpsrv_db_logger(dhcpsrv_logger, dhcpsrv_db_message_map);
+
+// Do this initialization here!
+DbLoggerStack db_logger_stack = { dhcpsrv_db_logger };
+
+
+} // namespace dhcp
+} // namespace isc
--- /dev/null
+// Copyright (C) 2018 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 DHCPSRV_DB_LOG_H
+#define DHCPSRV_DB_LOG_H
+
+#include <dhcpsrv/db_log.h>
+
+namespace isc {
+namespace dhcp {
+
+/// @brief DHCP server database message map
+extern const DbLogger::MessageMap dhcpsrv_db_message_map;
+
+/// @brief DHCP server database Logger
+///
+/// It is the default database logger.
+extern DbLogger dhcpsrv_db_logger;
+
+} // namespace dhcp
+} // namespace isc
+
+#endif // DHCPSRV_DB_LOG_H
-// Copyright (C) 2012-2017 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2012-2018 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/.
-#include <dhcpsrv/dhcpsrv_log.h>
+#include <dhcpsrv/db_log.h>
#include <dhcpsrv/mysql_connection.h>
#include <exceptions/exceptions.h>
void
MySqlConnection::startTransaction() {
- LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE_DETAIL,
- DHCPSRV_MYSQL_START_TRANSACTION);
+ DB_LOG_DEBUG(DB_DBG_TRACE_DETAIL, MYSQL_START_TRANSACTION);
// We create prepared statements for all other queries, but MySQL
// don't support prepared statements for START TRANSACTION.
int status = mysql_query(mysql_, "START TRANSACTION");
void
MySqlConnection::commit() {
- LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE_DETAIL, DHCPSRV_MYSQL_COMMIT);
+ DB_LOG_DEBUG(DB_DBG_TRACE_DETAIL, MYSQL_COMMIT);
if (mysql_commit(mysql_) != 0) {
isc_throw(DbOperationError, "commit failed: "
<< mysql_error(mysql_));
void
MySqlConnection::rollback() {
- LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE_DETAIL, DHCPSRV_MYSQL_ROLLBACK);
+ DB_LOG_DEBUG(DB_DBG_TRACE_DETAIL, MYSQL_ROLLBACK);
if (mysql_rollback(mysql_) != 0) {
isc_throw(DbOperationError, "rollback failed: "
<< mysql_error(mysql_));
-// Copyright (C) 2012-2017 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2012-2018 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
#define MYSQL_CONNECTION_H
#include <dhcpsrv/database_connection.h>
-#include <dhcpsrv/dhcpsrv_log.h>
+#include <dhcpsrv/db_log.h>
#include <exceptions/exceptions.h>
#include <boost/scoped_ptr.hpp>
#include <mysql.h>
case CR_OUT_OF_MEMORY:
case CR_CONNECTION_ERROR:
// We're exiting on fatal
- LOG_ERROR(dhcpsrv_logger, DHCPSRV_MYSQL_FATAL_ERROR)
- .arg(what)
- .arg(text_statements_[static_cast<int>(index)])
- .arg(mysql_error(mysql_))
- .arg(mysql_errno(mysql_));
+ DB_LOG_ERROR(MYSQL_FATAL_ERROR)
+ .arg(what)
+ .arg(text_statements_[static_cast<int>(index)])
+ .arg(mysql_error(mysql_))
+ .arg(mysql_errno(mysql_));
exit (-1);
default:
-// Copyright (C) 2016-2017 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2016-2018 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
#include <config.h>
-#include <dhcpsrv/dhcpsrv_log.h>
+#include <dhcpsrv/db_log.h>
#include <dhcpsrv/pgsql_connection.h>
// PostgreSQL errors should be tested based on the SQL state code. Each state
PgSqlResult r(PQexec(conn_, "DEALLOCATE all"));
if(PQresultStatus(r) != PGRES_COMMAND_OK) {
// Highly unlikely but we'll log it and go on.
- LOG_ERROR(dhcpsrv_logger, DHCPSRV_PGSQL_DEALLOC_ERROR)
- .arg(PQerrorMessage(conn_));
+ DB_LOG_ERROR(PGSQL_DEALLOC_ERROR).arg(PQerrorMessage(conn_));
}
}
}
(memcmp(sqlstate, "54", 2) == 0) || // Program Limit exceeded
(memcmp(sqlstate, "57", 2) == 0) || // Operator intervention
(memcmp(sqlstate, "58", 2) == 0))) { // System error
- LOG_ERROR(dhcpsrv_logger, DHCPSRV_PGSQL_FATAL_ERROR)
- .arg(statement.name)
- .arg(PQerrorMessage(conn_))
- .arg(sqlstate);
+ DB_LOG_ERROR(PGSQL_FATAL_ERROR)
+ .arg(statement.name)
+ .arg(PQerrorMessage(conn_))
+ .arg(sqlstate);
exit (-1);
}
void
PgSqlConnection::startTransaction() {
- LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE_DETAIL,
- DHCPSRV_PGSQL_START_TRANSACTION);
+ DB_LOG_DEBUG(DB_DBG_TRACE_DETAIL, PGSQL_START_TRANSACTION);
PgSqlResult r(PQexec(conn_, "START TRANSACTION"));
if (PQresultStatus(r) != PGRES_COMMAND_OK) {
const char* error_message = PQerrorMessage(conn_);
void
PgSqlConnection::commit() {
- LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE_DETAIL, DHCPSRV_PGSQL_COMMIT);
+ DB_LOG_DEBUG(DB_DBG_TRACE_DETAIL, PGSQL_COMMIT);
PgSqlResult r(PQexec(conn_, "COMMIT"));
if (PQresultStatus(r) != PGRES_COMMAND_OK) {
const char* error_message = PQerrorMessage(conn_);
void
PgSqlConnection::rollback() {
- LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE_DETAIL, DHCPSRV_PGSQL_ROLLBACK);
+ DB_LOG_DEBUG(DB_DBG_TRACE_DETAIL, PGSQL_ROLLBACK);
PgSqlResult r(PQexec(conn_, "ROLLBACK"));
if (PQresultStatus(r) != PGRES_COMMAND_OK) {
const char* error_message = PQerrorMessage(conn_);
projects / thirdparty / kea.git / commitdiff
