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