database_connection.h

Go to the documentation of this file.

// Copyright (C) 2015-2023 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 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) {}
};

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 DbCallback db_lost_callback_;

    static DbCallback db_recovered_callback_;

    static DbCallback db_failed_callback_;

    void checkUnusable() {
        if (unusable_)  {
            isc_throw (DbConnectionUnusable, "Attempt to use an invalid connection");
        }
    }

    bool isUnusable() {
        return (unusable_);
    }

protected:
    void markUnusable() { unusable_ = true; }

private:

    ParameterMap parameters_;

protected:

    DbCallback callback_;

private:

    bool unusable_;

    util::ReconnectCtlPtr reconnect_ctl_;
};

}  // namespace db
}  // namespace isc

#endif // DATABASE_CONNECTION_H