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