communication_state.h

Go to the documentation of this file.

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

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;

    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:

    bool clockSkewShouldWarn();

private:
    bool clockSkewShouldWarnInternal();

public:
    bool clockSkewShouldTerminate() const;

private:
    bool clockSkewShouldTerminateInternal() const;

    bool isClockSkewGreater(const long seconds) const;

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

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

    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 void analyzeMessageInternal(const boost::shared_ptr<dhcp::Pkt>& message);

    virtual bool failureDetectedInternal() const;

    virtual void clearConnectingClients();

    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.
            boost::multi_index::hashed_unique<
                boost::multi_index::composite_key<
                    ConnectingClient4,
                    boost::multi_index::member<ConnectingClient4, std::vector<uint8_t>,
                                               &ConnectingClient4::hwaddr_>,
                    boost::multi_index::member<ConnectingClient4, std::vector<uint8_t>,
                                               &ConnectingClient4::clientid_>
                >
            >,
            // 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_;
};

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 void analyzeMessageInternal(const boost::shared_ptr<dhcp::Pkt>& message);

    virtual bool failureDetectedInternal() const;

    virtual void clearConnectingClients();

    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.
            boost::multi_index::hashed_unique<
                boost::multi_index::member<ConnectingClient6, std::vector<uint8_t>,
                                           &ConnectingClient6::duid_>
            >,
            // 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_;
};

typedef boost::shared_ptr<CommunicationState6> CommunicationState6Ptr;

} // end of namespace isc::ha
} // end of namespace isc

#endif