ConnectionManager.h

Go to the documentation of this file.

// $Id: ConnectionManager.h 4468 2020-04-15 12:47:38Z linev $
 
/************************************************************
 * The Data Acquisition Backbone Core (DABC)                *
 ************************************************************
 * Copyright (C) 2009 -                                     *
 * GSI Helmholtzzentrum fuer Schwerionenforschung GmbH      *
 * Planckstr. 1, 64291 Darmstadt, Germany                   *
 * Contact:  http://dabc.gsi.de                             *
 ************************************************************
 * This software can be used under the GPL license          *
 * agreements as stated in LICENSE.txt file                 *
 * which is part of the distribution.                       *
 ************************************************************/
 
#ifndef DABC_ConnectionManager
#define DABC_ConnectionManager
 
#ifndef DABC_ModuleAsync
#include "dabc/ModuleAsync.h"
#endif
 
#ifndef DABC_ReferencesVector
#include "dabc/ReferencesVector.h"
#endif
 
namespace dabc {
 
   class ConnectionRequestFull : public ConnectionRequest {
 
       DABC_REFERENCE(ConnectionRequestFull, ConnectionRequest, ConnectionObject)
 
       // these states are representing connection state during connection establishing
 
       void SetUseAcknDirectly(bool on) { SetAllowedField(xmlUseacknAttr); SetUseAckn(on); }
 
       void SetConnTimeoutDirectly(double tm) { SetAllowedField(xmlTimeoutAttr); SetConnTimeout(tm); }
 
       std::string GetServerId() const { GET_PAR_FIELD(fServerId,"") }
       void SetServerId(const std::string &id) { SET_PAR_FIELD(fServerId, id) }
 
       std::string GetClientId() const { GET_PAR_FIELD(fClientId,"") }
       void SetClientId(const std::string &id) { SET_PAR_FIELD(fClientId, id) }
 
       int GetInlineDataSize() const { GET_PAR_FIELD(fInlineDataSize,0) }
       void SetInlineDataSize(int size) { SET_PAR_FIELD(fInlineDataSize, size) }
 
       Reference TakeCustomData() { GET_PAR_FIELD(fCustomData,0) }
       void SetCustomData(Reference ref) { SET_PAR_FIELD(fCustomData, ref) }
 
       std::string GetConnId() const { GET_PAR_FIELD(fConnId,"") }
       void SetConnId(const std::string &id) { SET_PAR_FIELD(fConnId, id) }
 
       int progress() const { GET_PAR_FIELD(fProgress,0) }
       void SetProgress(int pr) { SET_PAR_FIELD(fProgress, pr) }
 
       void SetRemoteCommand(dabc::Command cmd) { SET_PAR_FIELD(fRemoteCmd, cmd) }
       void ReplyRemoteCommand(bool res)
       {
          Command cmd;
          if (GetObject()) {
             LockGuard lock(GetObject()->ObjectMutex());
             cmd = GetObject()->fRemoteCmd;
             GetObject()->fRemoteCmd.Release();
          }
          cmd.ReplyBool(res);
       }
 
       bool match(const std::string localurl, const std::string remoteurl)
       {
          return (localurl == GetLocalUrl()) && (remoteurl == GetRemoteUrl());
       }
 
       std::string GetConnInfo()
       {
          return IsServerSide() ? (GetLocalUrl() + " --> " + GetRemoteUrl()) : (GetRemoteUrl() + " --> " + GetLocalUrl());
       }
 
       void ResetConnData()
       {
          SetProgress(0);
          SetConnTimeout(10.);
 
          // FIXME: should we protect fields here with mutex when clear ???
          SetServerId("");
          SetClientId("");
          TakeCustomData().Release();
          SetConnId("");
 
          ReplyRemoteCommand(false);
 
          if (GetObject())
             GetObject()->SetDelay(0, true);
       }
   };
 
   class CmdConnectionManagerHandle : public dabc::Command {
 
      DABC_COMMAND(CmdConnectionManagerHandle, "CmdConnectionManager")
 
      static const char* ReqArg() { return "#REQ"; }
 
      CmdConnectionManagerHandle(ConnectionRequestFull& req);
 
      std::string GetReq() const { return GetStr(ReqArg()); }
   };
 
 
   class CmdGlobalConnect : public Command {
 
      DABC_COMMAND(CmdGlobalConnect, "CmdGlobalConnect")
 
      void SetUrl1(const std::string &url1) { SetStr("Url1", url1); }
      void SetUrl2(const std::string &url2) { SetStr("Url2", url2); }
 
      std::string GetUrl1() const { return GetStr("Url1"); }
      std::string GetUrl2() const { return GetStr("Url2"); }
   };
 
   // ____________________________________________________________________________________
 
   class ConnectionManager : public ModuleAsync {
      protected:
         ReferencesVector   fRecs;
 
         Command            fConnCmd;          
         int                fDoingConnection;  
         int                fConnCounter;      
 
         void HandleConnectRequestCmdReply(CmdConnectionManagerHandle cmd);
 
         void HandleCmdGlobalConnectReply(CmdGlobalConnect cmd);
 
         bool FillAnswerOnRemoteConnectCmd(Command cmd, ConnectionRequestFull& req);
 
         void CheckConnectionRecs(bool finish_command = false);
 
         virtual void ModuleCleanup();
 
         virtual void ProcessParameterEvent(const ParameterEvent& evnt);
 
         virtual int ExecuteCommand(Command cmd);
         virtual bool ReplyCommand(Command cmd);
 
         virtual double ProcessTimeout(double last_diff);
 
      public:
 
         enum EConnProgress {
            progrInit,         
            progrDoingInit,    
            progrPending,      
            progrWaitReply,    
            progrDoingConnect, 
            progrConnected,    
            progrFailed        
         };
 
         ConnectionManager(const std::string &name, Command cmd = nullptr);
         virtual ~ConnectionManager();
 
         ConnectionRequestFull FindConnection(const std::string &url1, const std::string &url2);
   };
 
}
 
 
#endif