neighbormanager.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_NEIGHBORMANAGER_HPP
#define JOIN_FABRIC_NEIGHBORMANAGER_HPP
 
// libjoin.
#include <join/netlinkmanager.hpp>
#include <join/neighbor.hpp>
 
// C++.
#include <functional>
 
namespace join
{
    enum class NeighborChangeType : uint32_t
    {
        Added        = 1L << 0, 
        Deleted      = 1L << 1, 
        Modified     = 1L << 2, 
        MacChanged   = 1L << 3, 
        StateChanged = 1L << 4, 
    };
 
    inline NeighborChangeType operator& (NeighborChangeType a, NeighborChangeType b)
    {
        return NeighborChangeType (static_cast<uint32_t> (a) & static_cast<uint32_t> (b));
    }
 
    inline NeighborChangeType operator| (NeighborChangeType a, NeighborChangeType b)
    {
        return NeighborChangeType (static_cast<uint32_t> (a) | static_cast<uint32_t> (b));
    }
 
    inline NeighborChangeType operator^ (NeighborChangeType a, NeighborChangeType b)
    {
        return NeighborChangeType (static_cast<uint32_t> (a) ^ static_cast<uint32_t> (b));
    }
 
    inline NeighborChangeType operator~(NeighborChangeType a)
    {
        return NeighborChangeType (~static_cast<uint32_t> (a));
    }
 
    inline const NeighborChangeType& operator&= (NeighborChangeType& a, NeighborChangeType b)
    {
        return a = a & b;
    }
 
    inline const NeighborChangeType& operator|= (NeighborChangeType& a, NeighborChangeType b)
    {
        return a = a | b;
    }
 
    inline const NeighborChangeType& operator^= (NeighborChangeType& a, NeighborChangeType b)
    {
        return a = a ^ b;
    }
 
    struct NeighborInfo
    {
        Neighbor::Ptr neighbor;   
        NeighborChangeType flags; 
    };
 
    class NeighborManager : public NetlinkManager
    {
    public:
        using NeighborNotify = std::function<void (const NeighborInfo& info)>;
 
        explicit NeighborManager (Reactor* reactor = nullptr);
 
        NeighborManager (const NeighborManager& other) = delete;
 
        NeighborManager (NeighborManager&& other) = delete;
 
        NeighborManager& operator= (const NeighborManager& other) = delete;
 
        NeighborManager& operator= (NeighborManager&& other) = delete;
 
        ~NeighborManager ();
 
        static NeighborManager& instance ();
 
        Neighbor::Ptr findByIndex (uint32_t index, const IpAddress& ipAddress);
 
        Neighbor::Ptr findByName (const std::string& interfaceName, const IpAddress& ipAddress);
 
        NeighborList enumerate ();
 
        NeighborList enumerate (uint32_t index);
 
        NeighborList enumerate (const std::string& interfaceName);
 
        int refresh ();
 
        uint64_t addNeighborListener (const NeighborNotify& cb);
 
        void removeNeighborListener (uint64_t id);
 
        int addNeighbor (uint32_t index, const IpAddress& ipAddress, const MacAddress& macAddress,
                         uint16_t state = NUD_PERMANENT, bool sync = false);
 
        int addNeighbor (const std::string& interfaceName, const IpAddress& ipAddress, const MacAddress& macAddress,
                         uint16_t state = NUD_PERMANENT, bool sync = false);
 
        int removeNeighbor (uint32_t index, const IpAddress& ipAddress, bool sync = false);
 
        int removeNeighbor (const std::string& interfaceName, const IpAddress& ipAddress, bool sync = false);
 
        int flushNeighbors (uint32_t index, bool sync = false);
 
        int flushNeighbors (const std::string& interfaceName, bool sync = false);
 
    private:
        int setNeighbor (uint32_t index, const IpAddress& ipAddress, const MacAddress& macAddress, uint16_t state,
                         bool sync);
 
        int dumpNeighbors (bool sync = false);
 
        void onMessage (struct nlmsghdr* nlh) override;
 
        void onNeighborMessage (struct nlmsghdr* nlh);
 
        void notifyNeighborUpdate (const NeighborInfo& info);
 
        Neighbor::Ptr acquire (uint32_t index, const IpAddress& ipAddress, NeighborInfo& info);
 
        std::unordered_map<NeighborKey, Neighbor::Ptr> _neighbors;
 
        Mutex _neighMutex;
 
        std::unordered_map<uint64_t, NeighborNotify> _neighborListeners;
 
        uint64_t _listenerCounter = 0;
 
        Mutex _listenerMutex;
 
        // friendship with neighbor.
        friend class Neighbor;
    };
}
 
#endif