ha_service.h

Go to the documentation of this file.

// Copyright (C) 2018-2025 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_SERVICE_H
#define HA_SERVICE_H
 
#include <communication_state.h>
#include <ha_config.h>
#include <ha_server_type.h>
#include <lease_sync_filter.h>
#include <lease_update_backlog.h>
#include <query_filter.h>
#include <asiolink/asio_wrapper.h>
#include <asiolink/io_service.h>
#include <asiolink/tls_socket.h>
#include <cc/data.h>
#include <config/cmd_http_listener.h>
#include <dhcp/pkt4.h>
#include <http/response.h>
#include <dhcpsrv/lease.h>
#include <dhcpsrv/network_state.h>
#include <hooks/parking_lots.h>
#include <http/client.h>
#include <util/state_model.h>
 
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <functional>
#include <map>
#include <mutex>
#include <vector>
 
namespace isc {
namespace ha {
 
class HAService;
 
typedef HARelationshipMapper<HAService> HAServiceMapper;
 
typedef boost::shared_ptr<HAServiceMapper> HAServiceMapperPtr;
 
class HAService : public boost::noncopyable, public util::StateModel {
public:
 
    static const int HA_HEARTBEAT_COMPLETE_EVT = SM_DERIVED_EVENT_MIN + 1;
 
    static const int HA_LEASE_UPDATES_COMPLETE_EVT = SM_DERIVED_EVENT_MIN + 2;
 
    static const int HA_SYNCING_FAILED_EVT = SM_DERIVED_EVENT_MIN + 3;
 
    static const int HA_SYNCING_SUCCEEDED_EVT = SM_DERIVED_EVENT_MIN + 4;
 
    static const int HA_MAINTENANCE_NOTIFY_EVT = SM_DERIVED_EVENT_MIN + 5;
 
    static const int HA_MAINTENANCE_START_EVT = SM_DERIVED_EVENT_MIN + 6;
 
    static const int HA_MAINTENANCE_CANCEL_EVT = SM_DERIVED_EVENT_MIN + 7;
 
    static const int HA_SYNCED_PARTNER_UNAVAILABLE_EVT = SM_DERIVED_EVENT_MIN + 8;
 
    static const int HA_CONTROL_RESULT_MAINTENANCE_NOT_ALLOWED = 1001;
 
    static const int HA_WAITING_TO_TERMINATED_ST_DELAY_MINUTES = 10;
 
protected:
 
   typedef std::function<void(const bool, const std::string&, const int)> PostRequestCallback;
 
    typedef std::function<void(const bool, const std::string&, const bool)> PostSyncCallback;
 
public:
 
    HAService(const unsigned int id,
              const asiolink::IOServicePtr& io_service,
              const dhcp::NetworkStatePtr& network_state,
              const HAConfigPtr& config,
              const HAServerType& server_type = HAServerType::DHCPv4);
 
    virtual ~HAService();
 
    HAServerType getServerType() const {
        return (server_type_);
    }
 
private:
 
    unsigned int getLocalOrigin() const {
        return (dhcp::NetworkState::HA_LOCAL_COMMAND + id_);
    }
 
    unsigned int getRemoteOrigin() const {
        return (dhcp::NetworkState::HA_REMOTE_COMMAND + id_);
    }
 
    std::string getCSCallbacksSetName() const;
 
    virtual void defineEvents();
 
    virtual void verifyEvents();
 
    virtual void defineStates();
 
    void backupStateHandler();
 
    void communicationRecoveryHandler();
 
    void normalStateHandler();
 
    void inMaintenanceStateHandler();
 
    void partnerDownStateHandler();
 
    void partnerInMaintenanceStateHandler();
 
    void passiveBackupStateHandler();
 
    void readyStateHandler();
 
    void syncingStateHandler();
 
    void terminatedStateHandler();
 
    void waitingStateHandler();
 
    int getPartnerState() const {
        return (communication_state_->getPartnerState());
    }
 
protected:
 
    void verboseTransition(const unsigned state);
 
    int getNormalState() const;
 
public:
 
    bool unpause();
 
protected:
 
    void conditionalLogPausedState() const;
 
public:
 
    void serveDefaultScopes();
 
    void serveFailoverScopes();
 
    bool inScope(dhcp::Pkt4Ptr& query4);
 
    bool inScope(dhcp::Pkt6Ptr& query6);
 
private:
 
    template<typename QueryPtrType>
    bool inScopeInternal(QueryPtrType& query);
 
public:
 
    bool shouldReclaim(const dhcp::Lease4Ptr& lease4) const;
 
    bool shouldReclaim(const dhcp::Lease6Ptr& lease6) const;
 
private:
 
    template<typename LeaseTypePtr>
    bool shouldReclaimInternal(const LeaseTypePtr& lease) const;
 
public:
 
    void adjustNetworkState();
 
protected:
 
    bool shouldPartnerDown() const;
 
    bool shouldTerminate() const;
 
    bool isMaintenanceCanceled() const;
 
    bool isPartnerStateInvalid() const;
 
public:
 
    size_t asyncSendLeaseUpdates(const dhcp::Pkt4Ptr& query,
                                 const dhcp::Lease4CollectionPtr& leases,
                                 const dhcp::Lease4CollectionPtr& deleted_leases,
                                 const hooks::ParkingLotHandlePtr& parking_lot);
 
    size_t asyncSendSingleLeaseUpdate(const dhcp::Pkt4Ptr& query,
                                      const dhcp::Lease4Ptr& lease,
                                      const hooks::ParkingLotHandlePtr& parking_lot);
 
    size_t asyncSendLeaseUpdates(const dhcp::Pkt6Ptr& query,
                                 const dhcp::Lease6CollectionPtr& leases,
                                 const dhcp::Lease6CollectionPtr& deleted_leases,
                                 const hooks::ParkingLotHandlePtr& parking_lot);
 
protected:
 
    template<typename QueryPtrType>
    void asyncSendLeaseUpdate(const QueryPtrType& query,
                              const HAConfig::PeerConfigPtr& config,
                              const data::ConstElementPtr& command,
                              const hooks::ParkingLotHandlePtr& parking_lot);
 
    void logFailedLeaseUpdates(const dhcp::PktPtr& query,
                               const data::ConstElementPtr& args) const;
 
    bool shouldSendLeaseUpdates(const HAConfig::PeerConfigPtr& peer_config) const;
 
    bool shouldQueueLeaseUpdates(const HAConfig::PeerConfigPtr& peer_config) const;
 
public:
 
    data::ConstElementPtr processHeartbeat();
 
    data::ConstElementPtr processStatusGet() const;
 
    data::ConstElementPtr processHAReset();
 
protected:
 
    void asyncSendHeartbeat();
 
    void scheduleHeartbeat();
 
    void startHeartbeat();
 
    void asyncDisableDHCPService(http::HttpClient& http_client,
                                 const HAConfig::PeerConfigPtr& remote_config,
                                 const unsigned int max_period,
                                 PostRequestCallback post_request_action);
 
    void asyncEnableDHCPService(http::HttpClient& http_client,
                                const HAConfig::PeerConfigPtr& remote_config,
                                PostRequestCallback post_request_action);
 
    void localDisableDHCPService();
 
    void localEnableDHCPService();
 
    void asyncSyncLeases();
 
    void asyncSyncLeases(http::HttpClient& http_client,
                         const HAConfig::PeerConfigPtr& remote_config,
                         const unsigned int max_period,
                         const dhcp::LeasePtr& last_lease,
                         PostSyncCallback post_sync_action,
                         const bool dhcp_disabled = false);
 
    void asyncSyncLeasesInternal(http::HttpClient& http_client,
                                 const HAConfig::PeerConfigPtr& remote_config,
                                 const unsigned int max_period,
                                 const dhcp::LeasePtr& last_lease,
                                 PostSyncCallback post_sync_action,
                                 const bool dhcp_disabled);
 
public:
 
    data::ConstElementPtr processSynchronize(const std::string& server_name,
                                             const unsigned int max_period);
 
protected:
 
    int synchronize(std::string& status_message,
                    const HAConfig::PeerConfigPtr& remote_config,
                    const unsigned int max_period);
 
    void asyncSendLeaseUpdatesFromBacklog(http::HttpClient& http_client,
                                          const HAConfig::PeerConfigPtr& remote_config,
                                          PostRequestCallback post_request_action);
 
    bool sendLeaseUpdatesFromBacklog();
 
    void asyncSendHAReset(http::HttpClient& http_client,
                          const HAConfig::PeerConfigPtr& remote_config,
                          PostRequestCallback post_request_action);
 
    bool sendHAReset();
 
public:
 
    data::ConstElementPtr processScopes(const std::vector<std::string>& scopes);
 
    data::ConstElementPtr processContinue();
 
    data::ConstElementPtr processMaintenanceNotify(const bool cancel,
                                                   const std::string& state);
 
    data::ConstElementPtr processMaintenanceStart();
 
    data::ConstElementPtr processMaintenanceCancel();
 
    void checkPermissionsClientAndListener();
 
protected:
 
    void asyncSyncCompleteNotify(http::HttpClient& http_client,
                                 const HAConfig::PeerConfigPtr& remote_config,
                                 PostRequestCallback post_request_action);
 
public:
 
    data::ConstElementPtr processSyncCompleteNotify(const unsigned int origin_id);
 
    void startClientAndListener();
 
    void pauseClientAndListener();
 
    void resumeClientAndListener();
 
    void stopClientAndListener();
 
protected:
 
    data::ConstElementPtr verifyAsyncResponse(const http::HttpResponsePtr& response,
                                              int& rcode);
 
    bool clientConnectHandler(const boost::system::error_code& ec, int tcp_native_fd);
 
    bool clientHandshakeHandler(const boost::system::error_code&) {
        return (true);
    }
 
    void socketReadyHandler(int tcp_native_fd);
 
    void clientCloseHandler(int tcp_native_fd);
 
    unsigned int id_;
 
    asiolink::IOServicePtr io_service_;
 
    dhcp::NetworkStatePtr network_state_;
 
    HAConfigPtr config_;
 
    HAServerType server_type_;
 
    http::HttpClientPtr client_;
 
    config::CmdHttpListenerPtr listener_;
 
    CommunicationStatePtr communication_state_;
 
    QueryFilter query_filter_;
 
    LeaseSyncFilter lease_sync_filter_;
 
    template<typename QueryPtrType>
    bool leaseUpdateComplete(QueryPtrType& query,
                             const hooks::ParkingLotHandlePtr& parking_lot);
 
    template<typename QueryPtrType>
    void updatePendingRequest(QueryPtrType& query);
 
    size_t pendingRequestSize();
 
    template<typename QueryPtrType>
    int getPendingRequest(const QueryPtrType& query);
 
private:
    template<typename QueryPtrType>
    bool leaseUpdateCompleteInternal(QueryPtrType& query,
                                     const hooks::ParkingLotHandlePtr& parking_lot);
 
    template<typename QueryPtrType>
    void updatePendingRequestInternal(QueryPtrType& query);
 
    template<typename QueryPtrType>
    int getPendingRequestInternal(const QueryPtrType& query);
 
    std::mutex mutex_;
 
    std::map<boost::shared_ptr<dhcp::Pkt>, int> pending_requests_;
 
protected:
 
    LeaseUpdateBacklog lease_update_backlog_;
 
    bool sync_complete_notified_;
};
 
typedef boost::shared_ptr<HAService> HAServicePtr;
 
} // end of namespace isc::ha
} // end of namespace isc
 
#endif