flow_mgmt_dbclient.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Juniper Networks, Inc. All rights reserved.
 */
#ifndef __AGENT_FLOW_MGMT_DBCLIENT_H__
#define __AGENT_FLOW_MGMT_DBCLIENT_H__
 
#include "pkt/flow_event.h"
 
class EcmpLoadBalance;
// Request to the Flow Management module
class FlowMgmtDbClient {
public:
    struct FlowMgmtState : public DBState {
        FlowMgmtState() : gen_id_(0), deleted_(false) { }
        virtual ~FlowMgmtState() { }
 
        void IncrementGenId() { gen_id_++; }
        uint32_t gen_id_;
        bool deleted_;
    };
 
    struct VnFlowHandlerState : public FlowMgmtState {
        AclDBEntryConstRef acl_;
        AclDBEntryConstRef macl_;
        AclDBEntryConstRef mcacl_;
        bool enable_rpf_;
        bool flood_unknown_unicast_;
        VnFlowHandlerState(const AclDBEntry *acl,
                           const AclDBEntry *macl,
                           const AclDBEntry *mcacl, bool enable_rpf,
                           bool flood_unknown_unicast) :
           acl_(acl), macl_(macl), mcacl_(mcacl), enable_rpf_(enable_rpf),
           flood_unknown_unicast_(flood_unknown_unicast){ }
        virtual ~VnFlowHandlerState() { }
    };
 
    struct VmIntfFlowHandlerState : public FlowMgmtState {
        VmIntfFlowHandlerState(const VnEntry *vn) : vn_(vn),
            vrf_assign_acl_(NULL), is_vn_qos_config_(false),
            forwarding_vrf_id_(VrfEntry::kInvalidIndex) { }
        virtual ~VmIntfFlowHandlerState() { }
 
        VnEntryConstRef vn_;
        bool policy_;
        VmInterface::SecurityGroupEntryList sg_l_;
        AclDBEntryConstRef vrf_assign_acl_;
        bool is_vn_qos_config_;
        AgentQosConfigConstRef qos_config_;
        FirewallPolicyList fw_policy_list_;
        FirewallPolicyList fwaas_fw_policy_list_;
        uint32_t forwarding_vrf_id_;
    };
 
    struct VrfFlowHandlerState : public FlowMgmtState {
        VrfFlowHandlerState() : deleted_(false) {}
        virtual ~VrfFlowHandlerState() {}
 
        // Register to all the route tables of intrest
        void Register(FlowMgmtDbClient *client, VrfEntry *vrf);
        void Unregister(FlowMgmtDbClient *client, VrfEntry *vrf);
 
        // Unregister from the route tables
        bool Unregister(VrfEntry *vrf);
 
        DBTableBase::ListenerId GetListenerId(Agent::RouteTableType type) {
            if (type == Agent::INET4_UNICAST)
                return inet_listener_id_;
            if (type == Agent::INET6_UNICAST)
                return inet6_listener_id_;
            if (type == Agent::BRIDGE)
                return bridge_listener_id_;
 
            assert(0);
            return -1;
        }
        DBTableBase::ListenerId inet_listener_id_;
        DBTableBase::ListenerId inet6_listener_id_;
        DBTableBase::ListenerId bridge_listener_id_;
        bool deleted_;
    };
 
    struct RouteFlowHandlerState : public FlowMgmtState {
        RouteFlowHandlerState() : sg_l_(), active_nh_(NULL), local_nh_(NULL),
            ecmp_load_balance_(), tags_l_() {}
        virtual ~RouteFlowHandlerState() { }
        typedef std::map<InterfaceConstRef, IpAddress> FixedIpMap;
        typedef std::pair<InterfaceConstRef, IpAddress> FixedIpEntry;
 
        SecurityGroupList sg_l_;
        const NextHop* active_nh_;
        const NextHop* local_nh_;
        FixedIpMap fixed_ip_map_;
        EcmpLoadBalance ecmp_load_balance_;
        TagList tags_l_;
        TunnelType::TypeBmap tunnel_bmap_;
    };
 
    struct NhFlowHandlerState : public FlowMgmtState {
        NhFlowHandlerState(uint8_t valid_encap_size) : valid_encap_size_(valid_encap_size) { }
        uint8_t valid_encap_size_;
        virtual ~NhFlowHandlerState() { }
    };
 
    struct AclFlowHandlerState : public FlowMgmtState {
        AclFlowHandlerState() { }
        virtual ~AclFlowHandlerState() { }
    };
 
    FlowMgmtDbClient(Agent *agent, FlowMgmtManager *mgr);
    virtual ~FlowMgmtDbClient();
 
    void Init();
    void Shutdown();
    bool FreeDBState(const DBEntry *entry, uint32_t gen_id);
    void FreeVrfState(VrfEntry *vrf, uint32_t gen_id);
 
private:
    friend class FlowMgmtRouteTest;
    void AddEvent(const DBEntry *entry, FlowMgmtState *state);
    void DeleteEvent(const DBEntry *entry, FlowMgmtState *state);
    void DeleteAllFlow(const DBEntry *entry, FlowMgmtState *state);
    void ChangeEvent(const DBEntry *entry, FlowMgmtState *state);
    void RouteNHChangeEvent(const DBEntry *entry, FlowMgmtState *state);
 
    void FreeInterfaceState(Interface *intf, uint32_t gen_id);
    void InterfaceNotify(DBTablePartBase *part, DBEntryBase *e);
 
    void FreeVnState(VnEntry *vn, uint32_t gen_id);
    void VnNotify(DBTablePartBase *part, DBEntryBase *e);
 
    void FreeAclState(AclDBEntry *acl, uint32_t gen_id);
    void AclNotify(DBTablePartBase *part, DBEntryBase *e);
 
    void FreeNhState(NextHop *nh, uint32_t gen_id);
    void NhNotify(DBTablePartBase *part, DBEntryBase *e);
 
    void VrfNotify(DBTablePartBase *part, DBEntryBase *e);
 
    void TraceMsg(AgentRoute *entry, const AgentPath *path,
                  const SecurityGroupList &sg_list, bool deleted);
    void FreeRouteState(AgentRoute *route, uint32_t gen_id);
    void RouteNotify(VrfFlowHandlerState *vrf_state, Agent::RouteTableType type,
                     DBTablePartBase *partition, DBEntryBase *e);
    bool HandleTrackingIpChange(const AgentRoute *rt,
                                RouteFlowHandlerState *state);
    Agent *agent_;
    FlowMgmtManager *mgr_;
 
    DBTableBase::ListenerId acl_listener_id_;
    DBTableBase::ListenerId interface_listener_id_;
    DBTableBase::ListenerId vn_listener_id_;
    DBTableBase::ListenerId vm_listener_id_;
    DBTableBase::ListenerId vrf_listener_id_;
    DBTableBase::ListenerId nh_listener_id_;
    DISALLOW_COPY_AND_ASSIGN(FlowMgmtDbClient);
};
 
#endif //  __AGENT_FLOW_MGMT_DBCLIENT_H__