agent_route_walker.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
 */
 
#ifndef vnsw_agent_route_walker_hpp
#define vnsw_agent_route_walker_hpp
 
#include <atomic>
 
#include <boost/intrusive_ptr.hpp>
#include <boost/array.hpp>
 
#include <cmn/agent_cmn.h>
#include <cmn/agent.h>
#include <sandesh/sandesh_trace.h>
 
#define AGENT_DBWALK_TRACE_BUF "AgentDBwalkTrace"
extern SandeshTraceBufferPtr AgentDBwalkTraceBuf;
 
#define AGENT_DBWALK_TRACE(obj, ...) do {                                  \
    obj::TraceMsg(AgentDBwalkTraceBuf, __FILE__, __LINE__, ##__VA_ARGS__); \
} while (false)
 
class AgentRouteWalker;
class AgentRouteWalkerManager;
void intrusive_ptr_add_ref(AgentRouteWalker *w);
void intrusive_ptr_release(AgentRouteWalker *w);
typedef boost::intrusive_ptr<AgentRouteWalker> AgentRouteWalkerPtr;
 
struct RouteWalkerDBState : DBState {
    typedef boost::array<DBTable::DBTableWalkRef, Agent::ROUTE_TABLE_MAX> RouteWalkRef;
    typedef std::map<AgentRouteWalkerPtr, RouteWalkRef> AgentRouteWalkerRefMap;
    typedef AgentRouteWalkerRefMap::iterator AgentRouteWalkerRefMapIter;
    typedef AgentRouteWalkerRefMap::const_iterator AgentRouteWalkerRefMapConstIter;
 
    RouteWalkerDBState();
    AgentRouteWalkerRefMap walker_ref_map_;
};
 
class AgentRouteWalker {
public:
    static const int kInvalidWalkCount = 0;
    typedef boost::function<void()> WalkDone;
    typedef boost::function<void(VrfEntry *)> RouteWalkDoneCb;
    typedef std::map<const VrfEntry *, std::atomic<int> > VrfRouteWalkCountMap;
 
    virtual ~AgentRouteWalker();
 
    void StartVrfWalk();
    //Route table walk for specified VRF
    void StartRouteWalk(VrfEntry *vrf);
 
    virtual bool VrfWalkNotify(DBTablePartBase *partition, DBEntryBase *e);
    virtual bool RouteWalkNotify(DBTablePartBase *partition, DBEntryBase *e);
 
    virtual void VrfWalkDone(DBTableBase *part);
    virtual void RouteWalkDone(DBTableBase *part);
 
    //Walk done callbacks
    void WalkDoneCallback(WalkDone cb);
    void RouteWalkDoneForVrfCallback(RouteWalkDoneCb cb);
 
    //Helpers
    int walk_count() const {return walk_count_;}
    bool IsWalkCompleted() const {return (walk_count_ == kInvalidWalkCount);}
    bool IsValidDeleteWalkRef() const {
        return delete_walk_ref_.get() != NULL;
    }
    bool IsValidVrfWalkRef() const {
        return vrf_walk_ref_.get() != NULL;
    }
    bool IsDeregisterDone() const { return deregister_done_;}
    bool AreAllWalksDone() const;
    bool AreAllRouteWalksDone(const VrfEntry *vrf) const;
    bool IsRouteTableWalkCompleted(RouteWalkerDBState *state);
    AgentRouteWalkerManager *mgr() {return mgr_;}
    Agent *agent() const {return agent_;}
    uint32_t refcount() const { return refcount_; }
 
protected:
    friend class AgentRouteWalkerManager;
    friend void intrusive_ptr_add_ref(AgentRouteWalker *w);
    friend void intrusive_ptr_release(AgentRouteWalker *w);
    AgentRouteWalker(const std::string &name, Agent *agent);
    void set_mgr(AgentRouteWalkerManager *mgr) {mgr_ = mgr;}
 
private:
    void Callback(VrfEntry *vrf);
    void OnRouteTableWalkCompleteForVrf(VrfEntry *vrf);
    void DecrementWalkCount();
    void DecrementRouteWalkCount(const VrfEntry *vrf);
    void IncrementWalkCount() {walk_count_++;}
    void IncrementRouteWalkCount(const VrfEntry *vrf);
    void WalkTable(AgentRouteTable *table,
                   DBTable::DBTableWalkRef &route_table_walk_ref);
    DBTable::DBTableWalkRef AllocateRouteTableReferences(AgentRouteTable *table);
    void VrfWalkDoneInternal(DBTableBase *part);
    void RouteWalkDoneInternal(DBTableBase *part, AgentRouteWalkerPtr ptr);
    DBTable::DBTableWalkRef LocateRouteTableWalkRef(const VrfEntry *vrf,
                                                    RouteWalkerDBState *state,
                                                    AgentRouteTable *table);
    RouteWalkerDBState *LocateRouteWalkerDBState(VrfEntry *vrf);
    DBTable::DBTableWalkRef &vrf_walk_ref() {
        return vrf_walk_ref_;
    }
    DBTable::DBTableWalkRef &delete_walk_ref() {
        return delete_walk_ref_;
    }
    //Walk to release all references.
    void ReleaseVrfWalkReference();
    bool Deregister(DBTablePartBase *partition, DBEntryBase *e);
    static void DeregisterDone(AgentRouteWalkerPtr walker);
 
    Agent *agent_;
    std::string name_;
    VrfRouteWalkCountMap route_walk_count_;
    std::atomic<int> walk_count_;
    WalkDone walk_done_cb_;
    RouteWalkDoneCb route_walk_done_for_vrf_cb_;
    DBTable::DBTableWalkRef vrf_walk_ref_;
    AgentRouteWalkerManager *mgr_;
    bool deregister_done_;
    DBTable::DBTableWalkRef delete_walk_ref_;
    mutable std::atomic<uint32_t> refcount_;
    DISALLOW_COPY_AND_ASSIGN(AgentRouteWalker);
};
 
class AgentRouteWalkerManager {
public:
    typedef std::set<AgentRouteWalkerPtr> WalkRefList;
    typedef std::set<AgentRouteWalkerPtr>::iterator WalkRefListIter;
 
    AgentRouteWalkerManager(Agent *agent);
    virtual ~AgentRouteWalkerManager();
    Agent *agent() {return agent_;}
 
    void RegisterWalker(AgentRouteWalker *walker);
    void ReleaseWalker(AgentRouteWalker *walker);
    void Shutdown();
    void TryUnregister();
    //UT helper
    uint8_t walk_ref_list_size() const {return walk_ref_list_.size();}
 
protected:
    friend class AgentRouteWalker;
    void VrfNotify(DBTablePartBase *partition, DBEntryBase *e);
    void RemoveWalker(AgentRouteWalkerPtr walker);
    void ValidateAgentRouteWalker(AgentRouteWalkerPtr walker) const;
    RouteWalkerDBState *CreateState(VrfEntry *vrf);
    void RemoveWalkReferencesInVrf(RouteWalkerDBState *state, VrfEntry *vrf);
    DBTable::ListenerId vrf_listener_id() const {
        return vrf_listener_id_;
    }
 
private:
    DBTable::ListenerId vrf_listener_id_;
    Agent *agent_;
    WalkRefList walk_ref_list_;
    bool marked_for_deletion_;
    DISALLOW_COPY_AND_ASSIGN(AgentRouteWalkerManager);
};
 
#endif