ha_config.h

Go to the documentation of this file.

// Copyright (C) 2018-2023 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 <ha_relationship_mapper.h>
#include <asiolink/crypto_tls.h>
#include <exceptions/exceptions.h>
#include <http/basic_auth.h>
#include <http/post_request_json.h>
#include <http/url.h>
#include <util/optional.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;
 
typedef boost::shared_ptr<HAConfig> HAConfigPtr;
 
typedef HARelationshipMapper<HAConfig> HAConfigMapper;
 
typedef boost::shared_ptr<HAConfigMapper> HAConfigMapperPtr;
 
class HAConfig {
public:
 
    enum HAMode {
        LOAD_BALANCING,
        HOT_STANDBY,
        PASSIVE_BACKUP
    };
 
    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;
        }
 
        util::Optional<std::string> getTrustAnchor() const {
            return (trust_anchor_);
        }
 
        void setTrustAnchor(const util::Optional<std::string>& ca) {
            trust_anchor_ = ca;
        }
 
        util::Optional<std::string> getCertFile() const {
            return (cert_file_);
        }
 
        void setCertFile(const util::Optional<std::string>& cert) {
            cert_file_ = cert;
        }
 
        util::Optional<std::string> getKeyFile() const {
            return (key_file_);
        }
 
        void setKeyFile(const util::Optional<std::string>& key) {
            key_file_ = key;
        }
 
        asiolink::TlsContextPtr getTlsContext() const {
            return (tls_context_);
        }
 
        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;
        }
 
        http::BasicHttpAuthPtr& getBasicAuth() {
            return (basic_auth_);
        }
 
        const http::BasicHttpAuthPtr& getBasicAuth() const {
            return (basic_auth_);
        }
 
        void addBasicAuthHttpHeader(http::PostHttpRequestJsonPtr request) const;
 
        asiolink::TlsContextPtr tls_context_;
 
    private:
 
        std::string name_;                          
        http::Url url_;                             
        util::Optional<std::string> trust_anchor_;  
        util::Optional<std::string> cert_file_;     
        util::Optional<std::string> key_file_;      
        Role role_;                                 
        bool auto_failover_;                        
        http::BasicHttpAuthPtr basic_auth_;         
    };
 
    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();
 
    static HAConfigPtr create();
 
    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 getDelayedUpdatesLimit() const {
        return (delayed_updates_limit_);
    }
 
    void setDelayedUpdatesLimit(const uint32_t delayed_updates_limit) {
        delayed_updates_limit_ = delayed_updates_limit;
    }
 
    bool amAllowingCommRecovery() const {
        return (delayed_updates_limit_ > 0);
    }
 
    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;
    }
 
    uint32_t getMaxRejectedLeaseUpdates() const {
        return (max_rejected_lease_updates_);
    }
 
    void setMaxRejectedLeaseUpdates(const uint32_t max_rejected_lease_updates) {
        max_rejected_lease_updates_ = max_rejected_lease_updates;
    }
 
    void setWaitBackupAck(const bool wait_backup_ack) {
        wait_backup_ack_ = wait_backup_ack;
    }
 
    bool amWaitingBackupAck() const {
        return (wait_backup_ack_);
    }
 
    bool getEnableMultiThreading() {
        return (enable_multi_threading_);
    }
 
    void setEnableMultiThreading(bool enable_multi_threading) {
        enable_multi_threading_ = enable_multi_threading;
    }
 
    bool getHttpDedicatedListener() {
        return (http_dedicated_listener_);
    }
 
    void setHttpDedicatedListener(bool http_dedicated_listener) {
        http_dedicated_listener_ = http_dedicated_listener;
    }
 
    uint32_t getHttpListenerThreads() {
        return (http_listener_threads_);
    }
 
    void setHttpListenerThreads(uint32_t http_listener_threads) {
        http_listener_threads_ = http_listener_threads;
    }
 
    uint32_t getHttpClientThreads() {
        return (http_client_threads_);
    }
 
    void setHttpClientThreads(uint32_t http_client_threads) {
        http_client_threads_ = http_client_threads;
    }
 
    util::Optional<std::string> getTrustAnchor() const {
        return (trust_anchor_);
    }
 
    void setTrustAnchor(const util::Optional<std::string>& ca) {
        trust_anchor_ = ca;
    }
 
    util::Optional<std::string> getCertFile() const {
        return (cert_file_);
    }
 
    void setCertFile(const util::Optional<std::string>& cert) {
        cert_file_ = cert;
    }
 
    util::Optional<std::string> getKeyFile() const {
        return (key_file_);
    }
 
    void setKeyFile(const util::Optional<std::string>& key) {
        key_file_ = key;
    }
 
    bool getRequireClientCerts() const {
        return (require_client_certs_);
    }
 
    void setRequireClientCerts(bool flag) {
        require_client_certs_ = flag;
    }
 
    bool getRestrictCommands() const {
        return (restrict_commands_);
    }
 
    void setRestrictCommands(bool flag) {
        restrict_commands_ = flag;
    }
 
    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();
 
    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 delayed_updates_limit_;          
    uint32_t heartbeat_delay_;                
    uint32_t max_response_delay_;             
    uint32_t max_ack_delay_;                  
    uint32_t max_unacked_clients_;            
    uint32_t max_rejected_lease_updates_;     
    bool wait_backup_ack_;                    
    bool enable_multi_threading_;             
    bool http_dedicated_listener_;            
    uint32_t http_listener_threads_;          
    uint32_t http_client_threads_;            
    util::Optional<std::string> trust_anchor_; 
    util::Optional<std::string> cert_file_;    
    util::Optional<std::string> key_file_;     
    bool require_client_certs_;                
    bool restrict_commands_;                   
    PeerConfigMap peers_;                      
    StateMachineConfigPtr state_machine_;      
};
 
} // end of namespace isc::ha
} // end of namespace isc
 
#endif