ha_service.h

Go to the documentation of this file.

// Copyright (C) 2018-2026 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 <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 <dhcpsrv/lease.h>
#include <dhcpsrv/network_state.h>
#include <high_availability/communication_state.h>
#include <high_availability/ha_config.h>
#include <high_availability/ha_server_type.h>
#include <high_availability/lease_sync_filter.h>
#include <high_availability/lease_update_backlog.h>
#include <high_availability/query_filter.h>
#include <hooks/parking_lots.h>
#include <http/client.h>
#include <http/response.h>
#include <util/state_model.h>
 
#include <functional>
#include <map>
#include <mutex>
#include <vector>
 
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
 
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