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