ha_config.h

Go to the documentation of this file.

// Copyright (C) 2018-2021 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 <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 {
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();

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

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

    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_;            
    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_;     
    PeerConfigMap peers_;                      
    StateMachineConfigPtr state_machine_;      
};

typedef boost::shared_ptr<HAConfig> HAConfigPtr;

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

#endif