vxlan_routing_manager.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Juniper Networks, Inc. All rights reserved.
 */

#ifndef __AGENT_OPER_VXLAN_ROUTING_H
#define __AGENT_OPER_VXLAN_ROUTING_H

#include <cmn/agent_cmn.h>
#include <cmn/agent.h>
#include <oper/oper_db.h>
#include <base/logging.h>

class BgpPeer;
namespace autogen {
    struct EnetNextHopType;
    struct NextHopType;
}


struct RouteParameters {

    RouteParameters(const IpAddress& nh_addr,
        const MacAddress& mac,
        const VnListType& vns,
        const SecurityGroupList& sgs,
        const CommunityList& comms,
        const TagList& tags,
        const PathPreference& ppref,
        const EcmpLoadBalance& ecmp,
        uint64_t seq_n):
        nh_addresses_(1, nh_addr),
        nh_addr_(nh_addresses_.at(0)),
        nh_mac_(mac),
        vn_list_(vns), sg_list_(sgs),
        communities_(comms), tag_list_(tags),
        path_preference_(ppref),
        ecmp_load_balance_(ecmp),
        sequence_number_(seq_n) {
    }

    RouteParameters(const RouteParameters &rp):
        nh_addresses_(rp.nh_addresses_),
        nh_addr_(rp.nh_addr_),
        nh_mac_(rp.nh_mac_),
        vn_list_(rp.vn_list_), sg_list_(rp.sg_list_),
        communities_(rp.communities_), tag_list_(rp.tag_list_),
        path_preference_(rp.path_preference_),
        ecmp_load_balance_(rp.ecmp_load_balance_),
        sequence_number_(rp.sequence_number_) {
    }

    // template <class ITEM_T
    // static std::vector<typename ITEM_T> ItemToVector(const ITEM_T& item) {
    //     return std::vector<ITEM_T>();
    // }

    // template<class ITEM_T>
    // RouteParameters(const ITEM_T& item,
    //     const VnListType& vns,
    //     const SecurityGroupList& sgs,
    //     const TagList& tags,
    //     const PathPreference& ppref,
    //     const EcmpLoadBalance& ecmp,
    //     uint64_t seq_n):
    //     nh_addr_(nh_addr),
    //     vn_list_(vns), sg_list_(sgs),
    //     tag_list_(tags), path_preference_(ppref),
    //     ecmp_load_balance_(ecmp),
    //     sequence_number_(seq_n) {
    // }

    const std::vector<IpAddress> nh_addresses_;

    const IpAddress& nh_addr_;

    const MacAddress& nh_mac_;

    const VnListType& vn_list_;

    const SecurityGroupList& sg_list_;

    const CommunityList& communities_;

    const TagList& tag_list_;

    const PathPreference& path_preference_;

    const EcmpLoadBalance& ecmp_load_balance_;

    uint64_t sequence_number_;

private:

    RouteParameters();
};

struct VxlanRoutingState : public DBState {

    VxlanRoutingState(VxlanRoutingManager *mgr,
                      VrfEntry *vrf);

    virtual ~VxlanRoutingState();

    DBTable::ListenerId inet4_id_;

    DBTable::ListenerId inet6_id_;

    DBTable::ListenerId evpn_id_;

    AgentRouteTable *inet4_table_;

    AgentRouteTable *inet6_table_;

    AgentRouteTable *evpn_table_;
};

struct VxlanRoutingVnState : public DBState {

    typedef std::set<const VmInterface *> VmiList;

    typedef VmiList::iterator VmiListIter;

    VxlanRoutingVnState(VxlanRoutingManager *mgr);

    virtual ~VxlanRoutingVnState();

    void AddVmi(const VnEntry *vn, const VmInterface *vmi);

    void DeleteVmi(const VnEntry *vn, const VmInterface *vmi);

    boost::uuids::uuid logical_router_uuid() const;

    std::set<const VmInterface *> vmi_list_;

    bool is_routing_vn_;

    boost::uuids::uuid logical_router_uuid_;

    VrfEntryRef vrf_ref_;

    VxlanRoutingManager *mgr_;
};

struct VxlanRoutingVmiState : public DBState {

    VxlanRoutingVmiState();

    virtual ~VxlanRoutingVmiState();

    VnEntryRef vn_entry_;

    boost::uuids::uuid logical_router_uuid_;
};

class VxlanRoutingRouteWalker : public AgentRouteWalker {
public:

    VxlanRoutingRouteWalker(const std::string &name,
        VxlanRoutingManager *mgr, Agent *agent);

    virtual ~VxlanRoutingRouteWalker();

    virtual bool RouteWalkNotify(DBTablePartBase *partition, DBEntryBase *e);

private:

    VxlanRoutingManager *mgr_;

    DISALLOW_COPY_AND_ASSIGN(VxlanRoutingRouteWalker);
};


class VxlanRoutingVrfMapper {
public:

    struct RoutedVrfInfo {

        typedef std::set<const VnEntry *> BridgeVnList;

        typedef std::map<const VnEntry *, std::string> BridgeVrfNamesList;

        typedef BridgeVnList::iterator BridgeVnListIter;

        RoutedVrfInfo() : routing_vn_(),
        routing_vrf_(NULL), bridge_vn_list_() {
        }

        virtual ~RoutedVrfInfo() {
        }

        const VnEntry *routing_vn_;

        const VrfEntry *routing_vrf_;

        BridgeVnList bridge_vn_list_;

        BridgeVrfNamesList bridge_vrf_names_list_;
    };

    typedef std::map<boost::uuids::uuid, RoutedVrfInfo> LrVrfInfoMap;

    typedef LrVrfInfoMap::iterator LrVrfInfoMapIter;

    typedef std::map<const VnEntry *, boost::uuids::uuid> VnLrSet;

    typedef VnLrSet::iterator VnLrSetIter;

    typedef std::map<const InetUnicastAgentRouteTable *, DBTable::DBTableWalkRef>
        InetTableWalker;

    VxlanRoutingVrfMapper(VxlanRoutingManager *mgr);

    virtual ~VxlanRoutingVrfMapper();

    void BridgeInet4RouteWalkDone(DBTable::DBTableWalkRef walk_ref,
                       DBTableBase *partition);

    void BridgeInet6RouteWalkDone(DBTable::DBTableWalkRef walk_ref,
                       DBTableBase *partition);

    void RoutingVrfRouteWalkDone(DBTable::DBTableWalkRef walk_ref,
                                          DBTableBase *partition);

    void TryDeleteLogicalRouter(LrVrfInfoMapIter &it);

    bool IsEmpty() const {
        return ((vn_lr_set_.size() == 0) &&
                (lr_vrf_info_map_.size() == 0));
    }

private:

    friend class VxlanRoutingManager;

    void WalkBridgeVrfs(const RoutedVrfInfo &routing_vrf_info);

    void WalkRoutingVrf(const boost::uuids::uuid &lr_uuid,
        const VnEntry *vn, bool update, bool withdraw);

    void WalkBridgeInetTables(InetUnicastAgentRouteTable *inet4,
        InetUnicastAgentRouteTable *inet6);

    const VrfEntry *GetRoutingVrfUsingVn(const VnEntry *vn);

    const VrfEntry *GetRoutingVrfUsingAgentRoute(const AgentRoute *rt);

    const VrfEntry *GetRoutingVrfUsingUuid(const boost::uuids::uuid &lr_uuid);

    const boost::uuids::uuid GetLogicalRouterUuidUsingRoute(const AgentRoute *rt);

    VxlanRoutingManager *mgr_;

    LrVrfInfoMap lr_vrf_info_map_;

    VnLrSet vn_lr_set_;

    InetTableWalker inet4_table_walker_;

    InetTableWalker inet6_table_walker_;

    DISALLOW_COPY_AND_ASSIGN(VxlanRoutingVrfMapper);
};

class VxlanRoutingManager {
public:

    VxlanRoutingManager(Agent *agent);

    virtual ~VxlanRoutingManager();

    void Register();

    void Shutdown();

    void VnNotify(DBTablePartBase *partition, DBEntryBase *e);

    void BridgeVnNotify(const VnEntry *vn, VxlanRoutingVnState *vn_state);

    void RoutingVnNotify(const VnEntry *vn, VxlanRoutingVnState *vn_state);

    void VrfNotify(DBTablePartBase *partition, DBEntryBase *e);

    void VmiNotify(DBTablePartBase *partition, DBEntryBase *e);

    bool RouteNotify(DBTablePartBase *partition, DBEntryBase *e);


private:

    bool InetRouteNotify(DBTablePartBase *partition, DBEntryBase *e);

    bool EvpnRouteNotify(DBTablePartBase *partition, DBEntryBase *e);

    void ClearRedundantVrfPath(DBEntryBase *e);

    void WhenBridgeInetIntfWasDeleted(const InetUnicastRouteEntry *inet_rt,
        const VrfEntry *routing_vrf);

    void WhenRoutingEvpnRouteWasDeleted(const EvpnRouteEntry *routing_evpn_rt,
        const Peer* delete_from_peer);

public:

    bool WithdrawEvpnRouteFromRoutingVrf
    (const VrfEntry *routing_vrf, DBTablePartBase *partition, DBEntryBase *e);

    bool LeakRoutesIntoBridgeTables(DBTablePartBase *partition,
        DBEntryBase *e,
        const boost::uuids::uuid &uuid,
        const VnEntry *vn,
        bool update = false);

    void HandleSubnetRoute(const VrfEntry *vrf, bool bridge_vrf = false);

private:

    void RoutingVrfDeleteAllRoutes(VrfEntry* rt_vrf);

    void DeleteSubnetRoute(const VrfEntry *vrf);
    //void DeleteSubnetRoute(const VrfEntry *vrf, VnIpam *ipam = NULL);

    void DeleteSubnetRoute(const VnEntry *vn,
        const std::string& vrf_name);

    void DeleteIpamRoutes(const VnEntry *vn,
    const std::string& vrf_name,
    const IpAddress& ipam_prefix,
    const uint32_t plen);

    void UpdateSubnetRoute(const VrfEntry *vrf,
                            const VrfEntry *routing_vrf);
public:

    void FillSandeshInfo(VxlanRoutingResp *resp);

    DBTable::ListenerId vn_listener_id() const {
        return vn_listener_id_;
    }

    DBTable::ListenerId vrf_listener_id() const {
        return vrf_listener_id_;
    }

    DBTable::ListenerId vmi_listener_id() const {
        return vmi_listener_id_;
    }

    const VxlanRoutingVrfMapper &vrf_mapper() const {
        return vrf_mapper_;
    }

    AgentRouteWalker* walker() {
        return walker_.get();
    }

private:


    static const Peer *routing_vrf_interface_peer_;

    static const Peer* routing_vrf_vxlan_bgp_peer_;

    Agent *agent_;

    AgentRouteWalkerPtr walker_;

    DBTable::ListenerId vn_listener_id_;

    DBTable::ListenerId vrf_listener_id_;

    DBTable::ListenerId vmi_listener_id_;

    VxlanRoutingVrfMapper vrf_mapper_;

    static uint32_t loc_sequence_;

    static tbb::mutex mutex_;


    friend class VxlanRoutingRouteWalker;

    friend class ControllerEcmpRoute;

    friend class AgentXmppChannel;

    friend class AgentXmppChannelVxlanInterface;

    friend class VxlanRoutingVrfMapper;

    friend class MetadataProxy;


    static uint32_t GetNewLocalSequence(const AgentPath*);

    static bool is_ipv4_string(const std::string& prefix_str);

    static bool is_ipv6_string(const std::string& prefix_str);

    static uint32_t ipv4_prefix_len(const std::string& prefix_str);

    static std::string ipv4_prefix(const std::string& prefix_str);

    static uint32_t ipv6_prefix_len(const std::string& prefix_str);

    static std::string ipv6_prefix(const std::string& prefix_str);

    static bool IsVxlanAvailable(const Agent* agent);

    std::string GetOriginVn(const VrfEntry* routing_vrf,
        const IpAddress& ip_addr,
        const uint8_t& plen);

    static bool RoutePrefixIsEqualTo(const EvpnRouteEntry* route,
        const IpAddress& prefix_ip,
        const uint32_t prefix_len);

    static bool RoutePrefixIsEqualTo(const InetUnicastRouteEntry* route,
        const IpAddress& prefix_ip,
        const uint32_t prefix_len);

    static bool IsHostRoute(const IpAddress& prefix_ip, uint32_t prefix_len);

    static bool IsHostRoute(const EvpnRouteEntry *rt);

    bool IsHostRouteFromLocalSubnet(const EvpnRouteEntry *rt);

    bool IsVrfLocalRoute(EvpnRouteEntry *routing_evpn_rt,
        VrfEntry *bridge_vrf);

    bool IsLocalRoute(EvpnRouteEntry *routing_evpn_rt,
        VrfEntry *bridge_vrf);

    static bool HasVrfNexthop(const AgentRoute* rt);

    bool HasBgpPeerPath(EvpnRouteEntry *evpn_rt);

    static bool IsRoutingVrf(const VrfEntry* vrf);

    static bool IsBridgeVrf(const VrfEntry* vrf);

    static bool IsRoutingVrf(const std::string vrf_name, const Agent *agent);

    static const AgentPath* FindPathWithGivenPeer(
        const AgentRoute *inet_rt,
        const Peer::Type peer_type);

    static const AgentPath* FindPathWithGivenPeerAndNexthop(
        const AgentRoute *inet_rt,
        const Peer::Type peer_type,
        const NextHop::Type nh_type,
        bool strict_match = true);

    static const AgentPath* FindInterfacePathWithGivenPeer(
        const AgentRoute *inet_rt,
        const Peer::Type peer_type,
        bool strict_match = true);

    static const AgentPath *FindInterfacePathWithBgpPeer(
        const AgentRoute *inet_rt,
        bool strict_match = true);

    static const AgentPath *FindInterfacePathWithLocalVmPeer(
        const AgentRoute *inet_rt,
        bool strict_match = true);

    const AgentPath *FindBGPaaSPath(const InetUnicastRouteEntry *rt);

    void AdvertiseBGPaaSRoute(const IpAddress& prefix_ip, uint32_t prefix_len,
        const AgentPath* path, EvpnAgentRouteTable *evpn_table);

    static MacAddress NbComputeMac(const Ip4Address& compute_ip,
        const Agent *agent);


    TunnelNHKey* AllocateTunnelNextHopKey(const IpAddress& dip,
        const MacAddress& dmac) const;

    void XmppAdvertiseEvpnRoute(const IpAddress& prefix_ip,
        const int prefix_len, uint32_t vxlan_id, const std::string vrf_name,
        const RouteParameters& params, const Peer *bgp_peer);

    void XmppAdvertiseInetRoute(const IpAddress& prefix_ip,
        const int prefix_len, uint32_t vxlan_id, const std::string vrf_name,
        const RouteParameters& params, const Peer *bgp_peer);

    void XmppAdvertiseInetRoute(const IpAddress& prefix_ip,
        const int prefix_len, const std::string vrf_name,
        const AgentPath*);

    void XmppAdvertiseEvpnTunnel(
        EvpnAgentRouteTable *inet_table, const IpAddress& prefix_ip,
        const int prefix_len, uint32_t vxlan_id, const std::string vrf_name,
        const RouteParameters& params, const Peer *bgp_peer);

    void XmppAdvertiseEvpnInterface(
        EvpnAgentRouteTable *inet_table, const IpAddress& prefix_ip,
        const int prefix_len, uint32_t vxlan_id, const std::string vrf_name,
        const RouteParameters& params, const Peer *bgp_peer);

    void XmppAdvertiseInetTunnel(
        InetUnicastAgentRouteTable *inet_table, const IpAddress& prefix_ip,
        const int prefix_len, uint32_t vxlan_id, const std::string vrf_name,
        const RouteParameters& params, const Peer *bgp_peer);

    void XmppAdvertiseInetTunnel(
        InetUnicastAgentRouteTable *inet_table, const IpAddress& prefix_ip,
        const int prefix_len, const std::string vrf_name,
        const AgentPath* path);

    void XmppAdvertiseInetInterfaceOrComposite(
        InetUnicastAgentRouteTable *inet_table, const IpAddress& prefix_ip,
        const int prefix_len, const std::string vrf_name,
        const AgentPath* path);


    template <class ItType>
    static std::vector<IpAddress> ItemNexthopsToVector(ItType *item);

    template<typename NhType>
    static void AddInterfaceComponentToList(
        const std::string& prefix_str,
        const std::string& vrf_name,
        const NhType &nh_item,
        ComponentNHKeyList& comp_nh_list);

    static AgentRoute *FindEvpnOrInetRoute(const Agent *agent,
        const std::string &vrf_name,
        const IpAddress &ip_addr,
        uint32_t prefix_len,
        const autogen::EnetNextHopType &nh_item);

    static AgentRoute *FindEvpnOrInetRoute(const Agent *agent,
        const std::string &vrf_name,
        const IpAddress &ip_addr,
        uint32_t prefix_len,
        const autogen::NextHopType &nh_item);


    static void DeleteOldInterfacePath(const IpAddress &prefix_ip,
        const uint32_t plen,
        const Peer *peer,
        EvpnAgentRouteTable *evpn_table);

    static void CopyInterfacePathToEvpnTable(const AgentPath* path,
        const IpAddress &prefix_ip,
        const uint32_t plen,
        const Peer *peer,
        const RouteParameters &params,
        EvpnAgentRouteTable *evpn_table);

    static void DeleteOldInterfacePath(const IpAddress &prefix_ip,
        const uint32_t plen,
        const Peer *peer,
        InetUnicastAgentRouteTable *inet_table);

    void CopyPathToInetTable(const AgentPath* path,
        const IpAddress &prefix_ip,
        const uint32_t plen,
        const Peer *peer,
        const RouteParameters &params,
        InetUnicastAgentRouteTable *inet_table);

public:

    static void PrintEvpnTable(const VrfEntry* const_vrf);

    static void PrintInetTable(const VrfEntry* const_vrf);

    static void ListAttachedVns();

    DISALLOW_COPY_AND_ASSIGN(VxlanRoutingManager);
};

#include <oper/vxlan_templates.cc>

#endif