Line data    Source code

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