ha_service.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_SERVICE_H
#define HA_SERVICE_H
 
#include <communication_state.h>
#include <ha_config.h>
#include <ha_server_type.h>
#include <query_filter.h>
#include <asiolink/io_service.h>
#include <cc/data.h>
#include <dhcp/pkt4.h>
#include <http/response.h>
#include <dhcp/pkt4.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 <vector>
 
namespace isc {
namespace ha {
 
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;
 
protected:
 
   typedef std::function<void(const bool, const std::string&)> PostRequestCallback;
 
    typedef std::function<void(const bool, const std::string&, const bool)> PostSyncCallback;
 
public:
 
    HAService(const asiolink::IOServicePtr& io_service,
              const dhcp::NetworkStatePtr& network_state,
              const HAConfigPtr& config,
              const HAServerType& server_type = HAServerType::DHCPv4);
 
    HAServerType getServerType() const {
        return (server_type_);
    }
 
    virtual void defineEvents();
 
    virtual void verifyEvents();
 
    virtual void defineStates();
 
    void backupStateHandler();
 
    void normalStateHandler();
 
    void partnerDownStateHandler();
 
    void readyStateHandler();
 
    void syncingStateHandler();
 
    void terminatedStateHandler();
 
    void waitingStateHandler();
 
protected:
 
    void verboseTransition(const unsigned state);
 
public:
 
    bool unpause();
 
protected:
 
    void conditionalLogPausedState() const;
 
public:
 
    void serveDefaultScopes();
 
    bool inScope(dhcp::Pkt4Ptr& query4);
 
    bool inScope(dhcp::Pkt6Ptr& query6);
 
private:
 
    template<typename QueryPtrType>
    bool inScopeInternal(QueryPtrType& query);
 
public:
 
    void adjustNetworkState();
 
protected:
 
    bool shouldPartnerDown() const;
 
    bool shouldTerminate() 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 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);
 
    bool shouldSendLeaseUpdates(const HAConfig::PeerConfigPtr& peer_config) const;
 
public:
 
    data::ConstElementPtr processHeartbeat();
 
protected:
 
    void asyncSendHeartbeat();
 
    void scheduleHeartbeat();
 
    void startHeartbeat();
 
    void asyncDisableDHCPService(http::HttpClient& http_client,
                                 const std::string& server_name,
                                 const unsigned int max_period,
                                 PostRequestCallback post_request_action);
 
    void asyncEnableDHCPService(http::HttpClient& http_client,
                                const std::string& server_name,
                                PostRequestCallback post_request_action);
 
    void localDisableDHCPService();
 
    void localEnableDHCPService();
 
    void asyncSyncLeases();
 
    void asyncSyncLeases(http::HttpClient& http_client,
                         const std::string& server_name,
                         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 std::string& server_name,
                                 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 std::string& server_name,
                    const unsigned int max_period);
 
public:
 
    data::ConstElementPtr processScopes(const std::vector<std::string>& scopes);
 
    data::ConstElementPtr processContinue();
 
protected:
 
    data::ConstElementPtr verifyAsyncResponse(const http::HttpResponsePtr& response);
 
    asiolink::IOServicePtr io_service_;
 
    dhcp::NetworkStatePtr network_state_;
 
    HAConfigPtr config_;
 
    HAServerType server_type_;
 
    http::HttpClient client_;
 
    CommunicationStatePtr communication_state_;
 
    QueryFilter query_filter_;
 
    std::map<boost::shared_ptr<dhcp::Pkt>, int> pending_requests_;
};
 
typedef boost::shared_ptr<HAService> HAServicePtr;
 
} // end of namespace isc::ha
} // end of namespace isc
 
#endif