database_connection.h

Go to the documentation of this file.

// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef DATABASE_CONNECTION_H
#define DATABASE_CONNECTION_H

#include <cc/data.h>
#include <boost/noncopyable.hpp>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#include <exceptions/exceptions.h>
#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 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) {}
};

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

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

    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_);
    }

private:
    const std::string backend_type_;

    unsigned int max_retries_;

    unsigned int retries_left_;

    unsigned int retry_interval_;
};

typedef boost::shared_ptr<ReconnectCtl> ReconnectCtlPtr;

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)
        :parameters_(parameters) {
    }

    virtual ~DatabaseConnection(){};

    virtual ReconnectCtlPtr makeReconnectCtl() const;

    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;

    typedef boost::function<bool (ReconnectCtlPtr db_retry)> DbLostCallback;

    bool invokeDbLostCallback() const;

    static isc::data::ElementPtr toElement(const ParameterMap& params);

    static isc::data::ElementPtr toElementDbAccessString(const std::string& dbaccess);

    static DbLostCallback db_lost_callback;

private:

    ParameterMap parameters_;

};

}; // end of isc::db namespace
}; // end of isc namespace

#endif // DATABASE_CONNECTION_H