bfd_proto.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Juniper Networks, Inc. All rights reserved.
 */
 
#ifndef vnsw_agent_bfd_proto_h_
#define vnsw_agent_bfd_proto_h_
 
#include <mutex>
 
#include "pkt/proto.h"
#include "pkt/pkt_handler.h"
#include "services/bfd_handler.h"
#include "oper/health_check.h"
 
#include "bfd/bfd_client.h"
#include "bfd/bfd_server.h"
#include "bfd/bfd_connection.h"
#include "bfd/bfd_session.h"
 
#include "base/test/task_test_util.h"
 
#define BFD_TX_BUFF_LEN 128
 
#define BFD_TRACE(obj, ...)                                                 \
do {                                                                        \
    Bfd##obj::TraceMsg(BfdTraceBuf, __FILE__, __LINE__, ##__VA_ARGS__);     \
} while (false)
 
class BfdSessionsKey {
public:
    BfdSessionsKey(uint32_t id, IpAddress ip) :
        id_(id), ip_(ip) {
    }
 
    ~BfdSessionsKey () { }
 
    bool operator<(const BfdSessionsKey &right) const {
        if ( id_ == right.id_ ) {
            return ip_ < right.ip_;
        } else {
            return id_ < right.id_;
        }
    }
 
    bool IsLess(const BfdSessionsKey &rhs) const;
    bool IsEqual(const BfdSessionsKey &rhs) const;
 
    uint32_t id_;
    IpAddress ip_;
};
 
struct BfdSessionsKeyCmp {
    bool operator()(const BfdSessionsKey &lhs, const BfdSessionsKey &rhs) const {
        return lhs.IsLess(rhs);
    }
};
 
class BfdProto : public Proto {
public:
    static const uint32_t kMultiplier = 2;
    static const uint32_t kMinRxInterval = 500000; // microseconds
    static const uint32_t kMinTxInterval = 500000; // microseconds
 
    struct BfdStats {
        BfdStats() { Reset(); }
        void Reset() { bfd_sent = bfd_received = bfd_rx_drop_count = 0;
                       bfd_rx_ka_enqueue_count = 0; }
 
        uint64_t bfd_sent;
        uint64_t bfd_received;
        uint32_t bfd_rx_drop_count;
        uint64_t bfd_rx_ka_enqueue_count;
    };
 
    class BfdCommunicator : public BFD::Connection {
    public:
        BfdCommunicator(BfdProto *bfd_proto) :
            bfd_proto_(bfd_proto), server_(NULL) {}
        virtual ~BfdCommunicator() {}
        virtual void SendPacket(
                const boost::asio::ip::udp::endpoint &local_endpoint,
                const boost::asio::ip::udp::endpoint &remote_endpoint,
                const BFD::SessionIndex &session_index,
                const boost::asio::mutable_buffer &packet, int pktSize);
        virtual void NotifyStateChange(const BFD::SessionKey &key, const bool &up);
        virtual BFD::Server *GetServer() const { return server_; }
        virtual void SetServer(BFD::Server *server) { server_ = server; }
 
    private:
        BfdProto *bfd_proto_;
        BFD::Server *server_;
    };
 
    BfdProto(Agent *agent, boost::asio::io_context &io);
    virtual ~BfdProto();
    ProtoHandler *AllocProtoHandler(boost::shared_ptr<PktInfo> info,
                                    boost::asio::io_context &io);
    void Shutdown() {
        delete client_;
        client_ = NULL;
 
        // server_->DeleteClientSessions();
        // TASK_UTIL_EXPECT_TRUE(server_->event_queue()->IsQueueEmpty());
        server_->event_queue()->Shutdown();
        delete server_;
        server_ = NULL;
 
        sessions_.clear();
    }
 
    bool Enqueue(boost::shared_ptr<PktInfo> msg);
    void ProcessStats(PktStatsType::Type type);
    bool ProcessBfdKeepAlive(boost::shared_ptr<PktInfo> msg);
    void HandleReceiveSafe(boost::asio::const_buffer pkt,
                       const boost::asio::ip::udp::endpoint &local_endpoint,
                       const boost::asio::ip::udp::endpoint &remote_endpoint,
                       const BFD::SessionIndex &session_index,
                       uint8_t pkt_len,
                       boost::system::error_code ec);
 
    bool BfdHealthCheckSessionControl(
               HealthCheckTable::HealthCheckServiceAction action,
               HealthCheckInstanceService *service);
    void NotifyHealthCheckInstanceService(uint32_t interface,
                IpAddress address, std::string &data);
    BfdCommunicator &bfd_communicator() { return communicator_; }
 
    void IncrementSent() { stats_.bfd_sent++; }
    void IncrementReceived() { stats_.bfd_received++; }
    void IncrementReceiveDropCount() { stats_.bfd_rx_drop_count++; }
    void IncrementKaEnqueueCount() { stats_.bfd_rx_ka_enqueue_count++; }
    const BfdStats &GetStats() const { return stats_; }
    uint32_t ActiveSessions() const { return sessions_.size(); }
 
private:
    friend BfdCommunicator;
    // map from interface id,dest-ip to health check instance service
    typedef std::map<BfdSessionsKey, HealthCheckInstanceService *, BfdSessionsKeyCmp> Sessions;
    typedef std::pair<BfdSessionsKey, HealthCheckInstanceService *> SessionsPair;
 
    std::mutex mutex_; // lock for sessions_ access between health check & BFD
    std::mutex rx_mutex_; // lock for BFD control & keepalive Rx data
    boost::shared_ptr<PktInfo> msg_;
    BfdCommunicator communicator_;
    BFD::Server *server_;
    BFD::Client *client_;
    BfdHandler handler_;
    Sessions sessions_;
    BfdStats stats_;
 
    DISALLOW_COPY_AND_ASSIGN(BfdProto);
};
 
#endif // vnsw_agent_bfd_proto_h_