Kea: mysql_connection.h Source File

| Kea 2.2.0

mysql_connection.h
Go to the documentation of this file.
1// Copyright (C) 2012-2022 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#ifndef MYSQL_CONNECTION_H
8#define MYSQL_CONNECTION_H
9
10#include <asiolink/io_service.h>
11#include <database/database_connection.h>
12#include <database/db_exceptions.h>
13#include <database/db_log.h>
14#include <exceptions/exceptions.h>
15#include <mysql/mysql_binding.h>
16#include <mysql/mysql_constants.h>
17#include <boost/scoped_ptr.hpp>
18#include <mysql.h>
19#include <mysqld_error.h>
20#include <errmsg.h>
21#include <functional>
22#include <vector>
23#include <stdint.h>
24
25namespace isc {
26namespace db {
27
28
42
43 class MySqlFreeResult {
44public:
45
56 MySqlFreeResult(MYSQL_STMT* statement) : statement_(statement)
57 {}
58
62 ~MySqlFreeResult() {
63 (void) mysql_stmt_free_result(statement_);
64 }
65
66private:
67 MYSQL_STMT* statement_;
68};
69
74 struct TaggedStatement {
75 uint32_t index;
76 const char* text;
77};
78
88template <typename Fun, typename... Args>
89 int retryOnDeadlock(Fun& fun, Args... args) {
90 int status;
91 for (unsigned count = 0; count < 5; ++count) {
92 status = fun(args...);
93 if (status != ER_LOCK_DEADLOCK) {
94 break;
95 }
96 }
97 return (status);
98}
99
106 inline int MysqlExecuteStatement(MYSQL_STMT* stmt) {
107 return (retryOnDeadlock(mysql_stmt_execute, stmt));
108}
109
117 inline int MysqlQuery(MYSQL* mysql, const char* stmt) {
118 return (retryOnDeadlock(mysql_query, mysql, stmt));
119}
120
132 class MySqlHolder : public boost::noncopyable {
133public:
134
140 MySqlHolder() : mysql_(mysql_init(NULL)) {
141 if (mysql_ == NULL) {
142 isc_throw(db::DbOpenError, "unable to initialize MySQL");
143 }
144 }
145
149 ~MySqlHolder() {
150 if (mysql_ != NULL) {
151 mysql_close(mysql_);
152 }
153 }
154
159 operator MYSQL*() const {
160 return (mysql_);
161 }
162
163private:
165 static int atexit_;
166
168 MYSQL* mysql_;
169};
170
172class MySqlConnection;
173
194 class MySqlTransaction : public boost::noncopyable {
195public:
196
205 MySqlTransaction(MySqlConnection& conn);
206
210 ~MySqlTransaction();
211
213 void commit();
214
215private:
216
218 MySqlConnection& conn_;
219
224 bool committed_;
225};
226
227
235 class MySqlConnection : public db::DatabaseConnection {
236public:
237
239 typedef std::function<void(MySqlBindingCollection&)> ConsumeResultFun;
240
248 MySqlConnection(const ParameterMap& parameters,
249 IOServiceAccessorPtr io_accessor = IOServiceAccessorPtr(),
250 DbCallback callback = DbCallback())
251 : DatabaseConnection(parameters, callback),
252 io_service_accessor_(io_accessor), io_service_(),
253 transaction_ref_count_(0), tls_(false) {
254 }
255
257 virtual ~MySqlConnection();
258
269 static std::pair<uint32_t, uint32_t>
270 getVersion(const ParameterMap& parameters);
271
285 void prepareStatement(uint32_t index, const char* text);
286
301 void prepareStatements(const TaggedStatement* start_statement,
302 const TaggedStatement* end_statement);
303
305 void clearStatements();
306
314 void openDatabase();
315
323
329 static
330 void convertToDatabaseTime(const time_t input_time, MYSQL_TIME& output_time);
331
351 static
352 void convertToDatabaseTime(const time_t cltt, const uint32_t valid_lifetime,
353 MYSQL_TIME& expire);
354
372 static
373 void convertFromDatabaseTime(const MYSQL_TIME& expire,
374 uint32_t valid_lifetime, time_t& cltt);
376
390 void startTransaction();
391
395 bool isTransactionStarted() const;
396
424 template<typename StatementIndex>
425 void selectQuery(const StatementIndex& index,
426 const MySqlBindingCollection& in_bindings,
427 MySqlBindingCollection& out_bindings,
428 ConsumeResultFun process_result) {
429 checkUnusable();
430 // Extract native input bindings.
431 std::vector<MYSQL_BIND> in_bind_vec;
432 for (MySqlBindingPtr in_binding : in_bindings) {
433 in_bind_vec.push_back(in_binding->getMySqlBinding());
434 }
435
436 int status = 0;
437 if (!in_bind_vec.empty()) {
438 // Bind parameters to the prepared statement.
439 status = mysql_stmt_bind_param(statements_[index],
440 in_bind_vec.empty() ? 0 : &in_bind_vec[0]);
441 checkError(status, index, "unable to bind parameters for select");
442 }
443
444 // Bind variables that will receive results as well.
445 std::vector<MYSQL_BIND> out_bind_vec;
446 for (MySqlBindingPtr out_binding : out_bindings) {
447 out_bind_vec.push_back(out_binding->getMySqlBinding());
448 }
449 if (!out_bind_vec.empty()) {
450 status = mysql_stmt_bind_result(statements_[index], &out_bind_vec[0]);
451 checkError(status, index, "unable to bind result parameters for select");
452 }
453
454 // Execute query.
455 status = MysqlExecuteStatement(statements_[index]);
456 checkError(status, index, "unable to execute");
457
458 status = mysql_stmt_store_result(statements_[index]);
459 checkError(status, index, "unable to set up for storing all results");
460
461 // Fetch results.
462 MySqlFreeResult fetch_release(statements_[index]);
463 while ((status = mysql_stmt_fetch(statements_[index])) ==
464 MLM_MYSQL_FETCH_SUCCESS) {
465 try {
466 // For each returned row call user function which should
467 // consume the row and copy the data to a safe place.
468 process_result(out_bindings);
469
470 } catch (const std::exception& ex) {
471 // Rethrow the exception with a bit more data.
472 isc_throw(BadValue, ex.what() << ". Statement is <" <<
473 text_statements_[index] << ">");
474 }
475 }
476
477 // How did the fetch end?
478 // If mysql_stmt_fetch return value is equal to 1 an error occurred.
479 if (status == MLM_MYSQL_FETCH_FAILURE) {
480 // Error - unable to fetch results
481 checkError(status, index, "unable to fetch results");
482
483 } else if (status == MYSQL_DATA_TRUNCATED) {
484 // Data truncated - throw an exception indicating what was at fault
485 isc_throw(DataTruncated, text_statements_[index]
486 << " returned truncated data");
487 }
488 }
489
504 template<typename StatementIndex>
505 void insertQuery(const StatementIndex& index,
506 const MySqlBindingCollection& in_bindings) {
507 checkUnusable();
508 std::vector<MYSQL_BIND> in_bind_vec;
509 for (MySqlBindingPtr in_binding : in_bindings) {
510 in_bind_vec.push_back(in_binding->getMySqlBinding());
511 }
512
513 // Bind the parameters to the statement
514 int status = mysql_stmt_bind_param(statements_[index],
515 in_bind_vec.empty() ? 0 : &in_bind_vec[0]);
516 checkError(status, index, "unable to bind parameters");
517
518 // Execute the statement
519 status = MysqlExecuteStatement(statements_[index]);
520
521 if (status != 0) {
522 // Failure: check for the special case of duplicate entry.
523 if (mysql_errno(mysql_) == ER_DUP_ENTRY) {
524 isc_throw(DuplicateEntry, "Database duplicate entry error");
525 }
526 // Failure: check for the special case of WHERE returning NULL.
527 if (mysql_errno(mysql_) == ER_BAD_NULL_ERROR) {
528 isc_throw(NullKeyError, "Database bad NULL error");
529 }
530 checkError(status, index, "unable to execute");
531 }
532 }
533
548 template<typename StatementIndex>
549 uint64_t updateDeleteQuery(const StatementIndex& index,
550 const MySqlBindingCollection& in_bindings) {
551 checkUnusable();
552 std::vector<MYSQL_BIND> in_bind_vec;
553 for (MySqlBindingPtr in_binding : in_bindings) {
554 in_bind_vec.push_back(in_binding->getMySqlBinding());
555 }
556
557 // Bind the parameters to the statement
558 int status = mysql_stmt_bind_param(statements_[index],
559 in_bind_vec.empty() ? 0 : &in_bind_vec[0]);
560 checkError(status, index, "unable to bind parameters");
561
562 // Execute the statement
563 status = MysqlExecuteStatement(statements_[index]);
564
565 if (status != 0) {
566 // Failure: check for the special case of duplicate entry.
567 if ((mysql_errno(mysql_) == ER_DUP_ENTRY)
568#ifdef ER_FOREIGN_DUPLICATE_KEY
569 || (mysql_errno(mysql_) == ER_FOREIGN_DUPLICATE_KEY)
570#endif
571#ifdef ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO
572 || (mysql_errno(mysql_) == ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO)
573#endif
574#ifdef ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO
575 || (mysql_errno(mysql_) == ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO)
576#endif
577 ) {
578 isc_throw(DuplicateEntry, "Database duplicate entry error");
579 }
580 checkError(status, index, "unable to execute");
581 }
582
583 // Let's return how many rows were affected.
584 return (static_cast<uint64_t>(mysql_stmt_affected_rows(statements_[index])));
585 }
586
597 void commit();
598
609 void rollback();
610
639 template<typename StatementIndex>
640 void checkError(const int status, const StatementIndex& index,
641 const char* what) {
642 if (status != 0) {
643 switch(mysql_errno(mysql_)) {
644 // These are the ones we consider fatal. Remember this method is
645 // used to check errors of API calls made subsequent to successfully
646 // connecting. Errors occurring while attempting to connect are
647 // checked in the connection code. An alternative would be to call
648 // mysql_ping() - assuming autoreconnect is off. If that fails
649 // then we know connection is toast.
650 case CR_SERVER_GONE_ERROR:
651 case CR_SERVER_LOST:
652 case CR_OUT_OF_MEMORY:
653 case CR_CONNECTION_ERROR: {
654 DB_LOG_ERROR(db::MYSQL_FATAL_ERROR)
655 .arg(what)
656 .arg(text_statements_[static_cast<int>(index)])
657 .arg(mysql_error(mysql_))
658 .arg(mysql_errno(mysql_));
659
660 // Mark this connection as no longer usable.
661 markUnusable();
662
663 // Start the connection recovery.
664 startRecoverDbConnection();
665
666 // We still need to throw so caller can error out of the current
667 // processing.
668 isc_throw(db::DbConnectionUnusable,
669 "fatal database error or connectivity lost");
670 }
671 default:
672 // Connection is ok, so it must be an SQL error
673 isc_throw(db::DbOperationError, what << " for <"
674 << text_statements_[static_cast<int>(index)]
675 << ">, reason: "
676 << mysql_error(mysql_) << " (error code "
677 << mysql_errno(mysql_) << ")");
678 }
679 }
680 }
681
687 void startRecoverDbConnection() {
688 if (callback_) {
689 if (!io_service_ && io_service_accessor_) {
690 io_service_ = (*io_service_accessor_)();
691 io_service_accessor_.reset();
692 }
693
694 if (io_service_) {
695 io_service_->post(std::bind(callback_, reconnectCtl()));
696 }
697 }
698 }
699
703 bool getTls() const {
704 return (tls_);
705 }
706
710 std::string getTlsCipher() {
711 const char* cipher = mysql_get_ssl_cipher(mysql_);
712 return (cipher ? std::string(cipher) : "");
713 }
714
719 std::vector<MYSQL_STMT*> statements_;
720
725 std::vector<std::string> text_statements_;
726
731 MySqlHolder mysql_;
732
740 IOServiceAccessorPtr io_service_accessor_;
741
743 isc::asiolink::IOServicePtr io_service_;
744
751 int transaction_ref_count_;
752
754 bool tls_;
755};
756
757} // end of isc::db namespace
758} // end of isc namespace
759
760#endif // MYSQL_CONNECTION_H
isc::BadValue
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
Definition: exceptions/exceptions.h:132
isc::Exception::what
virtual const char * what() const
Returns a C-style character string of the cause of the exception.
Definition: exceptions/exceptions.cc:32
isc::db::DataTruncated
Data is truncated.
Definition: db_exceptions.h:23
isc::db::DatabaseConnection
Common database connection class.
Definition: database_connection.h:103
isc::db::DatabaseConnection::reconnectCtl
util::ReconnectCtlPtr reconnectCtl()
The reconnect settings.
Definition: database_connection.h:139
isc::db::DatabaseConnection::markUnusable
void markUnusable()
Sets the unusable flag to true.
Definition: database_connection.h:238
isc::db::DatabaseConnection::checkUnusable
void checkUnusable()
Throws an exception if the connection is not usable.
Definition: database_connection.h:223
isc::db::DatabaseConnection::ParameterMap
std::map< std::string, std::string > ParameterMap
Database configuration parameter map.
Definition: database_connection.h:115
isc::db::DatabaseConnection::callback_
DbCallback callback_
The callback used to recover the connection.
Definition: database_connection.h:252
isc::db::DbConnectionUnusable
Exception thrown when a specific connection has been rendered unusable either through loss of connect...
Definition: database_connection.h:46
isc::db::DbOpenError
Exception thrown on failure to open database.
Definition: database_connection.h:31
isc::db::DbOperationError
Exception thrown on failure to execute a database function.
Definition: database_connection.h:38
isc::db::DuplicateEntry
Database duplicate entry error.
Definition: db_exceptions.h:30
isc::db::MySqlConnection
Common MySQL Connector Pool.
Definition: mysql_connection.h:235
isc::db::MySqlConnection::io_service_
isc::asiolink::IOServicePtr io_service_
IOService object, used for all ASIO operations.
Definition: mysql_connection.h:743
isc::db::MySqlConnection::mysql_
MySqlHolder mysql_
MySQL connection handle.
Definition: mysql_connection.h:731
isc::db::MySqlConnection::prepareStatement
void prepareStatement(uint32_t index, const char *text)
Prepare Single Statement.
Definition: mysql_connection.cc:372
isc::db::MySqlConnection::statements_
std::vector< MYSQL_STMT * > statements_
Prepared statements.
Definition: mysql_connection.h:719
isc::db::MySqlConnection::isTransactionStarted
bool isTransactionStarted() const
Checks if there is a transaction in progress.
Definition: mysql_connection.cc:480
isc::db::MySqlConnection::text_statements_
std::vector< std::string > text_statements_
Raw text of statements.
Definition: mysql_connection.h:725
isc::db::MySqlConnection::insertQuery
void insertQuery(const StatementIndex &index, const MySqlBindingCollection &in_bindings)
Executes INSERT prepared statement.
Definition: mysql_connection.h:505
isc::db::MySqlConnection::tls_
bool tls_
TLS flag (true when TLS was required, false otherwise).
Definition: mysql_connection.h:754
isc::db::MySqlConnection::convertToDatabaseTime
static void convertToDatabaseTime(const time_t input_time, MYSQL_TIME &output_time)
Convert time_t value to database time.
Definition: mysql_connection.cc:443
isc::db::MySqlConnection::io_service_accessor_
IOServiceAccessorPtr io_service_accessor_
Accessor function which returns the IOService that can be used to recover the connection.
Definition: mysql_connection.h:740
isc::db::MySqlConnection::convertFromDatabaseTime
static void convertFromDatabaseTime(const MYSQL_TIME &expire, uint32_t valid_lifetime, time_t &cltt)
Convert Database Time to Lease Times.
Definition: mysql_connection.cc:456
isc::db::MySqlConnection::commit
void commit()
Commits current transaction.
Definition: mysql_connection.cc:485
isc::db::MySqlConnection::MySqlConnection
MySqlConnection(const ParameterMap &parameters, IOServiceAccessorPtr io_accessor=IOServiceAccessorPtr(), DbCallback callback=DbCallback())
Constructor.
Definition: mysql_connection.h:248
isc::db::MySqlConnection::startRecoverDbConnection
void startRecoverDbConnection()
The recover connection.
Definition: mysql_connection.h:687
isc::db::MySqlConnection::updateDeleteQuery
uint64_t updateDeleteQuery(const StatementIndex &index, const MySqlBindingCollection &in_bindings)
Executes UPDATE or DELETE prepared statement and returns the number of affected rows.
Definition: mysql_connection.h:549
isc::db::MySqlConnection::openDatabase
void openDatabase()
Open Database.
Definition: mysql_connection.cc:56
isc::db::MySqlConnection::getTlsCipher
std::string getTlsCipher()
Get the TLS cipher.
Definition: mysql_connection.h:710
isc::db::MySqlConnection::prepareStatements
void prepareStatements(const TaggedStatement *start_statement, const TaggedStatement *end_statement)
Prepare statements.
Definition: mysql_connection.cc:397
isc::db::MySqlConnection::getVersion
static std::pair< uint32_t, uint32_t > getVersion(const ParameterMap &parameters)
Get the schema version.
Definition: mysql_connection.cc:289
isc::db::MySqlConnection::transaction_ref_count_
int transaction_ref_count_
Reference counter for transactions.
Definition: mysql_connection.h:751
isc::db::MySqlConnection::startTransaction
void startTransaction()
Starts new transaction.
Definition: mysql_connection.cc:462
isc::db::MySqlConnection::~MySqlConnection
virtual ~MySqlConnection()
Destructor.
Definition: mysql_connection.cc:418
isc::db::MySqlConnection::ConsumeResultFun
std::function< void(MySqlBindingCollection &)> ConsumeResultFun
Function invoked to process fetched row.
Definition: mysql_connection.h:239
isc::db::MySqlConnection::checkError
void checkError(const int status, const StatementIndex &index, const char *what)
Check Error and Throw Exception.
Definition: mysql_connection.h:640
isc::db::MySqlConnection::getTls
bool getTls() const
Get the TLS flag.
Definition: mysql_connection.h:703
isc::db::MySqlConnection::selectQuery
void selectQuery(const StatementIndex &index, const MySqlBindingCollection &in_bindings, MySqlBindingCollection &out_bindings, ConsumeResultFun process_result)
Executes SELECT query using prepared statement.
Definition: mysql_connection.h:425
isc::db::MySqlConnection::clearStatements
void clearStatements()
Clears prepared statements and text statements.
Definition: mysql_connection.cc:412
isc::db::MySqlConnection::rollback
void rollback()
Rollbacks current transaction.
Definition: mysql_connection.cc:503
isc::db::MySqlFreeResult
Fetch and Release MySQL Results.
Definition: mysql_connection.h:43
isc::db::MySqlFreeResult::~MySqlFreeResult
~MySqlFreeResult()
Destructor.
Definition: mysql_connection.h:62
isc::db::MySqlFreeResult::MySqlFreeResult
MySqlFreeResult(MYSQL_STMT *statement)
Constructor.
Definition: mysql_connection.h:56
isc::db::MySqlHolder
MySQL Handle Holder.
Definition: mysql_connection.h:132
isc::db::MySqlHolder::MySqlHolder
MySqlHolder()
Constructor.
Definition: mysql_connection.h:140
isc::db::MySqlHolder::~MySqlHolder
~MySqlHolder()
Destructor.
Definition: mysql_connection.h:149
isc::db::MySqlTransaction
RAII object representing MySQL transaction.
Definition: mysql_connection.h:194
isc::db::MySqlTransaction::~MySqlTransaction
~MySqlTransaction()
Destructor.
Definition: mysql_connection.cc:39
isc::db::MySqlTransaction::commit
void commit()
Commits transaction.
Definition: mysql_connection.cc:48
isc::db::MySqlTransaction::MySqlTransaction
MySqlTransaction(MySqlConnection &conn)
Constructor.
Definition: mysql_connection.cc:34
isc::db::NullKeyError
Key is NULL but was specified NOT NULL.
Definition: db_exceptions.h:37
database_connection.h
db_exceptions.h
db_log.h
We want to reuse the database backend connection and exchange code for other uses,...
exceptions.h
isc_throw
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
Definition: exceptions/exceptions.h:210
io_service.h
mysql_binding.h
mysql_constants.h
isc::asiolink::IOServicePtr
boost::shared_ptr< IOService > IOServicePtr
Defines a smart pointer to an IOService instance.
Definition: io_service.h:110
isc::db::MySqlBindingPtr
boost::shared_ptr< MySqlBinding > MySqlBindingPtr
Shared pointer to the Binding class.
Definition: mysql_binding.h:136
isc::db::MYSQL_FATAL_ERROR
@ MYSQL_FATAL_ERROR
Definition: db_log.h:62
isc::db::IOServiceAccessorPtr
boost::shared_ptr< IOServiceAccessor > IOServiceAccessorPtr
Pointer to an instance of IOServiceAccessor.
Definition: database_connection.h:93
isc::db::MLM_MYSQL_FETCH_FAILURE
const int MLM_MYSQL_FETCH_FAILURE
MySQL fetch failure code.
Definition: mysql_constants.h:49
isc::db::MysqlQuery
int MysqlQuery(MYSQL *mysql, const char *stmt)
Execute a literal statement.
Definition: mysql_connection.h:117
isc::db::MySqlBindingCollection
std::vector< MySqlBindingPtr > MySqlBindingCollection
Collection of bindings.
Definition: mysql_binding.h:665
isc::db::MLM_MYSQL_FETCH_SUCCESS
const int MLM_MYSQL_FETCH_SUCCESS
check for bool size
Definition: mysql_constants.h:46
isc::db::retryOnDeadlock
int retryOnDeadlock(Fun &fun, Args... args)
Retry on InnoDB deadlock.
Definition: mysql_connection.h:89
isc::db::DbCallback
std::function< bool(util::ReconnectCtlPtr db_reconnect_ctl)> DbCallback
Defines a callback prototype for propagating events upward.
Definition: database_connection.h:81
isc::db::MysqlExecuteStatement
int MysqlExecuteStatement(MYSQL_STMT *stmt)
Execute a prepared statement.
Definition: mysql_connection.h:106
isc
Defines the logger used by the top-level component of kea-lfc.
Definition: agent_parser.cc:143
isc::db::DB_LOG_ERROR
Definition: db_log.h:183
isc::db::DB_LOG::arg
DB_LOG & arg(T first, Args... args)
Pass parameters to replace logger placeholders.
Definition: db_log.h:141
isc::db::TaggedStatement
MySQL Selection Statements.
Definition: mysql_connection.h:74
isc::db::TaggedStatement::index
uint32_t index
Definition: mysql_connection.h:75
isc::db::TaggedStatement::text
const char * text
Definition: mysql_connection.h:76