/
mirror_table.h
176 lines (161 loc) · 7.18 KB
/
mirror_table.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
/*
* Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
*/
#ifndef vnsw_agent_mirror_table_hpp
#define vnsw_agent_mirror_table_hpp
#include <cmn/agent_cmn.h>
#include <cmn/agent.h>
#include <agent_types.h>
struct MirrorEntryKey : public AgentKey {
MirrorEntryKey(const std::string analyzer_name)
: analyzer_name_(analyzer_name) {
}
std::string analyzer_name_;
};
struct MirrorEntryData : public AgentData {
enum MirrorEntryFlags {
DynamicNH_With_JuniperHdr = 1,
DynamicNH_Without_JuniperHdr = 2,
StaticNH_With_JuniperHdr = 3,
StaticNH_Without_JuniperHdr = 4
};
MirrorEntryData(const std::string vrf_name, const IpAddress &sip,
const uint16_t sport, const IpAddress &dip,
const uint16_t dport, uint8_t mirror_flags,
uint32_t vni, const MacAddress &mac, bool createdvrf):
vrf_name_(vrf_name), sip_(sip), sport_(sport), dip_(dip),
dport_(dport), mirror_flags_(mirror_flags), vni_(vni),
mac_(mac), createdvrf_(createdvrf){ };
std::string vrf_name_;
IpAddress sip_;
uint16_t sport_;
IpAddress dip_;
uint16_t dport_;
uint8_t mirror_flags_;
uint32_t vni_;
MacAddress mac_; // can be type of vtep mac or analyzer-mac based on type NH
bool createdvrf_;
};
class MirrorEntry : AgentRefCount<MirrorEntry>, public AgentDBEntry {
public:
MirrorEntry(std::string analyzer_name) :
analyzer_name_(analyzer_name), vrf_(NULL, this), nh_(NULL),
vrf_name_(""), createdvrf_(false) { };
virtual ~MirrorEntry() { };
virtual bool IsLess(const DBEntry &rhs) const;
virtual bool Change(const DBRequest *req) {return false;};
virtual void SetKey(const DBRequestKey *key);
virtual KeyPtr GetDBRequestKey() const;
virtual std::string ToString() const { return "MirrorEntry";};
uint32_t GetRefCount() const {
return AgentRefCount<MirrorEntry>::GetRefCount();
}
bool DBEntrySandesh(Sandesh *sresp, std::string &name) const;
void set_mirror_entrySandeshData(MirrorEntrySandeshData &data) const;
uint32_t vrf_id() const;
const VrfEntry *GetVrf() const;
const std::string GetAnalyzerName() const {return analyzer_name_;}
const IpAddress *GetSip() const {return &sip_;}
uint16_t GetSPort() const {return sport_;}
const IpAddress *GetDip() const {return &dip_;}
uint16_t GetDPort() const {return dport_;}
const NextHop *GetNH() const {return nh_.get();}
const std::string vrf_name() const {return vrf_name_;}
uint32_t GetVni() const {return vni_;}
uint8_t GetMirrorFlag() const {return mirror_flags_;}
const MacAddress *GetMac() const { return &mac_;}
bool GetCreatedVrf() const {return createdvrf_;}
private:
std::string analyzer_name_;
VrfEntryRef vrf_;
IpAddress sip_;
uint16_t sport_;
IpAddress dip_;
uint16_t dport_;
NextHopRef nh_;
std::string vrf_name_;
uint8_t mirror_flags_;
uint32_t vni_;
MacAddress mac_; // can be type of vtep mac or analyzer-mac based on type NH
// this vrf will be created if this mirror vrf is not known to compute node
// add it subscribes for the route information to get down loaded
bool createdvrf_;
friend class MirrorTable;
};
class MirrorTable : public AgentDBTable {
public:
const static unsigned bufLen = 512;
const static uint8_t kInvalidIndex = 0xFF;
typedef std::vector<MirrorEntry *> MirrorEntryList;
typedef std::map<std::string , MirrorEntryList> VrfMirrorEntryList;
typedef std::pair<std::string , MirrorEntryList> VrfMirrorEntry;
MirrorTable(DB *db, const std::string &name) : AgentDBTable(db, name) {
}
virtual ~MirrorTable();
virtual std::auto_ptr<DBEntry> AllocEntry(const DBRequestKey *k) const;
virtual size_t Hash(const DBEntry *entry) const {return 0;}
virtual size_t Hash(const DBRequestKey *key) const {return 0;}
virtual DBEntry *Add(const DBRequest *req);
virtual bool OnChange(DBEntry *entry, const DBRequest *req);
virtual bool Delete(DBEntry *entry, const DBRequest *request);
virtual bool Resync(DBEntry *entry, const DBRequest *req) {
bool ret = OnChange(entry, req);
return ret;
}
virtual AgentSandeshPtr GetAgentSandesh(const AgentSandeshArguments *args,
const std::string &context);
VrfEntry *FindVrfEntry(const std::string &vrf_name) const;
static void AddMirrorEntry(const std::string &analyzer_name,
const std::string &vrf_name,
const IpAddress &sip, uint16_t sport,
const IpAddress &dip, uint16_t dport);
static void AddMirrorEntry(const std::string &analyzer_name,
const std::string &vrf_name,
const IpAddress &sip, uint16_t sport,
const IpAddress &dip, uint16_t dport,
uint32_t vni, uint8_t mirror_flag,
const MacAddress &mac);
static void DelMirrorEntry(const std::string &analyzer_name);
virtual void OnZeroRefcount(AgentDBEntry *e);
static DBTableBase *CreateTable(DB *db, const std::string &name);
static MirrorTable *GetInstance() {return mirror_table_;}
void MirrorSockInit(void);
void ReadHandler(const boost::system::error_code& error, size_t bytes);
void AddUnresolved(MirrorEntry *entry);
void RemoveUnresolved(MirrorEntry *entry);
void AddResolvedVrfMirrorEntry(MirrorEntry *entry);
void DeleteResolvedVrfMirrorEntry(MirrorEntry *entry);
void ResyncMirrorEntry(VrfMirrorEntryList &list, const VrfEntry *vrf);
void ResyncResolvedMirrorEntry(const VrfEntry *vrf);
void ResyncUnresolvedMirrorEntry(const VrfEntry *vrf);
void Add(VrfMirrorEntryList &vrf_entry_map, MirrorEntry *entry);
void Delete(VrfMirrorEntryList &vrf_entry_map, MirrorEntry *entry);
void VrfListenerInit();
void VrfNotify(DBTablePartBase *root, DBEntryBase *entry);
void Shutdown();
void Initialize();
bool OnChange(MirrorEntry *mirror_entry);
struct MirrorVrfState : DBState {
MirrorVrfState() : DBState(), seen_(false),
bridge_rt_table_listener_id_(DBTableBase::kInvalidId) {}
bool seen_;
DBTableBase::ListenerId bridge_rt_table_listener_id_;
};
void BridgeRouteTableNotify(DBTablePartBase *partition, DBEntryBase *e);
void UnRegisterBridgeRouteTableListener(const VrfEntry *entry,
MirrorVrfState *state);
bool UnresolvedMirrorVrf(const VrfEntry *vrf, VrfMirrorEntryList &list);
MirrorEntry* GetMirrorEntry(VrfEntry *vrf, const MacAddress & mac,
VrfMirrorEntryList &list);
static MirrorEntryData::MirrorEntryFlags
DecodeMirrorFlag (const std::string &nh_mode, bool juniper_header);
void DeleteMirrorVrf(MirrorEntry *entry);
private:
std::auto_ptr<boost::asio::ip::udp::socket> udp_sock_;
static MirrorTable *mirror_table_;
char rx_buff_[bufLen];
VrfMirrorEntryList unresolved_entry_list_;
VrfMirrorEntryList resolved_entry_list_;
DBTableBase::ListenerId vrf_listener_id_;
};
#endif