Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2016 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include "control_node.h"
       6             : 
       7             : #include "base/misc_utils.h"
       8             : #include "base/task.h"
       9             : #include "base/task_annotations.h"
      10             : #include "base/task_trigger.h"
      11             : #include "base/timer.h"
      12             : #include "bgp/bgp_server.h"
      13             : #include "bgp/bgp_xmpp_channel.h"
      14             : #include "control-node/sandesh/control_node_types.h"
      15             : #include "ifmap/ifmap_server.h"
      16             : 
      17             : std::string ControlNode::hostname_;
      18             : std::string ControlNode::prog_name_;
      19             : std::string ControlNode::self_ip_;
      20             : bool ControlNode::test_mode_;
      21             : 
      22             : static std::unique_ptr<Timer> node_info_log_timer;
      23             : static std::unique_ptr<TaskTrigger> node_info_trigger;
      24             : 
      25         189 : bool ControlNode::ControlNodeInfoLogger(const BgpServer *server,
      26             :         const BgpXmppChannelManager *xmpp_channel_mgr,
      27             :         const IFMapServer *ifmap_server, const string &build_info) {
      28         189 :     CHECK_CONCURRENCY("bgp::ShowCommand");
      29             :     static bool first = true;
      30         189 :     static BgpRouterState state;
      31         189 :     bool change = false;
      32             : 
      33         189 :     state.set_name(server->localname());
      34             : 
      35             :     // Send self information.
      36         189 :     if (first) {
      37           1 :         state.set_uptime(UTCTimestampUsec());
      38           1 :         change = true;
      39             :     }
      40             : 
      41         189 :     vector<string> ip_list;
      42         189 :     ip_list.push_back(ControlNode::GetSelfIp());
      43         189 :     if (first || state.get_bgp_router_ip_list() != ip_list) {
      44           1 :         state.set_bgp_router_ip_list(ip_list);
      45           1 :         change = true;
      46             :     }
      47             : 
      48             :     // Send Build information.
      49         189 :     if (first || build_info != state.get_build_info()) {
      50           1 :         state.set_build_info(build_info);
      51           1 :         change = true;
      52             :     }
      53             : 
      54         189 :     change |= server->CollectStats(&state, first);
      55         189 :     change |= xmpp_channel_mgr->CollectStats(&state, first);
      56         189 :     change |= ifmap_server->CollectStats(&state, first);
      57             : 
      58         189 :     if (change) {
      59          33 :         assert(!state.get_name().empty());
      60          33 :         BGPRouterInfo::Send(state);
      61             : 
      62             :         // Reset changed flags in the uve structure.
      63          33 :         memset(static_cast<void*>(&state.__isset), 0, sizeof(state.__isset));
      64             :     }
      65             : 
      66             :     /* Release process free memory to back to system */
      67         189 :     int rc = malloc_trim(0);
      68         189 :     if (!rc) {
      69           0 :         LOG(ERROR, "Control-node free memory is not released to system,"
      70             :             " rc: " << rc);
      71             :     }
      72             : 
      73         189 :     first = false;
      74         189 :     return true;
      75         189 : }
      76             : 
      77         189 : bool ControlNode::ControlNodeInfoLogTimer(TaskTrigger *node_info_trigger) {
      78         189 :     node_info_trigger->Set();
      79             :     // Periodic timer. Restart
      80         189 :     return true;
      81             : }
      82             : 
      83           1 : void ControlNode::StartControlNodeInfoLogger(
      84             :         EventManager &evm, uint64_t period_msecs,
      85             :         const BgpServer *bgp_server,
      86             :         const BgpXmppChannelManager *xmpp_channel_mgr,
      87             :         const IFMapServer *ifmap_server, const string &build_info) {
      88           2 :     node_info_trigger.reset(
      89             :         new TaskTrigger(
      90           2 :             boost::bind(&ControlNode::ControlNodeInfoLogger, bgp_server,
      91             :                         xmpp_channel_mgr, ifmap_server, build_info),
      92           2 :             TaskScheduler::GetInstance()->GetTaskId("bgp::ShowCommand"), 0));
      93             : 
      94           1 :     node_info_log_timer.reset(TimerManager::CreateTimer(*evm.io_service(),
      95             :                                   "ControlNode Info log timer"));
      96             : 
      97             :     // Start periodic timer to send BGPRouterInfo UVE.
      98           1 :     node_info_log_timer->Start(period_msecs,
      99             :         boost::bind(&ControlNode::ControlNodeInfoLogTimer,
     100             :                     node_info_trigger.get()), NULL);
     101           1 : }
     102             : 
     103           1 : void ControlNode::Shutdown() {
     104           1 :     node_info_trigger->set_disable();
     105           1 :     while (node_info_trigger->IsSet())
     106           0 :         usleep(100);
     107           1 :     node_info_trigger.reset();
     108           1 :     if (node_info_log_timer.get()) {
     109           1 :         node_info_log_timer->Cancel();
     110           1 :         while (node_info_log_timer->running() || node_info_log_timer->fired())
     111           0 :             usleep(100);
     112           1 :         TimerManager::DeleteTimer(node_info_log_timer.get());
     113           1 :         node_info_log_timer.release();
     114             :     }
     115           1 : }