ha_config.h

Go to the documentation of this file.

// Copyright (C) 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 HA_CONFIG_H
#define HA_CONFIG_H

#include <exceptions/exceptions.h>
#include <http/url.h>
#include <util/state_model.h>
#include <boost/shared_ptr.hpp>
#include <cstdint>
#include <map>
#include <string>

namespace isc {
namespace ha {

class HAConfigValidationError : public Exception {
public:
    HAConfigValidationError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};

class HAConfig {
public:

    enum HAMode {
        LOAD_BALANCING,
        HOT_STANDBY,
    };

    class PeerConfig {
    public:

        enum Role {
            PRIMARY,
            SECONDARY,
            STANDBY,
            BACKUP
        };

        PeerConfig();

        std::string getName() const {
            return (name_);
        }

        void setName(const std::string& name);

        http::Url getUrl() const {
            return (url_);
        }

        void setUrl(const http::Url& url) {
            url_ = url;
        }

        std::string getLogLabel() const;

        Role getRole() const {
            return (role_);
        }

        void setRole(const std::string& role);

        static Role stringToRole(const std::string& role);

        static std::string roleToString(const HAConfig::PeerConfig::Role& role);

        bool isAutoFailover() const {
            return (auto_failover_);
        }

        void setAutoFailover(const bool auto_failover) {
            auto_failover_ = auto_failover;
        }

    private:

        std::string name_;   
        http::Url url_;      
        Role role_;          
        bool auto_failover_; 

    };

    typedef boost::shared_ptr<PeerConfig> PeerConfigPtr;

    typedef std::map<std::string, PeerConfigPtr> PeerConfigMap;


    class StateConfig {
    public:

        explicit StateConfig(const int state);

        int getState() const {
            return (state_);
        }

        util::StatePausing getPausing() const {
            return (pausing_);
        }

        void setPausing(const std::string& pausing);

        static util::StatePausing stringToPausing(const std::string& pausing);

        static std::string pausingToString(const util::StatePausing& pausing);

    private:

        int state_;

        util::StatePausing pausing_;
    };

    typedef boost::shared_ptr<StateConfig> StateConfigPtr;

    class StateMachineConfig {
    public:

        StateMachineConfig()
            :  states_() {
        }

        StateConfigPtr getStateConfig(const int state);

    private:

        std::map<int, StateConfigPtr> states_;
    };

    typedef boost::shared_ptr<StateMachineConfig> StateMachineConfigPtr;

    HAConfig();

    PeerConfigPtr selectNextPeerConfig(const std::string& name);

    std::string getThisServerName() const {
        return (this_server_name_);
    }

    void setThisServerName(const std::string& this_server_name);

    HAMode getHAMode() const {
        return (ha_mode_);
    }

    void setHAMode(const std::string& ha_mode);

    static HAMode stringToHAMode(const std::string& ha_mode);

    static std::string HAModeToString(const HAMode& ha_mode);

    bool amSendingLeaseUpdates() const {
        return (send_lease_updates_);
    }

    void setSendLeaseUpdates(const bool send_lease_updates) {
        send_lease_updates_ = send_lease_updates;
    }

    bool amSyncingLeases() const {
        return (sync_leases_);
    }

    void setSyncLeases(const bool sync_leases) {
        sync_leases_ = sync_leases;
    }

    uint32_t getSyncTimeout() const {
        return (sync_timeout_);
    }

    void setSyncTimeout(const uint32_t sync_timeout) {
        sync_timeout_ = sync_timeout;
    }

    uint32_t getSyncPageLimit() const {
        return (sync_page_limit_);
    }

    void setSyncPageLimit(const uint32_t sync_page_limit) {
        sync_page_limit_ = sync_page_limit;
    }

    uint32_t getHeartbeatDelay() const {
        return (heartbeat_delay_);
    }

    void setHeartbeatDelay(const uint32_t heartbeat_delay) {
        heartbeat_delay_ = heartbeat_delay;
    }

    uint32_t getMaxResponseDelay() const {
        return (max_response_delay_);
    }

    void setMaxResponseDelay(const uint32_t max_response_delay) {
        max_response_delay_ = max_response_delay;
    }

    uint32_t getMaxAckDelay() const {
        return (max_ack_delay_);
    }

    void setMaxAckDelay(const uint32_t max_ack_delay) {
        max_ack_delay_ = max_ack_delay;
    }

    uint32_t getMaxUnackedClients() const {
        return (max_unacked_clients_);
    }

    void setMaxUnackedClients(const uint32_t max_unacked_clients) {
        max_unacked_clients_ = max_unacked_clients;
    }

    PeerConfigPtr getPeerConfig(const std::string& name) const;

    PeerConfigPtr getFailoverPeerConfig() const;

    PeerConfigPtr getThisServerConfig() const;

    PeerConfigMap getOtherServersConfig() const;

    PeerConfigMap getAllServersConfig() const {
        return (peers_);
    }

    StateMachineConfigPtr getStateMachineConfig() const {
        return (state_machine_);
    }

    void validate() const;

    std::string this_server_name_;        
    HAMode ha_mode_;                      
    bool send_lease_updates_;             
    bool sync_leases_;                    
    uint32_t sync_timeout_;               
    uint32_t sync_page_limit_;            
    uint32_t heartbeat_delay_;            
    uint32_t max_response_delay_;         
    uint32_t max_ack_delay_;              
    uint32_t max_unacked_clients_;        
    PeerConfigMap peers_;                 
    StateMachineConfigPtr state_machine_; 
};

typedef boost::shared_ptr<HAConfig> HAConfigPtr;

} // end of namespace isc::ha
} // end of namespace isc

#endif