TGo4TaskHandler.h

Go to the documentation of this file.

// $Id$
//-----------------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//         Experiment Data Processing at EE department, GSI
//-----------------------------------------------------------------------
// Copyright (C) 2000- GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
//                     Planckstr. 1, 64291 Darmstadt, Germany
// Contact:            http://go4.gsi.de
//-----------------------------------------------------------------------
// This software can be used under the license agreements as stated
// in Go4License.txt file which is part of the distribution.
//-----------------------------------------------------------------------
 
#ifndef TGO4TASKHANDLER_H
#define TGO4TASKHANDLER_H
 
#include "TNamed.h"
#include "TGo4Command.h"
 
class TGo4ThreadManager;
class TGo4ThreadHandler;
class TGo4Socket;
class TGo4Queue;
class TGo4CommandInvoker;
class TGo4TaskHandlerStatus;
class TGo4DataRunnable;
class TGo4StatusRunnable;
class TGo4CommandRunnable;
 

class TGo4TaskHandler : public TNamed {
 
  public:
 
    friend class TGo4TaskManager;
 
    TGo4TaskHandler(const char *name, TGo4ThreadManager *threadmanager, Bool_t clientmode = kFALSE, Bool_t mastermode = kTRUE, UInt_t negotiationport = 0);
 
    virtual ~TGo4TaskHandler();

    Bool_t ConnectServerChannel(const char *name, TGo4Socket *negotiator, TGo4Socket *channel, const char *host);

    Bool_t ConnectClientChannel(const char *name, TGo4Socket *negotiator, TGo4Socket *channel, const char *host);

    TGo4Socket *ServerRequest(const char *host = "localhost");

    Bool_t ServerLogin(TGo4Socket *connector, Go4CommandMode_t account);

    Bool_t Connect(const char *host="localhost", TGo4Socket *negotiator = nullptr);

    Bool_t DisConnect(Bool_t waitforclient = kTRUE);
 
    TGo4ThreadManager *GetThreadManager() const { return fxThreadManager; }

    Int_t WaitGetPort(TGo4Socket *sock);

    void SetNegotiationPort(UInt_t port){ fuNegPort=port;}
 
    TGo4Socket *GetCommandTransport() const { return fxCommandTransport; }
 
    TGo4Socket *GetStatusTransport() const { return fxStatusTransport; }
 
    TGo4Socket *GetDataTransport() const { return fxDataTransport; }
 
    TGo4Queue *GetCommandQueue() const { return fxCommandQueue; }
 
    TGo4Queue *GetStatusQueue() const { return fxStatusQueue; }
 
    TGo4Queue *GetDataQueue() const { return fxDataQueue; }
 
    const char *GetHostName() const { return fxHostName.Data(); }
 
    const char *GetComName() const { return fxComName.Data(); }
 
    const char *GetDatName() const { return fxDatName.Data(); }
 
    const char *GetStatName() const { return fxStatName.Data(); }
 
    Int_t GetComPort() const { return fiComPort; }
 
    Int_t GetDatPort() const { return fiDatPort; }
 
    Int_t GetStatPort() const { return fiStatPort; }
 
    Go4CommandMode_t GetRole(){return fiRole;}
    void SetRole(Go4CommandMode_t role){fiRole=role;}

    TGo4CommandInvoker* GetInvoker() const { return fxInvoker; }

    Bool_t IsClientMode() const { return fbClientMode; }

    Bool_t IsMasterMode() const { return fbMasterMode; }

    void SetAborting(Bool_t isaborting=kTRUE) { fbIsAborting=isaborting; }

    Bool_t IsAborting() const { return fbIsAborting; }

    void SetInvoker(TGo4CommandInvoker* inv) { fxInvoker=inv; }

    virtual TGo4TaskHandlerStatus * CreateStatus();

    Bool_t StopTransportThreads(Bool_t wait=kTRUE);

    void StartTransportThreads();

    Bool_t WaitThreadStop(const char *name);

    void CloseChannels(Option_t *opt = "");

    void ClearQueues();
 

    static void SetAdminAccount(const char *name, const char *passwd);

    static void SetCtrlAccount(const char *name, const char *passwd);

    static void SetObservAccount(const char *name, const char *passwd);
 
    static const char *Get_fgcOK();
 
    static const char *Get_fgcERROR();
 
    static UInt_t Get_fguPORTWAITTIME();
 
    static Int_t Get_fgiPORTWAITCYCLES();
 
  protected:

    static const UInt_t fguCONNECTORPORT;        

    static const Int_t fgiTHREADSTOPCYCLES;

    static const UInt_t fguTHREADSTOPTIME;

    static const UInt_t fguTRANSPORTCHECKDELAY;  

    static const UInt_t  fguSTATUSQUEUESIZE;      

    static const UInt_t fguDATAQUEUESIZE;         

    static const UInt_t fguCOMMANDQUEUESIZE;      

    static const char *fgcCONNECT;            

    static const char *fgcDISCONNECT;         

   static const char *fgcMASTER;              

   static const char *fgcSLAVE;              

   static const char *fgcCOMMANDTHREAD;       

   static const char *fgcSTATUSTHREAD;        

   static const char *fgcDATATHREAD;          
 
 
  private:
    TGo4TaskHandler();

    static TNamed fgxADMINISTRATORACCOUNT;

    static TNamed fgxOBSERVERACCOUNT;

    static TNamed fgxCONTROLLERACCOUNT;

    static const char *fgcERROR;              

    static const char *fgcOK;                 

    static const UInt_t fguPORTWAITTIME;         

    static const Int_t fgiPORTWAITCYCLES;        

    Bool_t fbClientMode{kFALSE};

    Bool_t fbMasterMode{kFALSE};

    Bool_t fbIsAborting{kFALSE};

    TGo4ThreadManager *fxThreadManager{nullptr}; 

    TGo4ThreadHandler  *fxThreadHandler{nullptr}; 

    TGo4CommandInvoker  *fxInvoker{nullptr}; 

    TGo4Queue  *fxCommandQueue{nullptr}; 
    TGo4Queue  *fxStatusQueue{nullptr}; 
    TGo4Queue  *fxDataQueue{nullptr}; 

    TGo4Socket  *fxCommandTransport{nullptr}; 
    TGo4Socket  *fxStatusTransport{nullptr};  
    TGo4Socket  *fxDataTransport{nullptr};  

    TString fxComName;

    TString fxStatName;

    TString fxDatName;

    TString fxHostName;

    UInt_t fuNegPort{0};

    Int_t fiComPort{0};

    Int_t fiStatPort{0};

    Int_t fiDatPort{0};

    Go4CommandMode_t fiRole;

    TGo4StatusRunnable  *fxStatusRun{nullptr}; 

    TGo4DataRunnable  *fxDataRun{nullptr}; 

    TGo4CommandRunnable  *fxCommandRun{nullptr}; 
 
};
 
#endif //TGO4TASKHANDLER_H