global_vrouter.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
 */
 
#ifndef vnsw_agent_global_router_h_
#define vnsw_agent_global_router_h_
 
#include <cmn/agent_cmn.h>
#include <oper/oper_db.h>
#include <oper/ecmp_load_balance.h>
#include <oper/agent_route_walker.h>
 
class OperDB;
class VnEntry;
class VrfEntry;
class IFMapNode;
class AgentRouteResync;
class AgentRouteEncap;
class AgentUtXmlFlowThreshold;
class EcmpLoadBalance;
class CryptTunnelTable;
 
namespace autogen {
    struct LinklocalServiceEntryType;
    struct FlowAgingTimeout;
    class GlobalVrouterConfig;
}
 
struct LinkLocalDBState : DBState {
    const VrfEntry *vrf_;
    // set of linklocal addresses added to the VN
    std::set<IpAddress> addresses_;
 
    LinkLocalDBState(const VrfEntry *vrf) : DBState(), vrf_(vrf) {}
    void Add(const IpAddress &address) { addresses_.insert(address); }
    void Delete(const IpAddress &address) { addresses_.erase(address); }
};
 
struct PortConfig {
    PortConfig() : port_count(0) {}
 
    struct PortRange {
        PortRange(uint16_t start, uint16_t end):
            port_start(start), port_end(end) {}
 
        uint16_t port_start;
        uint16_t port_end;
    };
 
    void Trim();
    uint16_t port_count;
    std::vector<PortRange> port_range;
};
 
// Handle Global Vrouter configuration
class GlobalVrouter : public OperIFMapTable {
public:
    enum CryptMode {
        CRYPT_ALL_TRAFFIC,
        CRYPT_FLOW,
        CRYPT_NONE
    };
    static const std::string kMetadataService;
    static const std::string kMetadataService6;
    static const Ip4Address kLoopBackIp;
    static const int32_t kDefaultFlowExportRate = 0;
    static const int32_t kDisableSampling = -1;
 
    struct LinkLocalServiceKey {
        IpAddress linklocal_service_ip;
        uint16_t   linklocal_service_port;
 
        LinkLocalServiceKey(const IpAddress &addr, uint16_t port)
            : linklocal_service_ip(addr), linklocal_service_port(port) {}
        bool operator<(const LinkLocalServiceKey &rhs) const;
    };
 
    // Config data for each linklocal service
    struct LinkLocalService {
        std::string linklocal_service_name;
        std::string ipfabric_dns_service_name;
        std::vector<Ip4Address>  ipfabric_service_ip;
        uint16_t                 ipfabric_service_port;
 
        LinkLocalService(const std::string &service_name,
                         const std::string &fabric_dns_name,
                         const std::vector<Ip4Address> &fabric_ip,
                         uint16_t fabric_port);
        bool operator==(const LinkLocalService &rhs) const;
        bool IsAddressInUse(const Ip4Address &ip) const;
        DBTable::DBTableWalkRef vn_update_walk_ref_;
    };
 
    struct FlowAgingTimeoutKey {
        FlowAgingTimeoutKey(uint8_t proto, uint16_t port_arg):
            protocol(proto), port(port_arg) { }
        uint8_t protocol;
        uint16_t port;
        bool operator==(const FlowAgingTimeoutKey &rhs) const {
            return (protocol == rhs.protocol && port == rhs.port);
        }
 
        bool operator<(const FlowAgingTimeoutKey &rhs) const {
            if (protocol != rhs.protocol) {
                return protocol < rhs.protocol;
            }
            return port < rhs.port;
        }
    };
 
    typedef std::string CryptTunnelKey;
    struct CryptTunnel {
        CryptMode mode;
        CryptTunnel(CryptMode cmode): mode(cmode) {};
        bool operator==(const CryptTunnel &rhs) const {
            return (mode == rhs.mode);
        }
        bool operator<(const CryptTunnel &rhs) const {
            return (mode < rhs.mode);
        }
    };
 
    // map of linklocal service data, with (ip, port) as key
    typedef std::map<LinkLocalServiceKey, LinkLocalService> LinkLocalServicesMap;
    typedef std::pair<LinkLocalServiceKey, LinkLocalService> LinkLocalServicesPair;
 
    typedef std::map<CryptTunnelKey, CryptTunnel> CryptTunnelsMap;
    typedef std::pair<CryptTunnelKey, CryptTunnel> CryptTunnelsPair;
 
    typedef std::map<FlowAgingTimeoutKey, uint32_t> FlowAgingTimeoutMap;
    typedef std::pair<FlowAgingTimeoutKey, uint32_t> FlowAgingTimeoutPair;
 
    //Map used to audit for port pool configuration change
    typedef std::map<uint8_t, PortConfig> ProtocolPortSet;
 
    GlobalVrouter(Agent *agent);
    virtual ~GlobalVrouter();
    void CreateDBClients();
 
    const LinkLocalServicesMap &linklocal_services_map() const {
        return linklocal_services_map_;
    }
    int32_t flow_export_rate() const { return flow_export_rate_; }
 
    void ConfigDelete(IFMapNode *node);
    void ConfigAddChange(IFMapNode *node);
    void ConfigManagerEnqueue(IFMapNode *node);
 
    void GlobalVrouterConfig(IFMapNode *node);
    void UpdateSLOConfig(IFMapNode *node);
 
    bool FindLinkLocalService(const std::string &service_name,
        IpAddress *service_ip,
        uint16_t *service_port,
        std::string *fabric_hostname,
        Ip4Address *fabric_ip,
        uint16_t *fabric_port) const;
 
    bool FindLinkLocalService(const IpAddress &service_ip,
        uint16_t service_port,
        std::string *service_name,
        Ip4Address *fabric_ip,
        uint16_t *fabric_port) const;
 
    bool FindLinkLocalService(const std::string &service_name,
        std::set<IpAddress> *service_ip) const;
 
    bool FindLinkLocalService(const IpAddress &service_ip,
        std::set<std::string> *service_names) const;
 
    void LinkLocalRouteUpdate(const std::vector<Ip4Address> &addr_list);
    bool IsAddressInUse(const Ip4Address &ip) const;
    bool IsLinkLocalAddressInUse(const IpAddress &ip) const;
    Agent::ForwardingMode forwarding_mode() const {return forwarding_mode_;}
    boost::uuids::uuid slo_uuid() const {return slo_uuid_;}
 
    uint64_t PendingFabricDnsRequests() const;
    void ResyncRoutes();
    const EcmpLoadBalance &ecmp_load_balance() const;
    bool configured() const { return configured_; }
 
    friend class AgentUtXmlFlowThreshold;
private:
    class FabricDnsResolver;
    class LinkLocalRouteManager;
    typedef std::vector<autogen::LinklocalServiceEntryType> LinkLocalServiceList;
    typedef std::vector<autogen::EncryptionTunnelEndpoint> EncryptionTunnelEndpointList;
    typedef std::vector<autogen::FlowAgingTimeout> FlowAgingTimeoutList;
 
    void UpdateLinkLocalServiceConfig(const LinkLocalServiceList &linklocal_list);
    void DeleteLinkLocalServiceConfig();
    bool ChangeNotify(LinkLocalServicesMap *old_value,
                      LinkLocalServicesMap *new_value);
    void AddLinkLocalService(const LinkLocalServicesMap::iterator &it);
    void DeleteLinkLocalService(const LinkLocalServicesMap::iterator &it);
    void ChangeLinkLocalService(const LinkLocalServicesMap::iterator &old_it,
                                const LinkLocalServicesMap::iterator &new_it);
 
    bool IsVrouterPresentCryptTunnelConfig(const EncryptionTunnelEndpointList &endpoint_list);
    void UpdateCryptTunnelEndpointConfig(const EncryptionTunnelEndpointList &endpoint_list,
                                         const std::string encrypt_mode_str);
    void DeleteCryptTunnelEndpointConfig();
    bool ChangeNotifyCryptTunnels(CryptTunnelsMap *old_value,
                                  CryptTunnelsMap *new_value);
    void AddCryptTunnelEndpoint(const CryptTunnelsMap::iterator &it);
    void DeleteCryptTunnelEndpoint(const CryptTunnelsMap::iterator &it);
    void ChangeCryptTunnelEndpoint(const CryptTunnelsMap::iterator &old_it,
                                   const CryptTunnelsMap::iterator &new_it);
 
    void UpdateFlowAging(autogen::GlobalVrouterConfig *cfg);
    void DeleteFlowAging();
 
    void UpdatePortConfig(autogen::GlobalVrouterConfig *cfg);
    void DeletePortConfig();
 
    void ReadFlowsLimits(const autogen::GlobalVrouterConfig &cfg);
 
    LinkLocalServicesMap linklocal_services_map_;
    CryptTunnelsMap crypt_tunnels_map_;
    CryptMode crypt_mode_;
    boost::scoped_ptr<LinkLocalRouteManager> linklocal_route_mgr_;
    boost::scoped_ptr<FabricDnsResolver> fabric_dns_resolver_;
    AgentRouteWalkerPtr agent_route_resync_walker_;
    Agent::ForwardingMode forwarding_mode_;
    int32_t flow_export_rate_;
    FlowAgingTimeoutMap flow_aging_timeout_map_;
    ProtocolPortSet protocol_port_set_;
    EcmpLoadBalance ecmp_load_balance_;
    bool configured_; //true when global-vrouter-config stanza is present
    boost::uuids::uuid slo_uuid_; //SLO associated with global-vrouter
};
 
#endif // vnsw_agent_global_router_h_