-
Notifications
You must be signed in to change notification settings - Fork 390
/
physical_device_vn.h
159 lines (132 loc) · 5.82 KB
/
physical_device_vn.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
/*
* Copyright (c) 2014 Juniper Networks, Inc. All rights reserved.
*/
#ifndef SRC_VNSW_AGENT_OPER_PHYSICAL_DEVICE_VN_H_
#define SRC_VNSW_AGENT_OPER_PHYSICAL_DEVICE_VN_H_
/////////////////////////////////////////////////////////////////////////////
// Manages DB Table of "Physical Device and Virtual-Network" membership. The
// table is built based on the IFMap schema
/////////////////////////////////////////////////////////////////////////////
#include <cmn/agent_cmn.h>
#include <cmn/agent.h>
#include <string>
class IFMapDependencyManager;
struct PhysicalDeviceVnToVmi {
PhysicalDeviceVnToVmi(const boost::uuids::uuid &dev,
const boost::uuids::uuid &vn,
const boost::uuids::uuid vmi) :
dev_(dev), vn_(vn), vmi_(vmi) {
}
PhysicalDeviceVnToVmi() :
dev_(boost::uuids::nil_uuid()), vn_(boost::uuids::nil_uuid()),
vmi_(boost::uuids::nil_uuid()) {
}
PhysicalDeviceVnToVmi(const PhysicalDeviceVnToVmi &rhs) :
dev_(rhs.dev_), vn_(rhs.vn_), vmi_(rhs.vmi_) {
}
virtual ~PhysicalDeviceVnToVmi() { }
bool operator() (const PhysicalDeviceVnToVmi &lhs,
const PhysicalDeviceVnToVmi &rhs) {
if (lhs.dev_ != rhs.dev_)
return lhs.dev_ < rhs.dev_;
if (lhs.vn_ != rhs.vn_)
return lhs.vn_ < rhs.vn_;
return lhs.vmi_ < rhs.vmi_;
}
boost::uuids::uuid dev_;
boost::uuids::uuid vn_;
boost::uuids::uuid vmi_;
};
struct PhysicalDeviceVnKey : public AgentKey {
explicit PhysicalDeviceVnKey(const boost::uuids::uuid &dev_uuid,
const boost::uuids::uuid &vn_uuid) :
AgentKey(), device_uuid_(dev_uuid), vn_uuid_(vn_uuid) { }
virtual ~PhysicalDeviceVnKey() { }
boost::uuids::uuid device_uuid_;
boost::uuids::uuid vn_uuid_;
};
struct PhysicalDeviceVnData : public AgentData {
PhysicalDeviceVnData() { }
virtual ~PhysicalDeviceVnData() { }
};
class PhysicalDeviceVn : AgentRefCount<PhysicalDeviceVn>,
public AgentDBEntry {
public:
PhysicalDeviceVn(const boost::uuids::uuid &device_uuid,
const boost::uuids::uuid &vn_uuid) :
device_uuid_(device_uuid), vn_uuid_(vn_uuid), device_(), vn_(),
vxlan_id_(0), tor_ip_(Ip4Address(0)), device_display_name_() { }
virtual ~PhysicalDeviceVn() { }
virtual bool IsLess(const DBEntry &rhs) const;
virtual void SetKey(const DBRequestKey *key);
virtual std::string ToString() const;
uint32_t GetRefCount() const {
return AgentRefCount<PhysicalDeviceVn>::GetRefCount();
}
DBEntryBase::KeyPtr GetDBRequestKey() const;
const boost::uuids::uuid &device_uuid() const { return device_uuid_; }
PhysicalDevice *device() const { return device_.get(); }
const boost::uuids::uuid &vn_uuid() const { return vn_uuid_; }
VnEntry *vn() const { return vn_.get(); }
int vxlan_id() const { return vxlan_id_; }
const IpAddress &tor_ip() const {return tor_ip_;}
const std::string &device_display_name() const {return device_display_name_;}
bool Copy(PhysicalDeviceVnTable *table, const PhysicalDeviceVnData *data);
void SendObjectLog(AgentLogEvent::type event) const;
bool DBEntrySandesh(Sandesh *sresp, std::string &name) const;
private:
friend class PhysicalDeviceVnTable;
boost::uuids::uuid device_uuid_;
boost::uuids::uuid vn_uuid_;
PhysicalDeviceRef device_;
VnEntryRef vn_;
int vxlan_id_;
IpAddress tor_ip_;
std::string device_display_name_;
DISALLOW_COPY_AND_ASSIGN(PhysicalDeviceVn);
};
class PhysicalDeviceVnTable : public AgentDBTable {
public:
struct Compare {
bool operator() (const PhysicalDeviceVnKey &left,
const PhysicalDeviceVnKey &right) {
if (left.device_uuid_ != right.device_uuid_) {
return left.device_uuid_ < right.device_uuid_;
}
return left.vn_uuid_ < right.vn_uuid_;
}
};
typedef std::set<PhysicalDeviceVnToVmi, PhysicalDeviceVnToVmi> ConfigTree;
PhysicalDeviceVnTable(DB *db, const std::string &name) :
AgentDBTable(db, name), walkid_(DBTableWalker::kInvalidWalkerId) { }
virtual ~PhysicalDeviceVnTable() { }
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 *req);
virtual bool IFNodeToReq(IFMapNode *node, DBRequest &req);
virtual bool Resync(DBEntry *entry, const DBRequest *req);
virtual AgentSandeshPtr GetAgentSandesh(const AgentSandeshArguments *args,
const std::string &context);
void ProcessConfig(const boost::uuids::uuid &dev,
const boost::uuids::uuid &vn);
bool AddConfigEntry(const boost::uuids::uuid &vmi,
const boost::uuids::uuid &dev,
const boost::uuids::uuid &vn);
bool DeleteConfigEntry(const boost::uuids::uuid &vmi,
const boost::uuids::uuid &dev,
const boost::uuids::uuid &vn);
const ConfigTree &config_tree() const { return config_tree_; }
static DBTableBase *CreateTable(DB *db, const std::string &name);
bool DeviceVnWalk(DBTablePartBase *partition, DBEntryBase *entry);
void DeviceVnWalkDone(DBTableBase *partition);
// Handle change in VxLan Identifier mode from global-config
void UpdateVxLanNetworkIdentifierMode();
private:
ConfigTree config_tree_;
DBTableWalker::WalkId walkid_;
DISALLOW_COPY_AND_ASSIGN(PhysicalDeviceVnTable);
};
#endif // SRC_VNSW_AGENT_OPER_PHYSICAL_DEVICE_VN_H_