routemanager.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_ROUTEMANAGER_HPP
#define JOIN_FABRIC_ROUTEMANAGER_HPP
 
// libjoin.
#include <join/netlinkmanager.hpp>
#include <join/route.hpp>
 
// C++.
#include <functional>
 
namespace join
{
    enum class RouteChangeType : uint32_t
    {
        Added = 1L << 0,           
        Deleted = 1L << 1,         
        Modified = 1L << 2,        
        GatewayChanged = 1L << 3,  
        MetricChanged = 1L << 4,   
        TypeChanged = 1L << 5,     
        ScopeChanged = 1L << 6,    
        ProtocolChanged = 1L << 7, 
    };
 
    inline RouteChangeType operator& (RouteChangeType a, RouteChangeType b)
    {
        return RouteChangeType (static_cast<uint32_t> (a) & static_cast<uint32_t> (b));
    }
 
    inline RouteChangeType operator| (RouteChangeType a, RouteChangeType b)
    {
        return RouteChangeType (static_cast<uint32_t> (a) | static_cast<uint32_t> (b));
    }
 
    inline RouteChangeType operator^ (RouteChangeType a, RouteChangeType b)
    {
        return RouteChangeType (static_cast<uint32_t> (a) ^ static_cast<uint32_t> (b));
    }
 
    inline RouteChangeType operator~(RouteChangeType a)
    {
        return RouteChangeType (~static_cast<uint32_t> (a));
    }
 
    inline const RouteChangeType& operator&= (RouteChangeType& a, RouteChangeType b)
    {
        return a = a & b;
    }
 
    inline const RouteChangeType& operator|= (RouteChangeType& a, RouteChangeType b)
    {
        return a = a | b;
    }
 
    inline const RouteChangeType& operator^= (RouteChangeType& a, RouteChangeType b)
    {
        return a = a ^ b;
    }
 
    struct RouteInfo
    {
        Route::Ptr route;      
        RouteChangeType flags; 
    };
 
    class RouteManager : public NetlinkManager
    {
    public:
        using RouteNotify = std::function<void (const RouteInfo& info)>;
 
        explicit RouteManager (Reactor* reactor = nullptr);
 
        RouteManager (const RouteManager&) = delete;
 
        RouteManager (RouteManager&&) = delete;
 
        RouteManager& operator= (const RouteManager&) = delete;
 
        RouteManager& operator= (RouteManager&&) = delete;
 
        ~RouteManager ();
 
        static RouteManager& instance ();
 
        Route::Ptr findByIndex (uint32_t index, const IpAddress& dest, uint32_t prefix);
 
        Route::Ptr findByName (const std::string& interfaceName, const IpAddress& dest, uint32_t prefix);
 
        RouteList enumerate ();
 
        RouteList enumerate (uint32_t index);
 
        RouteList enumerate (const std::string& interfaceName);
 
        int refresh ();
 
        uint64_t addRouteListener (const RouteNotify& cb);
 
        void removeRouteListener (uint64_t id);
 
        int addRoute (uint32_t index, const IpAddress& dest, uint32_t prefix, const IpAddress& gateway = {},
                      uint32_t metric = 0, bool sync = false);
 
        int addRoute (const std::string& interfaceName, const IpAddress& dest, uint32_t prefix,
                      const IpAddress& gateway = {}, uint32_t metric = 0, bool sync = false);
 
        int removeRoute (uint32_t index, const IpAddress& dest, uint32_t prefix, bool sync = false);
 
        int removeRoute (const std::string& interfaceName, const IpAddress& dest, uint32_t prefix, bool sync = false);
 
        int flushRoutes (uint32_t index, bool sync = false);
 
        int flushRoutes (const std::string& interfaceName, bool sync = false);
 
    private:
        int setRoute (uint32_t index, const IpAddress& dest, uint32_t prefix, const IpAddress& gateway, uint32_t metric,
                      bool sync);
 
        int dumpRoutes (bool sync = false);
 
        void onMessage (struct nlmsghdr* nlh) override;
 
        void onRouteMessage (struct nlmsghdr* nlh);
 
        void notifyRouteUpdate (const RouteInfo& info);
 
        Route::Ptr acquire (uint32_t index, const IpAddress& dest, uint32_t prefix, RouteInfo& info);
 
        std::unordered_map<RouteKey, Route::Ptr> _routes;
 
        Mutex _routeMutex;
 
        std::unordered_map<uint64_t, RouteNotify> _routeListeners;
 
        std::atomic<uint64_t> _listenerCounter{0};
 
        // friendship with route.
        friend class Route;
    };
}
 
#endif