LCOV - code coverage report
Current view: top level - root/contrail/src/contrail-common/sandesh/library/cpp - sandesh_connection.cc (source / functions) Hit Total Coverage
Test: OpenSDN C/C++ coverage (all TARGET_SET jobs) Lines: 0 122 0.0 %
Date: 2026-11-16 02:06:09 Functions: 0 27 0.0 %
Legend: Lines: hit not hit

          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             : //
       7             : // sandesh_connection.cc
       8             : //
       9             : // Sandesh connection management implementation
      10             : //
      11             : 
      12             : #include <io/tcp_session.h>
      13             : #include <io/tcp_server.h>
      14             : #include <base/logging.h>
      15             : #include <sandesh/protocol/TXMLProtocol.h>
      16             : 
      17             : #include <sandesh/sandesh_types.h>
      18             : #include <sandesh/sandesh.h>
      19             : #include <sandesh/sandesh_ctrl_types.h>
      20             : #include <sandesh/common/vns_types.h>
      21             : #include <sandesh/common/vns_constants.h>
      22             : #include "sandesh_uve.h"
      23             : #include "sandesh_session.h"
      24             : #include "sandesh_client.h"
      25             : #include "sandesh_server.h"
      26             : #include "sandesh_connection.h"
      27             : 
      28             : using namespace std;
      29             : using boost::system::error_code;
      30             : 
      31             : #define CONNECTION_LOG(_Level, _Msg)                                           \
      32             :     do {                                                                       \
      33             :         if (LoggingDisabled()) break;                                          \
      34             :         log4cplus::Logger _Xlogger = Sandesh::logger();                        \
      35             :         if (_Xlogger.isEnabledFor(log4cplus::_Level##_LOG_LEVEL)) {            \
      36             :             log4cplus::tostringstream _Xbuf;                                   \
      37             :             if (!state_machine()->generator_key().empty()) {                   \
      38             :                 _Xbuf << state_machine()->generator_key() << " (" <<           \
      39             :                     GetTaskInstance() << ") ";                                 \
      40             :             }                                                                  \
      41             :             if (session()) {                                                   \
      42             :                 _Xbuf << session()->ToString() << " ";                         \
      43             :             }                                                                  \
      44             :             _Xbuf << _Msg;                                                     \
      45             :             _Xlogger.forcedLog(log4cplus::_Level##_LOG_LEVEL,                  \
      46             :                                _Xbuf.str());                                   \
      47             :         }                                                                      \
      48             :     } while (false)
      49             : 
      50           0 : SandeshConnection::SandeshConnection(const char *prefix, TcpServer *server,
      51           0 :         Endpoint endpoint, int task_instance, int task_id)
      52           0 :     : is_deleted_(false),
      53           0 :       server_(server),
      54           0 :       endpoint_(endpoint),
      55           0 :       admin_down_(false),
      56           0 :       session_(NULL),
      57           0 :       task_instance_(task_instance),
      58           0 :       task_id_(task_id),
      59           0 :       state_machine_(new SandeshStateMachine(prefix, this)) {
      60           0 : }
      61             : 
      62           0 : SandeshConnection::~SandeshConnection() {
      63           0 : }
      64             : 
      65           0 : void SandeshConnection::set_session(SandeshSession *session) {
      66           0 :     session_ = session;
      67           0 : }
      68             : 
      69           0 : SandeshSession *SandeshConnection::session() const {
      70           0 :     return session_;
      71             : }
      72             : 
      73           0 : bool SandeshConnection::ReceiveMsg(const std::string &msg, SandeshSession *session) {
      74           0 :     return state_machine_->OnSandeshMessage(session, msg);
      75             : }
      76             : 
      77           0 : bool SandeshConnection::SendSandesh(Sandesh *snh) {
      78           0 :     if (!session_) {
      79           0 :         snh->Release();
      80           0 :         return false;
      81             :     }
      82           0 :     ssm::SsmState state = state_machine_->get_state();
      83           0 :     if (state != ssm::SERVER_INIT && state != ssm::ESTABLISHED) {
      84           0 :         snh->Release();
      85           0 :         return false;
      86             :     }
      87             :     // XXX No bounded work queue
      88           0 :     SandeshElement element(snh);
      89           0 :     session_->send_queue()->Enqueue(element);
      90           0 :     return true;
      91             : }
      92             : 
      93           0 : void SandeshConnection::AcceptSession(SandeshSession *session) {
      94           0 :     session->SetReceiveMsgCb(boost::bind(&SandeshConnection::ReceiveMsg, this, _1, _2));
      95           0 :     session->SetConnection(this);
      96           0 :     state_machine_->PassiveOpen(session);
      97           0 : }
      98             : 
      99           0 : SandeshStateMachine *SandeshConnection::state_machine() const {
     100           0 :     return state_machine_.get();
     101             : }
     102             : 
     103           0 : void SandeshConnection::SetAdminState(bool down) {
     104           0 :     if (admin_down_ != down) {
     105           0 :         admin_down_ = down;
     106           0 :         state_machine_->SetAdminState(down);
     107             :     }
     108           0 : }
     109             : 
     110           0 : void SandeshConnection::Shutdown() {
     111           0 :     is_deleted_ = true;
     112           0 :     deleter()->Delete();
     113           0 : }
     114             : 
     115           0 : bool SandeshConnection::MayDelete() const {
     116             :     // XXX Do we have any dependencies?
     117           0 :     return true;
     118             : }
     119             : 
     120             : class SandeshServerConnection::DeleteActor : public LifetimeActor {
     121             : public:
     122           0 :     DeleteActor(SandeshServer *server, SandeshServerConnection *parent)
     123           0 :         : LifetimeActor(server->lifetime_manager()),
     124           0 :           server_(server), parent_(parent) {
     125           0 :     }
     126           0 :     virtual bool MayDelete() const {
     127           0 :         return parent_->MayDelete();
     128             :     }
     129           0 :     virtual void Shutdown() {
     130           0 :         SandeshSession *session = NULL;
     131           0 :         if (parent_->state_machine()) {
     132           0 :             session = parent_->state_machine()->session();
     133           0 :             parent_->state_machine()->clear_session();
     134             :         }
     135           0 :         if (session) {
     136           0 :             server_->DeleteSession(session);
     137             :         }
     138           0 :         parent_->is_deleted_ = true;
     139           0 :     }
     140           0 :     virtual void Destroy() {
     141           0 :         parent_->Destroy();
     142           0 :     }
     143             : 
     144             : private:
     145             :     SandeshServer *server_;
     146             :     SandeshServerConnection *parent_;
     147             : };
     148             : 
     149           0 : SandeshServerConnection::SandeshServerConnection(
     150           0 :         TcpServer *server, Endpoint endpoint, int task_instance, int task_id)
     151             :     : SandeshConnection("SandeshServer: ", server, endpoint, task_instance, task_id),
     152           0 :       deleter_(new DeleteActor(dynamic_cast<SandeshServer *>(server), this)),
     153           0 :       server_delete_ref_(this, dynamic_cast<SandeshServer *>(server)->deleter()) {
     154           0 : }
     155             : 
     156           0 : SandeshServerConnection::~SandeshServerConnection() {
     157           0 : }
     158             : 
     159           0 : void SandeshServerConnection::ManagedDelete() {
     160           0 :     deleter_->Delete();
     161           0 : }
     162             : 
     163           0 : bool SandeshServerConnection::ProcessSandeshCtrlMessage(const std::string &msg,
     164             :         const SandeshHeader &header, const std::string sandesh_name,
     165             :         const uint32_t header_offset) {
     166           0 :     SandeshServer *sserver = dynamic_cast<SandeshServer *>(server());
     167           0 :     if (!sserver) {
     168           0 :         CONNECTION_LOG(ERROR, __func__ << " No Server");
     169           0 :         return false;
     170             :     }
     171           0 :     Sandesh *ctrl_snh = SandeshSession::DecodeCtrlSandesh(msg, header, sandesh_name,
     172             :                                                           header_offset);
     173           0 :     bool ret = sserver->ReceiveSandeshCtrlMsg(state_machine(), session(), ctrl_snh);
     174           0 :     ctrl_snh->Release();
     175           0 :     return ret;
     176             : }
     177             : 
     178           0 : bool SandeshServerConnection::ProcessResourceUpdate(bool rsc) {
     179           0 :     SandeshServer *sserver = dynamic_cast<SandeshServer *>(server());
     180           0 :     if (!sserver) {
     181           0 :         CONNECTION_LOG(ERROR, __func__ << " No Server");
     182           0 :         return false;
     183             :     }
     184           0 :     return sserver->ReceiveResourceUpdate(session(), rsc);
     185             : }
     186             : 
     187           0 : bool SandeshServerConnection::ProcessSandeshMessage(
     188             :         const SandeshMessage *msg, bool resource) {
     189           0 :     SandeshServer *sserver = dynamic_cast<SandeshServer *>(server());
     190           0 :     if (!sserver) {
     191           0 :         CONNECTION_LOG(ERROR, __func__ << " No Server");
     192           0 :         return false;
     193             :     }
     194           0 :     sserver->ReceiveSandeshMsg(session(), msg, resource);
     195           0 :     return true;
     196             : }
     197             : 
     198           0 : void SandeshServerConnection::ProcessDisconnect(SandeshSession * sess) {
     199           0 :     SandeshServer *sserver = dynamic_cast<SandeshServer *>(server());
     200           0 :     if (!sserver) {
     201           0 :         CONNECTION_LOG(ERROR, __func__ << " No Server");
     202           0 :         return;
     203             :     }
     204           0 :     sserver->DisconnectSession(sess);
     205             : }
     206             : 
     207           0 : LifetimeManager *SandeshServerConnection::lifetime_manager() {
     208           0 :     SandeshServer *sserver = dynamic_cast<SandeshServer *>(server());
     209           0 :     if (!sserver) {
     210           0 :         CONNECTION_LOG(ERROR, __func__ << " No Server");
     211           0 :         return NULL;
     212             :     }
     213           0 :     return sserver->lifetime_manager();
     214             : }
     215             : 
     216           0 : void SandeshServerConnection::Destroy() {
     217           0 :     SandeshServer *sserver = dynamic_cast<SandeshServer *>(server());
     218           0 :     if (!sserver) {
     219           0 :         CONNECTION_LOG(ERROR, __func__ << " No Server");
     220           0 :         return;
     221             :     }
     222           0 :     int index = GetTaskInstance();
     223           0 :     if (index != -1) {
     224           0 :         sserver->FreeConnectionIndex(index);
     225             :     }
     226             :     // Deletes self - should always be the last 
     227           0 :     sserver->RemoveConnection(this);
     228             : };
     229             : 
     230           0 : LifetimeActor *SandeshServerConnection::deleter() {
     231           0 :     return deleter_.get();
     232             : }

Generated by: LCOV version 1.14