SocketCommandChannel.h

Go to the documentation of this file.

// $Id: SocketCommandChannel.h 4482 2020-04-15 14:47:18Z 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_SocketCommandChannel
#define DABC_SocketCommandChannel
 
#ifndef DABC_SocketThread
#include "dabc/SocketThread.h"
#endif
 
namespace dabc {
 
 
   struct SocketCmdPacket {
 
      uint32_t dabc_header;   
 
      uint32_t data_kind;     
 
      uint32_t data_timeout;  
 
      uint32_t data_size;     
 
      uint32_t data_cmdsize;  
 
      uint32_t data_rawsize;  
 
   };
 
 
   class SocketCommandChannel;
 
   // ____________________________________________________________________________________
 
   class SocketCommandClient : public Worker {
      protected:
 
         friend class SocketCommandChannel;
 
         enum EEVent {
            evntActivate = SocketAddon::evntSocketLastInfo + 1
         };
 
         enum {
            headerDabc = 123707321
         };
 
         enum ECmdDataKindNew {
            kindCommand    = 1,    
            kindReply      = 2,    
            kindCancel     = 3,    
            kindDisconnect = 4     
         };
 
 
         enum EState {
            stConnecting,  
            stWorking,     
            stClosing,     
            stFailure      
         };
 
         enum ERecvState {
            recvInit,     // receiver  ready to accept new command
            recvHeader,   // command is assigned and executing
            recvDevConnect, // special case of socket device connect via command channel
            recvData      // command is sends back, one need to release command only when it is replied
         };
 
         std::string        fRemoteHostName;    
         double             fReconnectPeriod;   
 
         CommandsQueue      fCmds;              
 
         EState             fState;             
 
         SocketCmdPacket    fSendHdr;           
         dabc::Buffer       fSendBuf;           
         dabc::Buffer       fSendRawData;       
         bool               fSendingActive;     
         SocketCmdPacket    fRecvHdr;           
         char*              fRecvBuf;           
         unsigned           fRecvBufSize;       
 
         CommandsQueue      fSendQueue;         
         CommandsQueue      fWaitQueue;         
 
         ERecvState         fRecvState;         
 
         // these are fields, used to manage information about remote node
         bool               fRemoteObserver;   
         std::string        fRemoteName;       
 
         // indicate that this is special connection to master node
         // each time it is reconnected, it will append special command to register itself in remote master
         bool               fMasterConn;
         std::string        fClientNameSufix;  
 
         virtual void OnThreadAssigned();
 
         virtual int ExecuteCommand(Command cmd);
 
         virtual bool ReplyCommand(Command cmd);
 
         virtual void ProcessEvent(const EventId&);
 
         virtual double ProcessTimeout(double last_diff);
 
         bool EnsureRecvBuffer(unsigned strsize);
 
         void ProcessRecvPacket();
 
         void AddCommand(dabc::Command cmd, bool asreply = false);
 
         void SendSubmittedCommands();
 
         void SendCommand(dabc::Command cmd, bool asreply = false);
 
         void CloseClient(bool iserr = false, const char* msg = 0);
 
         double ExtraClientTimeout() const { return 1.0; }
         double ExtraServerTimeout() const { return 0.1; }
 
         bool ExecuteCommandByItself(Command cmd);
 
      public:
         SocketCommandClient(Reference parent, const std::string &name,
                             SocketAddon* addon,
                             const std::string &hostname = "",
                             double reconnect = 0.);
         virtual ~SocketCommandClient();
   };
 
   class SocketCommandClientRef : public WorkerRef {
 
      DABC_REFERENCE(SocketCommandClientRef, WorkerRef, SocketCommandClient)
   };
 
   // ____________________________________________________________________________________
 
 
   class SocketCommandChannel : public Worker {
 
      friend class SocketCommandClient;
 
      protected:
         int             fNodeId;         
         bool            fClientsAllowed; 
         int             fClientCnt;      
         std::string     fRedirectDevice; 
 
         virtual int PreviewCommand(Command cmd);
         virtual int ExecuteCommand(Command cmd);
 
         std::string GetRemoteNode(const std::string &url);
 
         SocketCommandClientRef ProvideWorker(const std::string &remnodename, double conn_tmout = -1);
 
         virtual double ProcessTimeout(double last_diff);
 
      public:
         SocketCommandChannel(const std::string &name, SocketServerAddon* connaddon, Command cmd);
         virtual ~SocketCommandChannel() {}
 
         virtual std::string RequiredThrdClass() const { return typeSocketThread; }
 
   };
 
 
}
 
#endif