database_connection.h

Go to the documentation of this file.

// Copyright (C) 2015-2021 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 <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 DbInvalidReadOnly : public Exception {
public:
    DbInvalidReadOnly(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};

enum class OnFailAction {
    STOP_RETRY_EXIT,
    SERVE_RETRY_EXIT,
    SERVE_RETRY_CONTINUE
};

class ReconnectCtl {
public:
    ReconnectCtl(const std::string& backend_type, const std::string& timer_name,
                 unsigned int max_retries, unsigned int retry_interval,
                 OnFailAction action) :
          backend_type_(backend_type), timer_name_(timer_name),
          max_retries_(max_retries), retries_left_(max_retries),
          retry_interval_(retry_interval), action_(action) {}

    std::string backendType() const {
        return (backend_type_);
    }

    std::string timerName() const {
        return (timer_name_);
    }

    bool checkRetries() {
        return (retries_left_ ? --retries_left_ : false);
    }

    unsigned int maxRetries() {
        return (max_retries_);
    }

    unsigned int retriesLeft() {
        return (retries_left_);
    }

    unsigned int retryInterval() {
        return (retry_interval_);
    }

    void resetRetries() {
        retries_left_ = max_retries_;
    }

    bool alterServiceState() {
        return (action_ == OnFailAction::STOP_RETRY_EXIT);
    }

    bool exitOnFailure() {
        return ((action_ == OnFailAction::STOP_RETRY_EXIT) ||
                (action_ == OnFailAction::SERVE_RETRY_EXIT));
    }

    static std::string onFailActionToText(OnFailAction action);

    static OnFailAction onFailActionFromText(const std::string& text);

private:

    const std::string backend_type_;

    std::string timer_name_;

    unsigned int max_retries_;

    unsigned int retries_left_;

    unsigned int retry_interval_;

    OnFailAction action_;
};

typedef boost::shared_ptr<ReconnectCtl> ReconnectCtlPtr;

typedef std::function<bool (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);

    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 ReconnectCtlPtr& db_reconnect_ctl);

    static bool invokeDbRecoveredCallback(const ReconnectCtlPtr& db_reconnect_ctl);

    static bool invokeDbFailedCallback(const 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_;

    ReconnectCtlPtr reconnect_ctl_;
};

}  // namespace db
}  // namespace isc

#endif // DATABASE_CONNECTION_H