communication_state.h

Go to the documentation of this file.

// Copyright (C) 2018-2022 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);

private:
    void setPartnerStateInternal(const std::string& state);

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);

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_;

    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