database_connection.h

Go to the documentation of this file.

// Copyright (C) 2015-2024 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 DATABASE_CONNECTION_H
#define DATABASE_CONNECTION_H
 
#include <asiolink/io_service.h>
#include <cc/data.h>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <exceptions/exceptions.h>
#include <util/reconnect_ctl.h>
#include <functional>
#include <map>
#include <string>
 
namespace isc {
namespace db {
 
class NoDatabaseName : public Exception {
public:
    NoDatabaseName(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class DbOpenError : public Exception {
public:
    DbOpenError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class DbOpenErrorWithRetry : public Exception {
public:
    DbOpenErrorWithRetry(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class DbOperationError : public Exception {
public:
    DbOperationError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class DbConnectionUnusable : public Exception {
public:
    DbConnectionUnusable(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class InvalidType : public Exception {
public:
    InvalidType(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class DbInvalidTimeout : public Exception {
public:
    DbInvalidTimeout(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class DbInvalidPort : public Exception {
public:
    DbInvalidPort(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class DbInvalidReadOnly : public Exception {
public:
    DbInvalidReadOnly(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class SchemaInitializationFailed : public Exception {
public:
    SchemaInitializationFailed(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
typedef std::function<bool (util::ReconnectCtlPtr db_reconnect_ctl)> DbCallback;
 
typedef std::function<isc::asiolink::IOServicePtr ()> IOServiceAccessor;
 
typedef boost::shared_ptr<IOServiceAccessor> IOServiceAccessorPtr;
 
class DatabaseConnection : public boost::noncopyable {
public:
 
    static const time_t MAX_DB_TIME;
 
    typedef std::map<std::string, std::string> ParameterMap;
 
    DatabaseConnection(const ParameterMap& parameters,
                       DbCallback callback = DbCallback())
        : parameters_(parameters), callback_(callback), unusable_(false) {
    }
 
    virtual ~DatabaseConnection(){}
 
    virtual void makeReconnectCtl(const std::string& timer_name);
 
    util::ReconnectCtlPtr reconnectCtl() {
        return (reconnect_ctl_);
    }
 
    std::string getParameter(const std::string& name) const;
 
    static ParameterMap parse(const std::string& dbaccess);
 
    static std::string redactedAccessString(const ParameterMap& parameters);
 
    bool configuredReadOnly() const;
 
    static bool invokeDbLostCallback(const util::ReconnectCtlPtr& db_reconnect_ctl);
 
    static bool invokeDbRecoveredCallback(const util::ReconnectCtlPtr& db_reconnect_ctl);
 
    static bool invokeDbFailedCallback(const util::ReconnectCtlPtr& db_reconnect_ctl);
 
    static isc::data::ElementPtr toElement(const ParameterMap& params);
 
    static isc::data::ElementPtr toElementDbAccessString(const std::string& dbaccess);
 
    static void setIOService(const isc::asiolink::IOServicePtr& io_service) {
        io_service_ = io_service;
    }
 
    static isc::asiolink::IOServicePtr& getIOService() {
        return (io_service_);
    }
 
    static DbCallback db_lost_callback_;
 
    static DbCallback db_recovered_callback_;
 
    static DbCallback db_failed_callback_;
 
    static bool retry_;
 
    void checkUnusable() {
        if (unusable_)  {
            isc_throw (DbConnectionUnusable, "Attempt to use an invalid connection");
        }
    }
 
    bool isUnusable() {
        return (unusable_);
    }
 
    static bool test_mode_;
 
    class EnterTest {
    public:
 
        EnterTest() {
            DatabaseConnection::test_mode_ = true;
        }
 
        ~EnterTest() {
            DatabaseConnection::test_mode_ = false;
        }
    };
 
protected:
 
    void markUnusable() { unusable_ = true; }
 
private:
 
    ParameterMap parameters_;
 
protected:
 
    DbCallback callback_;
 
private:
 
    bool unusable_;
 
    util::ReconnectCtlPtr reconnect_ctl_;
 
    static isc::asiolink::IOServicePtr io_service_;
};
 
class DbConnectionInitWithRetry {
public:
    DbConnectionInitWithRetry() {
        DatabaseConnection::retry_ = true;
    }
 
    ~DbConnectionInitWithRetry() {
        DatabaseConnection::retry_ = false;
    }
};
 
}  // namespace db
}  // namespace isc
 
#endif // DATABASE_CONNECTION_H