Go4TaskHandler/TGo4TaskHandler.h

Go to the documentation of this file.

// $Id: TGo4TaskHandler.h 478 2009-10-29 12:26:09Z linev $
//-----------------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//         Experiment Data Processing at EE department, GSI
//-----------------------------------------------------------------------
// Copyright (C) 2000- GSI Helmholtzzentrum für 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=0);


    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;

    Bool_t fbMasterMode;

    Bool_t fbIsAborting;

    TGo4ThreadManager* fxThreadManager; 

    TGo4ThreadHandler* fxThreadHandler; 

    TGo4CommandInvoker* fxInvoker; 

    TGo4Queue* fxCommandQueue; 
    TGo4Queue* fxStatusQueue; 
    TGo4Queue* fxDataQueue; 

    TGo4Socket* fxCommandTransport; 
    TGo4Socket* fxStatusTransport;  
    TGo4Socket* fxDataTransport;  

    TString fxComName;

    TString fxStatName;

    TString fxDatName;

    TString fxHostName;

    UInt_t fuNegPort;

    Int_t fiComPort;

    Int_t fiStatPort;

    Int_t fiDatPort;

    Go4CommandMode_t fiRole;

    TGo4StatusRunnable* fxStatusRun; 

    TGo4DataRunnable* fxDataRun; 

    TGo4CommandRunnable* fxCommandRun; 

};

#endif //TGO4TASKHANDLER_H