vxlan_routing_manager.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Juniper Networks, Inc. All rights reserved.
 * Copyright (c) 2022 - 2026 Matvey Kraposhin.
 * Copyright (c) 2024 - 2026 Elena Zizganova.
 */
#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_;
 
        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_;
 
 
    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);
 
    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,
        const std::vector<std::string> &peer_sources);
 
    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,
        const std::vector<std::string> &peer_sources);
 
    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,
        std::vector<std::string> &peer_sources);
 
    template<typename NhType>
    static void AddBgpaasInterfaceComponentToList(
        const std::string& vrf_name,
        const NhType &nh_item,
        ComponentNHKeyList& comp_nh_list,
        std::vector<std::string> &peer_sources);
 
    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);
 
    void XmppAdvertiseEvpnBgpaas(
    EvpnAgentRouteTable *evpn_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,
    const std::vector<std::string> &peer_sources);
 
    void XmppAdvertiseEvpnBgpaasInterface(
    EvpnAgentRouteTable *evpn_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,  const NextHop *nh);
 
    void XmppAdvertiseEvpnBgpaasComposite(
    EvpnAgentRouteTable *evpn_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,
    ComponentNHKeyList &comp_nh_list);
 
public:
 
    static void PrintEvpnTable(const VrfEntry* const_vrf);
 
    static void PrintInetTable(const VrfEntry* const_vrf);
 
    static void ListAttachedVns();
 
    static inline VrfEntry* VnVrf(const VnEntry *vn, const std::string &vrf_name) {
        VrfEntry* vrf = nullptr;
        vrf = vn->GetVrf();
        if (vrf != nullptr) {
            return vrf;
        }
        vrf = Agent::GetInstance()->vrf_table()->FindVrfFromName(vrf_name);
        return vrf;
    }
 
    DISALLOW_COPY_AND_ASSIGN(VxlanRoutingManager);
};
 
#include <oper/vxlan_templates.cc>
 
#endif