communication_state.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_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 <dhcp/pkt.h>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#include <map>
#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 {
        return (partner_state_);
    }

    void setPartnerState(const std::string& state);

    void startHeartbeat(const long interval,
                        const boost::function<void()>& heartbeat_impl);

protected:

    void startHeartbeatInternal(const long interval = 0,
                                const boost::function<void()>& heartbeat_impl = 0);

public:

    void stopHeartbeat();

    bool isHeartbeatRunning() const {
        return (static_cast<bool>(timer_));
    }

    void poke();

    int64_t getDurationInMillisecs() const;

    bool isCommunicationInterrupted() const;

    virtual void analyzeMessage(const boost::shared_ptr<dhcp::Pkt>& message) = 0;

    virtual bool failureDetected() const = 0;

protected:

    virtual void clearUnackedClients() = 0;

public:

    bool clockSkewShouldWarn();

    bool clockSkewShouldTerminate() const;

protected:

    bool isClockSkewGreater(const long seconds) const;

public:

    void setPartnerTime(const std::string& time_text);

    std::string logFormatClockSkew() const;

protected:

    asiolink::IOServicePtr io_service_;

    HAConfigPtr config_;

    asiolink::IntervalTimerPtr timer_;

    long interval_;

    boost::posix_time::ptime poke_time_;

    boost::function<void()> heartbeat_impl_;

    int partner_state_;

    boost::posix_time::time_duration clock_skew_;

    boost::posix_time::ptime last_clock_skew_warn_;
};

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;

protected:

    virtual void clearUnackedClients();

    std::multimap<std::vector<uint8_t>, std::vector<uint8_t> > unacked_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;

protected:

    virtual void clearUnackedClients();

    std::set<std::vector<uint8_t> > unacked_clients_;
};

typedef boost::shared_ptr<CommunicationState6> CommunicationState6Ptr;

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

#endif