static_route.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
 */
 
#ifndef SRC_BGP_ROUTING_INSTANCE_STATIC_ROUTE_H_
#define SRC_BGP_ROUTING_INSTANCE_STATIC_ROUTE_H_
 
#include <map>
#include <set>
 
#include "bgp/routing-instance/istatic_route_mgr.h"
 
#include "base/queue_task.h"
#include "bgp/bgp_condition_listener.h"
#include "bgp/bgp_config.h"
#include "bgp/inet/inet_route.h"
#include "bgp/inet6/inet6_route.h"
 
class InetVpnRoute;
class Inet6VpnRoute;
class StaticRouteConfig;
 
template <typename T> class StaticRoute;
 
template <typename T1, typename T2, typename T3, typename T4>
struct StaticRouteBase {
  typedef T1 RouteT;
  typedef T2 VpnRouteT;
  typedef T3 PrefixT;
  typedef T4 AddressT;
};
 
class StaticRouteInet : public StaticRouteBase<
    InetRoute, InetVpnRoute, Ip4Prefix, Ip4Address> {
};
 
class StaticRouteInet6 : public StaticRouteBase<
    Inet6Route, Inet6VpnRoute, Inet6Prefix, Ip6Address> {
};
 
typedef ConditionMatchPtr StaticRoutePtr;
 
struct StaticRouteRequest {
    enum RequestType {
        NEXTHOP_ADD_CHG,
        NEXTHOP_DELETE
    };
 
    StaticRouteRequest(RequestType type, BgpTable *table, BgpRoute *route,
                        StaticRoutePtr info)
        : type_(type), table_(table), rt_(route), info_(info) {
    }
 
    RequestType type_;
    BgpTable *table_;
    BgpRoute *rt_;
    StaticRoutePtr info_;
 
private:
    DISALLOW_COPY_AND_ASSIGN(StaticRouteRequest);
};
 
template <typename T>
class StaticRouteMgr : public IStaticRouteMgr {
public:
    typedef typename T::RouteT RouteT;
    typedef typename T::VpnRouteT VpnRouteT;
    typedef typename T::PrefixT PrefixT;
    typedef typename T::AddressT AddressT;
    typedef StaticRoute<T> StaticRouteT;
 
    struct RouteKey {
        RouteKey (const PrefixT &prefix, const IpAddress &nexthop) :
                prefix(prefix), nexthop(nexthop) {
        }
 
        bool operator<(const RouteKey &rhs) const {
            BOOL_KEY_COMPARE(prefix, rhs.prefix);
            BOOL_KEY_COMPARE(nexthop, rhs.nexthop);
            return false;
        }
 
        PrefixT prefix;
        IpAddress nexthop;
    };
 
    // Map of Static Route prefix to the StaticRoute match object
    typedef std::map<RouteKey, StaticRoutePtr> StaticRouteMap;
 
    explicit StaticRouteMgr(RoutingInstance *instance);
    ~StaticRouteMgr();
 
    // Config
    virtual void ProcessStaticRouteConfig();
    virtual void UpdateStaticRouteConfig();
    virtual void FlushStaticRouteConfig();
 
    void EnqueueStaticRouteReq(StaticRouteRequest *req);
    const StaticRouteMap &static_route_map() const { return static_route_map_; }
 
    virtual void NotifyAllRoutes();
    virtual void UpdateAllRoutes();
    virtual uint32_t GetRouteCount() const;
    virtual uint32_t GetDownRouteCount() const;
    virtual bool FillStaticRouteInfo(RoutingInstance *rtinstance,
                                     StaticRouteEntriesInfo *info) const;
 
    Address::Family GetFamily() const;
    AddressT GetAddress(IpAddress addr) const;
 
private:
    template <typename U> friend class StaticRouteTest;
    typedef std::set<StaticRoutePtr> StaticRouteProcessList;
    typedef BgpInstanceConfig::StaticRouteList StaticRouteConfigList;
 
    // All static route related actions are performed in the context
    // of this task. This task has exclusion with db::DBTable task.
    static int static_route_task_id_;
 
    int CompareStaticRoute(typename StaticRouteMap::iterator loc,
        StaticRouteConfigList::iterator it);
    void AddStaticRoute(StaticRouteConfigList::iterator it);
    void DelStaticRoute(typename StaticRouteMap::iterator loc);
    void UpdateStaticRoute(typename StaticRouteMap::iterator loc,
        StaticRouteConfigList::iterator it);
 
    void LocateStaticRoutePrefix(const StaticRouteConfig &config);
    void RemoveStaticRoutePrefix(const RouteKey &static_route);
    void StopStaticRouteDone(BgpTable *table, ConditionMatch *info);
    void UnregisterAndResolveStaticRoute(StaticRoutePtr entry);
    bool StaticRouteEventCallback(StaticRouteRequest *req);
 
    bool ProcessUnregisterList();
 
    virtual void DisableUnregisterTrigger();
    virtual void EnableUnregisterTrigger();
 
    virtual void DisableQueue() { static_route_queue_->set_disable(true); }
    virtual void EnableQueue() { static_route_queue_->set_disable(false); }
    virtual bool IsQueueEmpty() { return static_route_queue_->IsQueueEmpty(); }
    RoutingInstance *routing_instance() { return rtinstance_; }
 
    RoutingInstance *rtinstance_;
    BgpConditionListener *listener_;
    StaticRouteMap  static_route_map_;
    WorkQueue<StaticRouteRequest *> *static_route_queue_;
    tbb::mutex mutex_;
    StaticRouteProcessList unregister_static_route_list_;
    boost::scoped_ptr<TaskTrigger> unregister_list_trigger_;
 
    DISALLOW_COPY_AND_ASSIGN(StaticRouteMgr);
};
 
typedef StaticRouteMgr<StaticRouteInet> StaticRouteMgrInet;
typedef StaticRouteMgr<StaticRouteInet6> StaticRouteMgrInet6;
 
#endif  // SRC_BGP_ROUTING_INSTANCE_STATIC_ROUTE_H_