Line data Source code
1 : /*
2 : * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
3 : * Copyright Contributors to the OpenSDN project
4 : */
5 :
6 : #include "bgp/peer_close_manager.h"
7 :
8 :
9 : #include <list>
10 : #include <map>
11 :
12 : #include <boost/foreach.hpp>
13 :
14 : #include "base/task_annotations.h"
15 : #include "bgp/bgp_log.h"
16 : #include "bgp/bgp_membership.h"
17 : #include "bgp/bgp_peer_types.h"
18 : #include "bgp/bgp_route.h"
19 : #include "bgp/bgp_server.h"
20 : #include "bgp/routing-instance/routing_instance.h"
21 : #include "net/community_type.h"
22 :
23 : #define PEER_CLOSE_MANAGER_LOG(msg) \
24 : BGP_LOG_PEER(Event, peer_close_->peer(), SandeshLevel::SYS_INFO, \
25 : BGP_LOG_FLAG_ALL, BGP_PEER_DIR_NA, \
26 : "PeerCloseManager: State " << GetStateName(state_) << \
27 : ", MembershipState: " << GetMembershipStateName(membership_state_) << \
28 : ", MembershipReqPending: " << membership_req_pending_ << \
29 : ", CloseAgain?: " << (close_again_ ? "Yes" : "No") << ": " << msg);
30 :
31 : #define PEER_CLOSE_MANAGER_TABLE_LOG(msg) \
32 : BGP_LOG_PEER_TABLE(peer_close_->peer(), SandeshLevel::SYS_INFO, \
33 : BGP_LOG_FLAG_ALL, table, \
34 : "PeerCloseManager: State " << GetStateName(state_) << \
35 : ", MembershipState: " << GetMembershipStateName(membership_state_) << \
36 : ", MembershipReqPending: " << membership_req_pending_ << \
37 : ", CloseAgain?: " << (close_again_ ? "Yes" : "No") << ": " << msg);
38 :
39 : #define MOVE_TO_STATE(state) \
40 : do { \
41 : assert(state_ != state); \
42 : PEER_CLOSE_MANAGER_LOG("Move to state " << GetStateName(state)); \
43 : state_ = state; \
44 : } while (false)
45 :
46 : // Create an instance of PeerCloseManager with back reference to parent IPeer
47 0 : PeerCloseManager::PeerCloseManager(IPeerClose *peer_close,
48 0 : boost::asio::io_context *io_service) :
49 0 : peer_close_(peer_close), gr_timer_(NULL),
50 0 : event_queue_(new WorkQueue<Event *>(
51 0 : TaskScheduler::GetInstance()->GetTaskId(
52 0 : peer_close_->GetTaskName()),
53 0 : peer_close_->GetTaskInstance(),
54 0 : boost::bind(&PeerCloseManager::EventCallback, this, _1))),
55 0 : state_(NONE), close_again_(false), graceful_(true), gr_elapsed_(0),
56 0 : llgr_elapsed_(0), membership_state_(MEMBERSHIP_NONE) {
57 0 : stats_.init++;
58 0 : membership_req_pending_ = 0;
59 0 : gr_timer_ = TimerManager::CreateTimer(*io_service,
60 : "Graceful Restart Timer");
61 0 : }
62 :
63 : // Create an instance of PeerCloseManager with back reference to parent IPeer
64 232 : PeerCloseManager::PeerCloseManager(IPeerClose *peer_close) :
65 232 : peer_close_(peer_close), gr_timer_(NULL),
66 464 : event_queue_(new WorkQueue<Event *>(
67 696 : TaskScheduler::GetInstance()->GetTaskId(
68 232 : peer_close_->GetTaskName()),
69 232 : peer_close_->GetTaskInstance(),
70 232 : boost::bind(&PeerCloseManager::EventCallback, this, _1))),
71 232 : state_(NONE), close_again_(false), graceful_(true), gr_elapsed_(0),
72 464 : llgr_elapsed_(0), membership_state_(MEMBERSHIP_NONE) {
73 232 : stats_.init++;
74 232 : membership_req_pending_ = 0;
75 232 : if (peer_close->peer() && peer_close->peer()->server()) {
76 152 : gr_timer_ =
77 152 : TimerManager::CreateTimer(*peer_close->peer()->server()->ioservice(),
78 : "Graceful Restart Timer");
79 : }
80 232 : }
81 :
82 232 : PeerCloseManager::~PeerCloseManager() {
83 232 : event_queue_->Shutdown();
84 232 : TimerManager::DeleteTimer(gr_timer_);
85 232 : }
86 :
87 3804 : std::string PeerCloseManager::GetStateName(State state) const {
88 3804 : switch (state) {
89 330 : case NONE:
90 330 : return "NONE";
91 226 : case GR_TIMER:
92 226 : return "GR_TIMER";
93 1408 : case STALE:
94 1408 : return "STALE";
95 0 : case LLGR_STALE:
96 0 : return "LLGR_STALE";
97 0 : case LLGR_TIMER:
98 0 : return "LLGR_TIMER";
99 768 : case SWEEP:
100 768 : return "SWEEP";
101 1072 : case DELETE:
102 1072 : return "DELETE";
103 : }
104 0 : assert(false);
105 : return "";
106 : }
107 :
108 3596 : std::string PeerCloseManager::GetMembershipStateName(
109 : MembershipState state) const {
110 3596 : switch (state) {
111 428 : case MEMBERSHIP_NONE:
112 428 : return "NONE";
113 3142 : case MEMBERSHIP_IN_USE:
114 3142 : return "IN_USE";
115 26 : case MEMBERSHIP_IN_WAIT:
116 26 : return "IN_WAIT";
117 : }
118 0 : assert(false);
119 : return "";
120 : }
121 :
122 1332 : std::string PeerCloseManager::GetEventName(EventType eventType) const {
123 1332 : switch (eventType) {
124 0 : case EVENT_NONE:
125 0 : return "NONE";
126 80 : case CLOSE:
127 80 : return "CLOSE";
128 196 : case EOR_RECEIVED:
129 196 : return "EOR_RECEIVED";
130 64 : case MEMBERSHIP_REQUEST:
131 64 : return "MEMBERSHIP_REQUEST";
132 976 : case MEMBERSHIP_REQUEST_COMPLETE_CALLBACK:
133 976 : return "MEMBERSHIP_REQUEST_COMPLETE_CALLBACK";
134 16 : case TIMER_CALLBACK:
135 16 : return "TIMER_CALLBACK";
136 : }
137 :
138 0 : return "";
139 : }
140 :
141 3447 : void PeerCloseManager::EnqueueEvent(Event *event) {
142 4271 : PEER_CLOSE_MANAGER_LOG("Enqueued event " <<
143 : GetEventName(event->event_type) <<
144 : ", graceful " << event->graceful <<
145 : ", family " << Address::FamilyToString(event->family));
146 3449 : event_queue_->Enqueue(event);
147 3464 : }
148 :
149 : // Trigger closure of an IPeer
150 : //
151 : // Graceful close_state_: NONE
152 : // RibIn Stale Marking and Ribout deletion close_state_: STALE
153 : // StateMachine restart and GR timer start close_state_: GR_TIMER
154 : //
155 : // Peer IsReady() in GR timer callback (or via reception of all EoRs)
156 : // RibIn Sweep and Ribout Generation close_state_: SWEEP
157 : // MembershipRequestCallback close_state_: NONE
158 : //
159 : // Peer not IsReady() in GR timer callback
160 : // If LLGR supported close_state_: LLGR_STALE
161 : // RibIn Stale marking with LLGR_STALE community close_state_: LLGR_TIMER
162 : //
163 : // Peer not IsReady() in LLGR timer callback
164 : // RibIn Delete close_state_: DELETE
165 : // MembershipRequestCallback close_state_: NONE
166 : //
167 : // Peer IsReady() in LLGR timer callback (or via reception of all EoRs)
168 : // RibIn Sweep close_state_: SWEEP
169 : // MembershipRequestCallback close_state_: NONE
170 : //
171 : // If LLGR is not supported
172 : // RibIn Delete close_state_: DELETE
173 : // MembershipRequestCallback close_state_: NONE
174 : //
175 : // Close() call during any state other than NONE and DELETE
176 : // Cancel GR timer and restart GR Closure all over again
177 : //
178 : // NonGraceful close_state_ = * (except DELETE)
179 : // A. RibIn deletion and Ribout deletion close_state_ = DELETE
180 : // B. MembershipRequestCallback => Peers delete/StateMachine restart
181 : // close_state_ = NONE
182 : //
183 : // If Close is restarted, account for GR timer's elapsed time.
184 : //
185 : // Use graceful as true to close gracefully.
186 232 : void PeerCloseManager::Close(bool graceful) {
187 232 : EnqueueEvent(new Event(CLOSE, graceful));
188 232 : }
189 :
190 232 : void PeerCloseManager::Close(Event *event) {
191 : // Note down non-graceful close trigger. Once non-graceful closure is
192 : // triggered, it should remain so until close process is complete. Further
193 : // graceful closure calls until then should remain non-graceful.
194 232 : graceful_ &= event->graceful;
195 232 : CloseInternal();
196 232 : }
197 :
198 248 : void PeerCloseManager::CloseInternal() {
199 248 : stats_.close++;
200 :
201 : // Ignore nested closures
202 248 : if (close_again_) {
203 0 : PEER_CLOSE_MANAGER_LOG("Nested close calls ignored");
204 0 : return;
205 : }
206 :
207 248 : switch (state_) {
208 232 : case NONE:
209 232 : stats_.ResetRouteStats();
210 232 : ProcessClosure();
211 232 : break;
212 :
213 16 : case GR_TIMER:
214 24 : PEER_CLOSE_MANAGER_LOG("Nested close: Restart GR");
215 16 : close_again_ = true;
216 16 : stats_.nested++;
217 16 : gr_elapsed_ += gr_timer_->GetElapsedTime();
218 16 : CloseComplete();
219 16 : break;
220 :
221 0 : case LLGR_TIMER:
222 0 : PEER_CLOSE_MANAGER_LOG("Nested close: Restart LLGR");
223 0 : close_again_ = true;
224 0 : stats_.nested++;
225 0 : llgr_elapsed_ += gr_timer_->GetElapsedTime();
226 0 : CloseComplete();
227 0 : break;
228 :
229 0 : case STALE:
230 : case LLGR_STALE:
231 : case SWEEP:
232 : case DELETE:
233 0 : PEER_CLOSE_MANAGER_LOG("Nested close");
234 0 : close_again_ = true;
235 0 : stats_.nested++;
236 0 : break;
237 : }
238 : }
239 :
240 356 : void PeerCloseManager::ProcessEORMarkerReceived(Address::Family family) {
241 356 : EnqueueEvent(new Event(EOR_RECEIVED, family));
242 356 : }
243 :
244 356 : void PeerCloseManager::ProcessEORMarkerReceived(Event *event) {
245 356 : if ((state_ == GR_TIMER || state_ == LLGR_TIMER) && !families_.empty()) {
246 50 : if (event->family == Address::UNSPEC) {
247 8 : families_.clear();
248 : } else {
249 42 : families_.erase(event->family);
250 : }
251 :
252 : // Start the timer if all EORs have been received.
253 50 : if (families_.empty())
254 16 : StartRestartTimer(0);
255 : }
256 356 : }
257 :
258 : // Process RibIn during peer closure.
259 48 : void PeerCloseManager::StartRestartTimer(int time) {
260 48 : gr_timer_->Cancel();
261 72 : PEER_CLOSE_MANAGER_LOG("GR Timer started to fire after " << time/1000 <<
262 : " seconds");
263 48 : gr_timer_->Start(time,
264 : boost::bind(&PeerCloseManager::RestartTimerCallback, this));
265 48 : }
266 :
267 16 : bool PeerCloseManager::RestartTimerCallback() {
268 16 : CHECK_CONCURRENCY("timer::TimerTask");
269 16 : EnqueueEvent(new Event(TIMER_CALLBACK));
270 16 : return false;
271 : }
272 :
273 16 : void PeerCloseManager::RestartTimerCallback(Event *event) {
274 16 : CHECK_CONCURRENCY(peer_close_->GetTaskName());
275 :
276 24 : PEER_CLOSE_MANAGER_LOG("GR Timer callback started");
277 16 : if (state_ != GR_TIMER && state_ != LLGR_TIMER)
278 0 : return;
279 :
280 16 : if (peer_close_->IsReady() && !families_.empty()) {
281 : // Fake reception of all EORs.
282 0 : for (IPeerClose::Families::iterator i = families_.begin(), next = i;
283 0 : i != families_.end(); i = next) {
284 0 : next++;
285 0 : PEER_CLOSE_MANAGER_LOG("Simulate EoR reception for family " << *i);
286 0 : peer_close_->ReceiveEndOfRIB(*i);
287 : }
288 : } else {
289 16 : ProcessClosure();
290 : }
291 : }
292 :
293 : // Route stale timer callback. If the peer has come back up, sweep routes for
294 : // those address families that are still active. Delete the rest
295 248 : void PeerCloseManager::ProcessClosure() {
296 : // If the peer is back up and this address family is still supported,
297 : // sweep old paths which may not have come back in the new session
298 248 : switch (state_) {
299 232 : case NONE:
300 232 : if (!graceful_ || !peer_close_->IsCloseGraceful()) {
301 224 : MOVE_TO_STATE(DELETE);
302 200 : stats_.deletes++;
303 : } else {
304 48 : MOVE_TO_STATE(STALE);
305 32 : stats_.stale++;
306 32 : StaleNotify();
307 32 : return;
308 : }
309 200 : break;
310 16 : case GR_TIMER:
311 16 : if (peer_close_->IsReady()) {
312 24 : MOVE_TO_STATE(SWEEP);
313 16 : gr_elapsed_ = 0;
314 16 : llgr_elapsed_ = 0;
315 16 : stats_.sweep++;
316 16 : break;
317 : }
318 0 : if (peer_close_->IsCloseLongLivedGraceful()) {
319 0 : MOVE_TO_STATE(LLGR_STALE);
320 0 : stats_.llgr_stale++;
321 0 : peer_close_->LongLivedGracefulRestartStale();
322 0 : break;
323 : }
324 0 : MOVE_TO_STATE(DELETE);
325 0 : stats_.deletes++;
326 0 : break;
327 :
328 0 : case LLGR_TIMER:
329 0 : if (peer_close_->IsReady()) {
330 0 : MOVE_TO_STATE(SWEEP);
331 0 : gr_elapsed_ = 0;
332 0 : llgr_elapsed_ = 0;
333 0 : stats_.sweep++;
334 0 : break;
335 : }
336 0 : MOVE_TO_STATE(DELETE);
337 0 : stats_.deletes++;
338 0 : break;
339 :
340 0 : case STALE:
341 : case LLGR_STALE:
342 : case SWEEP:
343 : case DELETE:
344 0 : assert(false);
345 : return;
346 : }
347 :
348 216 : if (state_ == DELETE)
349 200 : peer_close_->CustomClose();
350 216 : MembershipRequest();
351 : }
352 :
353 32 : void PeerCloseManager::CloseComplete() {
354 48 : MOVE_TO_STATE(NONE);
355 32 : gr_timer_->Cancel();
356 32 : families_.clear();
357 32 : stats_.init++;
358 :
359 : // Nested closures trigger fresh GR
360 32 : if (close_again_) {
361 16 : close_again_ = false;
362 16 : CloseInternal();
363 : }
364 32 : }
365 :
366 16 : bool PeerCloseManager::AssertSweepState(bool do_assert) {
367 16 : bool check = (state_ == SWEEP);
368 16 : if (do_assert)
369 16 : assert(check);
370 16 : return check;
371 : }
372 :
373 2712 : bool PeerCloseManager::AssertMembershipManagerInUse(bool do_assert) {
374 2712 : bool check = false;
375 4752 : check |= (state_ == STALE || state_ == LLGR_STALE || state_ == SWEEP ||
376 2040 : state_ == DELETE);
377 2712 : check |= (membership_state_ == MEMBERSHIP_IN_USE);
378 2712 : check |= (membership_req_pending_ > 0);
379 2712 : if (do_assert)
380 2712 : assert(check);
381 2712 : return check;
382 : }
383 :
384 256 : bool PeerCloseManager::AssertMembershipState(bool do_assert) {
385 256 : bool check = (membership_state_ != MEMBERSHIP_IN_USE);
386 256 : if (do_assert)
387 256 : assert(check);
388 256 : return check;
389 : }
390 :
391 248 : bool PeerCloseManager::AssertMembershipReqCount(bool do_assert) {
392 248 : bool check = !membership_req_pending_;
393 248 : if (do_assert)
394 248 : assert(check);
395 248 : return check;
396 : }
397 :
398 16 : void PeerCloseManager::TriggerSweepStateActions() {
399 16 : CHECK_CONCURRENCY(peer_close_->GetTaskName());
400 16 : if (!AssertSweepState())
401 0 : return;
402 :
403 : // Notify clients to trigger sweep as appropriate.
404 16 : peer_close_->GracefulRestartSweep();
405 :
406 : // Reset MembershipUse state after client has been notified above.
407 16 : set_membership_state(MEMBERSHIP_NONE);
408 16 : CloseComplete();
409 : }
410 :
411 : // Notify clients about entering Stale event.
412 32 : void PeerCloseManager::StaleNotify() {
413 32 : CHECK_CONCURRENCY(peer_close_->GetTaskName());
414 :
415 32 : peer_close_->GracefulRestartStale();
416 32 : if (!AssertMembershipState())
417 0 : return;
418 32 : MembershipRequest(NULL);
419 : }
420 :
421 224 : bool PeerCloseManager::CanUseMembershipManager() const {
422 224 : return peer_close_->peer()->CanUseMembershipManager();
423 : }
424 :
425 248 : void PeerCloseManager::GetRegisteredRibs(std::list<BgpTable *> *tables) {
426 248 : BgpMembershipManager *mgr = peer_close_->peer()->server()->membership_mgr();
427 248 : mgr->GetRegisteredRibs(peer_close_->peer(), tables);
428 248 : }
429 :
430 2648 : bool PeerCloseManager::IsRegistered(BgpTable *table) const {
431 2648 : BgpMembershipManager *mgr = peer_close_->peer()->server()->membership_mgr();
432 2648 : return mgr->IsRegistered(peer_close_->peer(), table);
433 : }
434 :
435 1944 : void PeerCloseManager::Unregister(BgpTable *table) {
436 1944 : BgpMembershipManager *mgr = peer_close_->peer()->server()->membership_mgr();
437 1944 : mgr->Unregister(peer_close_->peer(), table);
438 1944 : }
439 :
440 432 : void PeerCloseManager::WalkRibIn(BgpTable *table) {
441 432 : BgpMembershipManager *mgr = peer_close_->peer()->server()->membership_mgr();
442 432 : mgr->WalkRibIn(peer_close_->peer(), table);
443 432 : }
444 :
445 240 : void PeerCloseManager::UnregisterRibOut(BgpTable *table) {
446 240 : BgpMembershipManager *mgr = peer_close_->peer()->server()->membership_mgr();
447 240 : mgr->UnregisterRibOut(peer_close_->peer(), table);
448 240 : }
449 :
450 424 : bool PeerCloseManager::IsRibInRegistered(BgpTable *table) const {
451 424 : BgpMembershipManager *mgr = peer_close_->peer()->server()->membership_mgr();
452 424 : return mgr->IsRibInRegistered(peer_close_->peer(), table);
453 : }
454 :
455 32 : void PeerCloseManager::UnregisterRibIn(BgpTable *table) {
456 32 : BgpMembershipManager *mgr = peer_close_->peer()->server()->membership_mgr();
457 32 : mgr->UnregisterRibIn(peer_close_->peer(), table);
458 32 : }
459 :
460 224 : void PeerCloseManager::MembershipRequest() {
461 224 : if (!AssertMembershipState())
462 0 : return;
463 :
464 : // Pause if membership manager is not ready for usage.
465 224 : if (!CanUseMembershipManager()) {
466 8 : set_membership_state(MEMBERSHIP_IN_WAIT);
467 8 : PEER_CLOSE_MANAGER_LOG("Wait for membership manager availability");
468 8 : return;
469 : }
470 216 : set_membership_state(MEMBERSHIP_IN_USE);
471 216 : EnqueueEvent(new Event(MEMBERSHIP_REQUEST));
472 : }
473 :
474 248 : void PeerCloseManager::MembershipRequest(Event *evnet) {
475 248 : CHECK_CONCURRENCY(peer_close_->GetTaskName());
476 :
477 248 : set_membership_state(MEMBERSHIP_IN_USE);
478 248 : if (!AssertMembershipReqCount())
479 64 : return;
480 248 : membership_req_pending_++;
481 248 : std::list<BgpTable *> tables;
482 248 : GetRegisteredRibs(&tables);
483 :
484 248 : if (tables.empty()) {
485 64 : assert(MembershipRequestCallback(NULL));
486 64 : return;
487 : }
488 :
489 : // Account for extra increment above.
490 184 : membership_req_pending_--;
491 5480 : BOOST_FOREACH(BgpTable *table, tables) {
492 2648 : membership_req_pending_++;
493 2648 : if (IsRegistered(table)) {
494 2224 : if (state_ == PeerCloseManager::DELETE) {
495 2432 : PEER_CLOSE_MANAGER_TABLE_LOG(
496 : "MembershipManager::Unregister");
497 1944 : Unregister(table);
498 280 : } else if (state_ == PeerCloseManager::SWEEP) {
499 80 : PEER_CLOSE_MANAGER_TABLE_LOG("MembershipManager::WalkRibIn");
500 40 : WalkRibIn(table);
501 : } else {
502 664 : PEER_CLOSE_MANAGER_TABLE_LOG(
503 : "MembershipManager::UnregisterRibOut");
504 240 : UnregisterRibOut(table);
505 : }
506 : } else {
507 424 : assert(IsRibInRegistered(table));
508 424 : if (state_ == PeerCloseManager::DELETE) {
509 32 : PEER_CLOSE_MANAGER_TABLE_LOG(
510 : "MembershipManager::UnregisterRibIn");
511 32 : UnregisterRibIn(table);
512 : } else {
513 1152 : PEER_CLOSE_MANAGER_TABLE_LOG("MembershipManager::WalkRibIn");
514 392 : WalkRibIn(table);
515 : }
516 : }
517 : }
518 248 : }
519 :
520 2630 : void PeerCloseManager::MembershipRequestCallback() {
521 2630 : EnqueueEvent(new Event(MEMBERSHIP_REQUEST_COMPLETE_CALLBACK));
522 2645 : }
523 :
524 : // Close process for this peer in terms of walking RibIns and RibOuts are
525 : // complete. Do the final cleanups necessary and notify interested party
526 : //
527 : // Retrun true if we are done using membership manager, false otherwise.
528 2712 : bool PeerCloseManager::MembershipRequestCallback(Event *event) {
529 2712 : CHECK_CONCURRENCY(peer_close_->GetTaskName());
530 :
531 2712 : bool result = false;
532 3464 : PEER_CLOSE_MANAGER_LOG("MembershipRequestCallback");
533 :
534 2712 : if (!AssertMembershipManagerInUse())
535 0 : return result;
536 2712 : if (--membership_req_pending_)
537 2464 : return result;
538 :
539 : // Indicate to the caller that we are done using the membership manager.
540 248 : result = true;
541 :
542 248 : if (state_ == DELETE) {
543 224 : MOVE_TO_STATE(NONE);
544 200 : peer_close_->Delete();
545 200 : gr_elapsed_ = 0;
546 200 : llgr_elapsed_ = 0;
547 200 : stats_.init++;
548 200 : close_again_ = false;
549 200 : graceful_ = true;
550 200 : set_membership_state(MEMBERSHIP_NONE);
551 200 : return result;
552 : }
553 :
554 : // Process nested closures.
555 48 : if (close_again_) {
556 0 : set_membership_state(MEMBERSHIP_NONE);
557 0 : CloseComplete();
558 :
559 : // Nested closure can make membership manager to be in use again.
560 0 : return membership_state_ != MEMBERSHIP_IN_USE;
561 : }
562 :
563 : // If any GR stale timer has to be launched, then to wait for some time
564 : // hoping for the peer (and the paths) to come back up.
565 48 : if (state_ == STALE) {
566 32 : peer_close_->CloseComplete();
567 48 : MOVE_TO_STATE(GR_TIMER);
568 32 : peer_close_->GetGracefulRestartFamilies(&families_);
569 :
570 : // Offset restart time with elapsed time during nested closures.
571 32 : int time = peer_close_->GetGracefulRestartTime() * 1000;
572 32 : time -= gr_elapsed_;
573 32 : if (time < 0)
574 0 : time = 0;
575 32 : StartRestartTimer(time);
576 32 : stats_.gr_timer++;
577 32 : set_membership_state(MEMBERSHIP_NONE);
578 32 : return result;
579 : }
580 :
581 : // From LLGR_STALE state, switch to LLGR_TIMER state. Typically this would
582 : // be a very long timer, and we expect to receive EORs before this timer
583 : // expires.
584 : // Just like for GRSTALE in the above case, before moving to LLGR_TIMER and
585 : // starting LLGR_TIMER, we can check if the peer can come back up.
586 16 : if (state_ == LLGR_STALE) {
587 0 : MOVE_TO_STATE(LLGR_TIMER);
588 0 : peer_close_->CloseComplete();
589 0 : peer_close_->GetLongLivedGracefulRestartFamilies(&families_);
590 :
591 : // Offset restart time with elapsed time during nested closures.
592 0 : int time = peer_close_->GetLongLivedGracefulRestartTime() * 1000;
593 0 : time -= llgr_elapsed_;
594 0 : if (time < 0)
595 0 : time = 0;
596 0 : StartRestartTimer(time);
597 0 : stats_.llgr_timer++;
598 0 : set_membership_state(MEMBERSHIP_NONE);
599 0 : return result;
600 : }
601 :
602 16 : TriggerSweepStateActions();
603 16 : return result;
604 : }
605 :
606 0 : void PeerCloseManager::FillRouteCloseInfo(PeerCloseInfo *close_info) const {
607 0 : std::map<std::string, PeerCloseRouteInfo> route_stats;
608 :
609 0 : for (int i = 0; i < Address::NUM_FAMILIES; i++) {
610 0 : if (!stats_.route_stats[i].IsSet())
611 0 : continue;
612 0 : PeerCloseRouteInfo route_info;
613 0 : route_info.set_staled(stats_.route_stats[i].staled);
614 0 : route_info.set_llgr_staled(stats_.route_stats[i].llgr_staled);
615 0 : route_info.set_refreshed(stats_.route_stats[i].refreshed);
616 0 : route_info.set_fresh(stats_.route_stats[i].fresh);
617 0 : route_info.set_deleted(stats_.route_stats[i].deleted);
618 0 : route_stats[Address::FamilyToString(static_cast<Address::Family>(i))] = route_info;
619 0 : }
620 :
621 0 : if (!route_stats.empty())
622 0 : close_info->set_route_stats(route_stats);
623 0 : }
624 :
625 0 : BgpNeighborResp *PeerCloseManager::FillCloseInfo(BgpNeighborResp *resp) const {
626 0 : PeerCloseInfo peer_close_info;
627 0 : peer_close_info.set_state(GetStateName(state_));
628 0 : peer_close_info.set_membership_state(
629 0 : GetMembershipStateName(membership_state_));
630 0 : peer_close_info.set_close_again(close_again_);
631 0 : peer_close_info.set_graceful(graceful_);
632 0 : peer_close_info.set_init(stats_.init);
633 0 : peer_close_info.set_close(stats_.close);
634 0 : peer_close_info.set_nested(stats_.nested);
635 0 : peer_close_info.set_deletes(stats_.deletes);
636 0 : peer_close_info.set_stale(stats_.stale);
637 0 : peer_close_info.set_llgr_stale(stats_.llgr_stale);
638 0 : peer_close_info.set_sweep(stats_.sweep);
639 0 : peer_close_info.set_gr_timer(stats_.gr_timer);
640 0 : peer_close_info.set_llgr_timer(stats_.llgr_timer);
641 0 : FillRouteCloseInfo(&peer_close_info);
642 :
643 0 : resp->set_peer_close_info(peer_close_info);
644 :
645 0 : return resp;
646 0 : }
647 :
648 10595 : void PeerCloseManager::UpdateRouteStats(Address::Family family,
649 : const BgpPath *old_path, uint32_t path_flags) const {
650 10595 : if (state_ == NONE)
651 9690 : return;
652 :
653 905 : if (!old_path)
654 0 : stats_.route_stats[family].fresh++;
655 905 : else if (old_path->IsStale() && !(path_flags & BgpPath::Stale))
656 102 : stats_.route_stats[family].refreshed++;
657 : }
658 :
659 7155 : bool PeerCloseManager::MembershipPathCallback(DBTablePartBase *root,
660 : BgpRoute *rt, BgpPath *path) {
661 7155 : CHECK_CONCURRENCY("db::DBTable");
662 7151 : DBRequest::DBOperation oper = DBRequest::DB_ENTRY_INVALID;
663 7151 : BgpAttrPtr attrs;
664 :
665 7151 : BgpTable *table = static_cast<BgpTable *>(root->parent());
666 7149 : assert(table);
667 :
668 7149 : uint32_t stale = 0;
669 :
670 7149 : switch (state_) {
671 0 : case NONE:
672 : case GR_TIMER:
673 : case LLGR_TIMER:
674 0 : return false;
675 :
676 782 : case SWEEP:
677 :
678 : // Stale paths must be deleted.
679 782 : if (!path->IsStale() && !path->IsLlgrStale())
680 80 : return false;
681 702 : if (path->IsStale()) {
682 702 : path->ResetStale();
683 702 : table->UpdateStalePathCount(-1);
684 : }
685 704 : if (path->IsLlgrStale()) {
686 0 : path->ResetLlgrStale();
687 0 : table->UpdateLlgrStalePathCount(-1);
688 : }
689 704 : oper = DBRequest::DB_ENTRY_DELETE;
690 704 : attrs = NULL;
691 703 : stats_.route_stats[table->family()].deleted++;
692 703 : break;
693 :
694 4816 : case DELETE:
695 :
696 : // This path must be deleted. Hence attr is not required.
697 4816 : oper = DBRequest::DB_ENTRY_DELETE;
698 4816 : attrs = NULL;
699 4817 : stats_.route_stats[table->family()].deleted++;
700 4830 : break;
701 :
702 1551 : case STALE:
703 :
704 : // We do not support GR for multicast routes (yet).
705 3105 : if ((table->family() == Address::ERMVPN) ||
706 1555 : (table->family() == Address::MVPN)) {
707 0 : oper = DBRequest::DB_ENTRY_DELETE;
708 0 : attrs = NULL;
709 0 : stats_.route_stats[table->family()].deleted++;
710 0 : break;
711 : }
712 :
713 : // If path is already marked as stale, then there is no need to
714 : // process again. This can happen if the session flips while in
715 : // GR_TIMER state.
716 1553 : if (path->IsStale())
717 752 : return false;
718 :
719 : // This path must be marked for staling. Update the local
720 : // preference and update the route accordingly.
721 801 : oper = DBRequest::DB_ENTRY_ADD_CHANGE;
722 801 : attrs = path->GetAttr();
723 806 : stale = BgpPath::Stale;
724 806 : stats_.route_stats[table->family()].staled++;
725 806 : break;
726 :
727 0 : case LLGR_STALE:
728 :
729 : // If the path has NO_LLGR community, DELETE it.
730 0 : if (path->GetAttr()->community() &&
731 0 : path->GetAttr()->community()->ContainsValue(
732 : CommunityType::NoLlgr)) {
733 0 : oper = DBRequest::DB_ENTRY_DELETE;
734 0 : attrs = NULL;
735 0 : stats_.route_stats[table->family()].deleted++;
736 0 : break;
737 : }
738 :
739 : // If path is already marked as llgr_stale, then there is no
740 : // need to process again. This can happen if the session flips
741 : // while in LLGR_TIMER state.
742 0 : if (path->IsLlgrStale())
743 0 : return false;
744 :
745 0 : attrs = path->GetAttr();
746 0 : stale = BgpPath::LlgrStale;
747 0 : oper = DBRequest::DB_ENTRY_ADD_CHANGE;
748 0 : stats_.route_stats[table->family()].llgr_staled++;
749 0 : break;
750 : }
751 :
752 : // Feed the route modify/delete request to the table input process.
753 19015 : return table->InputCommon(root, rt, path, peer_close_->peer(), NULL, oper,
754 6338 : attrs, path->GetPathId(), path->GetFlags() | stale, path->GetLabel(),
755 6338 : path->GetL3Label());
756 7170 : }
757 :
758 : //
759 : // Handler for an Event.
760 : //
761 3468 : bool PeerCloseManager::EventCallback(Event *event) {
762 3468 : CHECK_CONCURRENCY(peer_close_->GetTaskName());
763 : bool result;
764 :
765 3468 : switch (event->event_type) {
766 0 : case EVENT_NONE:
767 0 : break;
768 232 : case CLOSE:
769 232 : Close(event);
770 232 : break;
771 356 : case EOR_RECEIVED:
772 356 : ProcessEORMarkerReceived(event);
773 356 : break;
774 216 : case MEMBERSHIP_REQUEST:
775 216 : MembershipRequest(event);
776 216 : break;
777 2648 : case MEMBERSHIP_REQUEST_COMPLETE_CALLBACK:
778 2648 : result = MembershipRequestCallback(event);
779 :
780 : // Notify clients if we are no longer using the membership mgr.
781 2648 : if (result)
782 184 : peer_close_->MembershipRequestCallbackComplete();
783 2648 : break;
784 16 : case TIMER_CALLBACK:
785 16 : RestartTimerCallback(event);
786 16 : break;
787 : }
788 :
789 3468 : delete event;
790 3468 : return true;
791 : }
|