communication_state.h

Go to the documentation of this file.

// Copyright (C) 2018-2023 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_COMMUNICATION_STATE_H
#define HA_COMMUNICATION_STATE_H
 
#include <ha_config.h>
#include <ha_service_states.h>
#include <asiolink/interval_timer.h>
#include <asiolink/io_service.h>
#include <cc/data.h>
#include <dhcp/pkt.h>
 
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/composite_key.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/indexed_by.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
 
#include <functional>
#include <map>
#include <mutex>
#include <set>
#include <string>
#include <utility>
 
namespace isc {
namespace ha {
 
class CommunicationState {
public:
 
    CommunicationState(const asiolink::IOServicePtr& io_service,
                       const HAConfigPtr& config);
 
    virtual ~CommunicationState();
 
    int getPartnerState() const;
 
    void setPartnerState(const std::string& state);
 
    void setPartnerUnavailable();
 
private:
    void setPartnerStateInternal(const std::string& state);
 
public:
 
    boost::posix_time::time_duration getDurationSincePartnerStateTime() const;
 
private:
 
    void setCurrentPartnerStateTimeInternal();
 
public:
 
    std::set<std::string> getPartnerScopes() const;
 
    void setPartnerScopes(data::ConstElementPtr new_scopes);
 
private:
    void setPartnerScopesInternal(data::ConstElementPtr new_scopes);
 
public:
    void startHeartbeat(const long interval,
                        const std::function<void()>& heartbeat_impl);
 
    void stopHeartbeat();
 
private:
    void startHeartbeatInternal(const long interval = 0,
                                const std::function<void()>& heartbeat_impl = 0);
 
    void stopHeartbeatInternal();
 
public:
    bool isHeartbeatRunning() const;
 
    void poke();
 
private:
    void pokeInternal();
 
public:
    int64_t getDurationInMillisecs() const;
 
    bool isCommunicationInterrupted() const;
 
protected:
 
    static std::vector<uint8_t> getClientId(const dhcp::PktPtr& message,
                                            const uint16_t option_type);
public:
 
    virtual void analyzeMessage(const boost::shared_ptr<dhcp::Pkt>& message) = 0;
 
    size_t getAnalyzedMessagesCount() const;
 
    virtual bool failureDetected() const = 0;
 
    virtual size_t getConnectingClientsCount() const = 0;
 
    virtual size_t getUnackedClientsCount() const = 0;
 
protected:
 
    virtual void clearConnectingClients() = 0;
 
public:
 
    size_t getRejectedLeaseUpdatesCount();
 
protected:
 
    virtual size_t getRejectedLeaseUpdatesCountInternal() = 0;
 
    template<typename RejectedClientsType>
    static size_t getRejectedLeaseUpdatesCountFromContainer(RejectedClientsType& rejected_clients) {
        if (rejected_clients.empty()) {
            return (0);
        }
        auto& idx = rejected_clients.template get<1>();
        auto upper_limit = idx.upper_bound(time(NULL));
        if (upper_limit != idx.end()) {
            auto lower_limit = idx.cbegin();
            idx.erase(lower_limit, upper_limit);
        }
        return (rejected_clients.size());
    }
 
public:
 
    bool reportRejectedLeaseUpdate(const dhcp::PktPtr& message,
                                   const uint32_t lifetime = 86400);
 
protected:
 
    virtual bool reportRejectedLeaseUpdateInternal(const dhcp::PktPtr& message,
                                                   const uint32_t lifetime) = 0;
public:
 
    bool reportSuccessfulLeaseUpdate(const dhcp::PktPtr& message);
 
protected:
 
    virtual bool reportSuccessfulLeaseUpdateInternal(const dhcp::PktPtr& message) = 0;
 
public:
 
    void clearRejectedLeaseUpdates();
 
protected:
 
    virtual void clearRejectedLeaseUpdatesInternal() = 0;
 
public:
 
    bool clockSkewShouldWarn();
 
private:
    bool clockSkewShouldWarnInternal();
 
public:
    bool clockSkewShouldTerminate();
 
private:
    bool clockSkewShouldTerminateInternal();
 
    bool isClockSkewGreater(const long seconds) const;
 
public:
 
    bool rejectedLeaseUpdatesShouldTerminate();
 
private:
 
    bool rejectedLeaseUpdatesShouldTerminateInternal();
 
public:
 
    void setPartnerTime(const std::string& time_text);
 
private:
 
    void setPartnerTimeInternal(const std::string& time_text);
 
    void resetPartnerTimeInternal();
 
public:
    std::string logFormatClockSkew() const;
 
private:
    std::string logFormatClockSkewInternal() const;
 
public:
    data::ElementPtr getReport() const;
 
    void modifyPokeTime(const long secs);
 
private:
 
    int64_t getDurationInMillisecsInternal() const;
 
protected:
    boost::posix_time::time_duration updatePokeTime();
 
private:
    boost::posix_time::time_duration updatePokeTimeInternal();
 
public:
 
    uint64_t getUnsentUpdateCount() const;
 
    void increaseUnsentUpdateCount();
 
private:
 
    void increaseUnsentUpdateCountInternal();
 
public:
 
    bool hasPartnerNewUnsentUpdates() const;
 
private:
 
    bool hasPartnerNewUnsentUpdatesInternal() const;
 
public:
 
    void setPartnerUnsentUpdateCount(uint64_t unsent_update_count);
 
private:
 
    void setPartnerUnsentUpdateCountInternal(uint64_t unsent_update_count);
 
protected:
    asiolink::IOServicePtr io_service_;
 
    HAConfigPtr config_;
 
    asiolink::IntervalTimerPtr timer_;
 
    long interval_;
 
    boost::posix_time::ptime poke_time_;
 
    std::function<void()> heartbeat_impl_;
 
    int partner_state_;
 
    boost::posix_time::ptime partner_state_time_;
 
    std::set<std::string> partner_scopes_;
 
    boost::posix_time::time_duration clock_skew_;
 
    boost::posix_time::ptime last_clock_skew_warn_;
 
    boost::posix_time::ptime my_time_at_skew_;
 
    boost::posix_time::ptime partner_time_at_skew_;
 
    size_t analyzed_messages_count_;
 
    uint64_t unsent_update_count_;
 
    std::pair<uint64_t, uint64_t> partner_unsent_update_count_;
 
    const boost::scoped_ptr<std::mutex> mutex_;
};
 
typedef boost::shared_ptr<CommunicationState> CommunicationStatePtr;
 
 
class CommunicationState4 : public CommunicationState {
public:
 
    CommunicationState4(const asiolink::IOServicePtr& io_service,
                        const HAConfigPtr& config);
 
    virtual void analyzeMessage(const boost::shared_ptr<dhcp::Pkt>& message);
 
    virtual bool failureDetected() const;
 
    virtual size_t getConnectingClientsCount() const;
 
    virtual size_t getUnackedClientsCount() const;
 
protected:
 
    virtual size_t getRejectedLeaseUpdatesCountInternal();
 
    virtual bool reportRejectedLeaseUpdateInternal(const dhcp::PktPtr& message,
                                                   const uint32_t lifetime);
 
    virtual bool reportSuccessfulLeaseUpdateInternal(const dhcp::PktPtr& message);
 
    virtual void clearRejectedLeaseUpdatesInternal();
 
    virtual void analyzeMessageInternal(const boost::shared_ptr<dhcp::Pkt>& message);
 
    virtual bool failureDetectedInternal() const;
 
    virtual void clearConnectingClients();
 
    template<typename ClientData>
    using ClientIdent4 = boost::multi_index::hashed_unique<
        boost::multi_index::composite_key<
            ClientData,
            boost::multi_index::member<ClientData, std::vector<uint8_t>,
                                       &ClientData::hwaddr_>,
            boost::multi_index::member<ClientData, std::vector<uint8_t>,
                                       &ClientData::clientid_>
            >
        >;
 
    struct ConnectingClient4 {
        std::vector<uint8_t> hwaddr_;
        std::vector<uint8_t> clientid_;
        bool unacked_;
    };
 
    typedef boost::multi_index_container<
        ConnectingClient4,
        boost::multi_index::indexed_by<
            // First index is a composite index which allows to find a client
            // by the HW address/client identifier tuple.
            ClientIdent4<ConnectingClient4>,
            // Second index allows for counting all clients which are
            // considered unacked.
            boost::multi_index::ordered_non_unique<
                boost::multi_index::member<ConnectingClient4, bool, &ConnectingClient4::unacked_>
            >
        >
    > ConnectingClients4;
 
    ConnectingClients4 connecting_clients_;
 
    struct RejectedClient4 {
        std::vector<uint8_t> hwaddr_;
        std::vector<uint8_t> clientid_;
        int64_t expire_;
    };
 
    typedef boost::multi_index_container<
        RejectedClient4,
        boost::multi_index::indexed_by<
            ClientIdent4<RejectedClient4>,
            boost::multi_index::ordered_non_unique<
                boost::multi_index::member<RejectedClient4, int64_t,
                                           &RejectedClient4::expire_>
            >
        >
    > RejectedClients4;
 
    RejectedClients4 rejected_clients_;
};
 
typedef boost::shared_ptr<CommunicationState4> CommunicationState4Ptr;
 
class CommunicationState6 : public CommunicationState {
public:
 
    CommunicationState6(const asiolink::IOServicePtr& io_service,
                        const HAConfigPtr& config);
 
    virtual void analyzeMessage(const boost::shared_ptr<dhcp::Pkt>& message);
 
    virtual bool failureDetected() const;
 
    virtual size_t getConnectingClientsCount() const;
 
    virtual size_t getUnackedClientsCount() const;
 
protected:
 
    virtual size_t getRejectedLeaseUpdatesCountInternal();
 
    virtual bool reportRejectedLeaseUpdateInternal(const dhcp::PktPtr& message,
                                                   const uint32_t lifetime = 86400);
 
    virtual bool reportSuccessfulLeaseUpdateInternal(const dhcp::PktPtr& message);
 
    virtual void clearRejectedLeaseUpdatesInternal();
 
protected:
 
    virtual void analyzeMessageInternal(const boost::shared_ptr<dhcp::Pkt>& message);
 
    virtual bool failureDetectedInternal() const;
 
    virtual void clearConnectingClients();
 
    template<typename ClientData>
    using ClientIdent6 = boost::multi_index::hashed_unique<
        boost::multi_index::member<ClientData, std::vector<uint8_t>,
                                   &ClientData::duid_>
        >;
 
    struct ConnectingClient6 {
        std::vector<uint8_t> duid_;
        bool unacked_;
    };
 
    typedef boost::multi_index_container<
        ConnectingClient6,
        boost::multi_index::indexed_by<
            // First index is for accessing connecting clients by DUID.
            ClientIdent6<ConnectingClient6>,
            // Second index allows for counting all clients which are
            // considered unacked.
            boost::multi_index::ordered_non_unique<
                boost::multi_index::member<ConnectingClient6, bool, &ConnectingClient6::unacked_>
            >
        >
    > ConnectingClients6;
 
    ConnectingClients6 connecting_clients_;
 
    struct RejectedClient6 {
        std::vector<uint8_t> duid_;
        int64_t expire_;
    };
 
    typedef boost::multi_index_container<
        RejectedClient6,
        boost::multi_index::indexed_by<
            ClientIdent6<RejectedClient6>,
            boost::multi_index::ordered_non_unique<
                boost::multi_index::member<RejectedClient6, int64_t,
                                           &RejectedClient6::expire_>
            >
        >
    > RejectedClients6;
 
    RejectedClients6 rejected_clients_;
};
 
typedef boost::shared_ptr<CommunicationState6> CommunicationState6Ptr;
 
} // end of namespace isc::ha
} // end of namespace isc
 
#endif