Line data Source code
1 : /*
2 : * Copyright (c) 2016 Juniper Networks, Inc. All rights reserved.
3 : * Copyright Contributors to the OpenSDN project
4 : */
5 : #include "bgp/bgp_xmpp_rtarget_manager.h"
6 :
7 : #include <utility>
8 : #include <vector>
9 :
10 : #include <boost/foreach.hpp>
11 :
12 : #include "bgp/ipeer.h"
13 : #include "bgp/bgp_peer_types.h"
14 : #include "bgp/bgp_server.h"
15 : #include "bgp/bgp_xmpp_channel.h"
16 : #include "routing-instance/routing_instance.h"
17 :
18 : using std::make_pair;
19 : using std::pair;
20 : using std::string;
21 : using std::vector;
22 :
23 200 : BgpXmppRTargetManager::BgpXmppRTargetManager(BgpXmppChannel *bgp_xmpp_channel) :
24 200 : bgp_xmpp_channel_(bgp_xmpp_channel) {
25 200 : }
26 :
27 400 : BgpXmppRTargetManager::~BgpXmppRTargetManager() {
28 400 : }
29 :
30 440 : bool BgpXmppRTargetManager::IsSubscriptionEmpty() const {
31 440 : return bgp_xmpp_channel_->IsSubscriptionEmpty();
32 : }
33 :
34 0 : bool BgpXmppRTargetManager::IsSubscriptionGrStale(
35 : RoutingInstance *instance) const {
36 0 : return bgp_xmpp_channel_->IsSubscriptionGrStale(instance);
37 : }
38 :
39 0 : bool BgpXmppRTargetManager::IsSubscriptionLlgrStale(
40 : RoutingInstance *instance) const {
41 0 : return bgp_xmpp_channel_->IsSubscriptionLlgrStale(instance);
42 : }
43 :
44 1104 : bool BgpXmppRTargetManager::delete_in_progress() const {
45 1104 : return bgp_xmpp_channel_->delete_in_progress();
46 : }
47 :
48 1824 : const IPeer *BgpXmppRTargetManager::Peer() const {
49 1824 : return bgp_xmpp_channel_->Peer();
50 : }
51 :
52 1824 : void BgpXmppRTargetManager::Enqueue(DBRequest *req) const {
53 : RoutingInstanceMgr *instance_mgr =
54 1824 : bgp_xmpp_channel_->bgp_server()->routing_instance_mgr();
55 1824 : RoutingInstance *master = instance_mgr->GetDefaultRoutingInstance();
56 1824 : BgpTable *table = master->GetTable(Address::RTARGET);
57 1824 : assert(table);
58 1824 : table->Enqueue(req);
59 1824 : }
60 :
61 2000 : BgpAttrPtr BgpXmppRTargetManager::GetRouteTargetRouteAttr() const {
62 2000 : BgpAttrSpec attrs;
63 2000 : BgpAttrNextHop nexthop(bgp_xmpp_channel_->bgp_server()->bgp_identifier());
64 2000 : attrs.push_back(&nexthop);
65 2000 : BgpAttrOrigin origin(BgpAttrOrigin::IGP);
66 2000 : attrs.push_back(&origin);
67 4000 : return bgp_xmpp_channel_->bgp_server()->attr_db()->Locate(attrs);
68 2000 : }
69 :
70 1824 : int BgpXmppRTargetManager::local_autonomous_system() const {
71 1824 : return bgp_xmpp_channel_->bgp_server()->local_autonomous_system();
72 : }
73 :
74 : const BgpXmppRTargetManager::RouteTargetList &
75 440 : BgpXmppRTargetManager::GetSubscribedRTargets(RoutingInstance *instance) const {
76 440 : return bgp_xmpp_channel_->GetSubscribedRTargets(instance);
77 : }
78 :
79 720 : uint32_t BgpXmppRTargetManager::GetRTargetRouteFlag(
80 : const RouteTarget &rtarget) const {
81 : PublishedRTargetRoutes::const_iterator rt_loc =
82 720 : rtarget_routes_.find(rtarget);
83 720 : if (rt_loc == rtarget_routes_.end() || rt_loc->second.empty())
84 720 : return 0;
85 :
86 : // Route is [llgr-]stale only if it is stale for all instances in the set.
87 0 : uint32_t flags = BgpPath::Stale | BgpPath::LlgrStale;
88 0 : BOOST_FOREACH(RoutingInstance *routing_instance, rt_loc->second) {
89 0 : if (!IsSubscriptionGrStale(routing_instance))
90 0 : flags &= ~BgpPath::Stale;
91 0 : if (!IsSubscriptionLlgrStale(routing_instance))
92 0 : flags &= ~BgpPath::LlgrStale;
93 0 : if (!flags)
94 0 : break;
95 : }
96 :
97 0 : return flags;
98 : }
99 :
100 1824 : void BgpXmppRTargetManager::RTargetRouteOp(as_t asn,
101 : const RouteTarget &rtarget,
102 : BgpAttrPtr attr, bool add_change,
103 : uint32_t flags) const {
104 1824 : if (add_change && delete_in_progress())
105 0 : return;
106 :
107 1824 : DBRequest req;
108 1824 : RTargetPrefix rt_prefix(asn, rtarget);
109 1824 : req.key.reset(new RTargetTable::RequestKey(rt_prefix, Peer()));
110 1824 : if (add_change) {
111 : // Find correct rtarget route flags if not already known.
112 1104 : if (!flags)
113 720 : flags = GetRTargetRouteFlag(rtarget);
114 1104 : req.data.reset(new RTargetTable::RequestData(attr, flags, 0, 0, 0));
115 1104 : req.oper = DBRequest::DB_ENTRY_ADD_CHANGE;
116 : } else {
117 720 : req.oper = DBRequest::DB_ENTRY_DELETE;
118 : }
119 1824 : Enqueue(&req);
120 1824 : }
121 :
122 0 : void BgpXmppRTargetManager::ASNUpdateCallback(as_t old_asn,
123 : as_t old_local_asn) const {
124 0 : if (local_autonomous_system() == (int)old_local_asn)
125 0 : return;
126 0 : if (IsSubscriptionEmpty())
127 0 : return;
128 :
129 : // Delete the route and add with new local ASN
130 0 : BgpAttrPtr attr = GetRouteTargetRouteAttr();
131 0 : for (PublishedRTargetRoutes::const_iterator it = rtarget_routes_.begin();
132 0 : it != rtarget_routes_.end(); it++) {
133 0 : RTargetRouteOp(old_local_asn, it->first, NULL, false);
134 0 : RTargetRouteOp(local_autonomous_system(), it->first, attr, true);
135 : }
136 0 : }
137 :
138 1920 : void BgpXmppRTargetManager::AddNewRTargetRoute(RoutingInstance *rtinstance,
139 : const RouteTarget &rtarget, BgpAttrPtr attr) {
140 1920 : PublishedRTargetRoutes::iterator rt_loc = rtarget_routes_.find(rtarget);
141 1920 : if (rt_loc == rtarget_routes_.end()) {
142 : pair<PublishedRTargetRoutes::iterator, bool> ret =
143 720 : rtarget_routes_.insert(make_pair(rtarget, RoutingInstanceList()));
144 :
145 720 : rt_loc = ret.first;
146 :
147 : // Send rtarget route ADD
148 720 : RTargetRouteOp(local_autonomous_system(), rtarget, attr, true);
149 : }
150 1920 : rt_loc->second.insert(rtinstance);
151 1920 : }
152 :
153 192 : void BgpXmppRTargetManager::DeleteRTargetRoute(
154 : RoutingInstance *rtinstance, const RouteTarget &rtarget) {
155 192 : PublishedRTargetRoutes::iterator rt_loc = rtarget_routes_.find(rtarget);
156 192 : assert(rt_loc != rtarget_routes_.end());
157 192 : assert(rt_loc->second.erase(rtinstance));
158 192 : if (rt_loc->second.empty()) {
159 72 : rtarget_routes_.erase(rtarget);
160 : // Send rtarget route DELETE
161 72 : RTargetRouteOp(local_autonomous_system(), rtarget, NULL, false);
162 : }
163 192 : }
164 :
165 0 : void BgpXmppRTargetManager::RoutingInstanceCallback(
166 : RoutingInstance *rt_instance, RouteTargetList *targets) {
167 : // Import list in the routing instance
168 0 : const RouteTargetList &new_list = rt_instance->GetImportList();
169 :
170 : // Previous route target list for which the rtarget route was added
171 0 : RouteTargetList *current = targets;
172 0 : RouteTargetList::iterator cur_next_it, cur_it;
173 0 : cur_it = cur_next_it = current->begin();
174 0 : RouteTargetList::const_iterator new_it = new_list.begin();
175 :
176 0 : pair<RouteTargetList::iterator, bool> r;
177 0 : BgpAttrPtr attr = GetRouteTargetRouteAttr();
178 0 : while (cur_it != current->end() && new_it != new_list.end()) {
179 0 : if (*new_it < *cur_it) {
180 0 : r = current->insert(*new_it);
181 0 : assert(r.second);
182 0 : AddNewRTargetRoute(rt_instance, *new_it, attr);
183 0 : new_it++;
184 0 : } else if (*new_it > *cur_it) {
185 0 : cur_next_it++;
186 0 : DeleteRTargetRoute(rt_instance, *cur_it);
187 0 : current->erase(cur_it);
188 0 : cur_it = cur_next_it;
189 : } else {
190 : // Update
191 0 : cur_it++;
192 0 : new_it++;
193 : }
194 0 : cur_next_it = cur_it;
195 : }
196 0 : for (; new_it != new_list.end(); ++new_it) {
197 0 : r = current->insert(*new_it);
198 0 : assert(r.second);
199 0 : AddNewRTargetRoute(rt_instance, *new_it, attr);
200 : }
201 0 : for (cur_next_it = cur_it;
202 0 : cur_it != current->end();
203 0 : cur_it = cur_next_it) {
204 0 : cur_next_it++;
205 0 : DeleteRTargetRoute(rt_instance, *cur_it);
206 0 : current->erase(cur_it);
207 : }
208 0 : }
209 :
210 80 : void BgpXmppRTargetManager::UpdateRouteTargetRouteFlag(
211 : RoutingInstance *routing_instance, const RouteTargetList &targets,
212 : uint32_t flags) const {
213 80 : BgpAttrPtr attr = GetRouteTargetRouteAttr();
214 848 : BOOST_FOREACH(RouteTarget rtarget, targets) {
215 : // Update route target route [llgr-]stale flag status.
216 384 : RTargetRouteOp(local_autonomous_system(), rtarget, attr, true, flags);
217 : }
218 80 : }
219 :
220 120 : void BgpXmppRTargetManager::Close() {
221 120 : if (rtarget_routes_.empty())
222 48 : return;
223 :
224 72 : for (PublishedRTargetRoutes::iterator it = rtarget_routes_.begin();
225 720 : it != rtarget_routes_.end(); it++) {
226 648 : RTargetRouteOp(local_autonomous_system(), it->first, NULL, false);
227 : }
228 72 : rtarget_routes_.clear();
229 : }
230 :
231 0 : void BgpXmppRTargetManager::Stale(const RouteTargetList &targets) const {
232 0 : BgpAttrPtr attr = GetRouteTargetRouteAttr();
233 :
234 : // Update route targets to clear STALE flag.
235 0 : BOOST_FOREACH(RouteTarget rtarget, targets) {
236 : PublishedRTargetRoutes::const_iterator rt_loc =
237 0 : rtarget_routes_.find(rtarget);
238 0 : assert(rt_loc != rtarget_routes_.end());
239 :
240 : // Send rtarget route ADD
241 0 : RTargetRouteOp(local_autonomous_system(), rtarget, attr, true);
242 : }
243 0 : }
244 :
245 : // Add/Delete rtarget route for import route target of the routing instance.
246 440 : void BgpXmppRTargetManager::PublishRTargetRoute(RoutingInstance *rt_instance,
247 : bool add_change) {
248 440 : if (IsSubscriptionEmpty())
249 0 : return;
250 :
251 440 : if (add_change) {
252 4240 : BOOST_FOREACH(RouteTarget rtarget, GetSubscribedRTargets(rt_instance)) {
253 1920 : AddNewRTargetRoute(rt_instance, rtarget, GetRouteTargetRouteAttr());
254 : }
255 : } else {
256 424 : BOOST_FOREACH(RouteTarget rtarget, GetSubscribedRTargets(rt_instance)) {
257 192 : DeleteRTargetRoute(rt_instance, rtarget);
258 : }
259 : }
260 : }
261 :
262 0 : void BgpXmppRTargetManager::FillInfo(BgpNeighborRoutingInstance *instance,
263 : const RouteTargetList &targets) const {
264 0 : vector<string> import_targets;
265 0 : BOOST_FOREACH(RouteTarget rt, targets) {
266 0 : import_targets.push_back(rt.ToString());
267 : }
268 0 : instance->set_import_targets(import_targets);
269 0 : }
|