GSI Object Oriented Online Offline (Go4)  GO4-6.2.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
TGo4AnalysisClientImp.cxx
Go to the documentation of this file.
1 // $Id: TGo4AnalysisClientImp.cxx 3515 2022-01-24 11:06:44Z linev $
2 //-----------------------------------------------------------------------
3 // The GSI Online Offline Object Oriented (Go4) Project
4 // Experiment Data Processing at EE department, GSI
5 //-----------------------------------------------------------------------
6 // Copyright (C) 2000- GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
7 // Planckstr. 1, 64291 Darmstadt, Germany
8 // Contact: http://go4.gsi.de
9 //-----------------------------------------------------------------------
10 // This software can be used under the license agreements as stated
11 // in Go4License.txt file which is part of the distribution.
12 //-----------------------------------------------------------------------
13 
14 #include "TGo4AnalysisClientImp.h"
15 
16 #include "TApplication.h"
17 #include "TROOT.h"
18 #include "TDatime.h"
19 #include "TDataType.h"
20 
21 #include "TGo4Log.h"
22 #include "TGo4LockGuard.h"
23 
24 #include "TGo4CommandInvoker.h"
26 #include "TGo4ComServerQuit.h"
27 #include "TGo4ThreadHandler.h"
28 #include "TGo4Task.h"
29 #include "TGo4TaskHandler.h"
32 #include "TGo4AnalysisSniffer.h"
33 #include "TGo4HistogramServer.h"
34 #include "TGo4AnalysisStatus.h"
35 #include "TGo4AnalysisImp.h"
36 #include "TGo4AnalysisStep.h"
37 
40 #include "TGo4Ratemeter.h"
41 
42 const char* TGo4AnalysisClient::fgcWATCHTHREAD="WATCH-";
43 const char* TGo4AnalysisClient::fgcMAINTHREAD="MAIN-";
44 const UInt_t TGo4AnalysisClient::fguSTATUSUPDATE = 1000; // events between two updates
45 const Double_t TGo4AnalysisClient::fgdSTATUSTIMEOUT = 2; // maximum seconds between two updates
46 const UInt_t TGo4AnalysisClient::fguCINTTIMERPERIOD = 200; // frequency of timer for cint lock
47 
48 
50  TGo4Analysis* analysis,
51  const char* host,
52  UInt_t negport,
53  Bool_t histoserver,
54  const char* basename,
55  const char* passwd,
56  Bool_t servermode,
57  Bool_t autorun,
58  Bool_t cintmode,
59  Bool_t loadprefs,
60  Bool_t showrate) :
61  TGo4Slave(name, servermode, host, negport),
62  fdBufferUpdateTime(0),
63  fxHistoServer(0),
64  fbAutoStart(autorun),
65  fbCintMode(kFALSE),
66  fbLoadPrefs(loadprefs),
67  fbShowRate(showrate)
68 {
69  GO4TRACE((15,"TGo4AnalysisClient::TGo4AnalysisClient(const char*,...)",__LINE__, __FILE__));
70 
71  if(analysis==0) {
72  TGo4Log::Debug("!!! AnalysisClient ''%s'': no external analysis specified !!",GetName());
74  } else {
75  fxAnalysis=analysis;
76  }
78 
79  Constructor(histoserver,basename,passwd);
80 
81  SetCintMode(cintmode);
82 }
83 
85  TGo4Analysis* analysis,
86  Bool_t histoserver,
87  const char* basename,
88  const char* passwd,
89  Bool_t servermode,
90  Bool_t autorun) :
91  TGo4Slave(argv[2], servermode, argv[3] , (argc>4) ? atoi(argv[4]) : 5000),
92  fdBufferUpdateTime(0),
93  fxHistoServer(0),
94  fbAutoStart(autorun),
95  fbCintMode(kFALSE),
96  fbLoadPrefs(kTRUE),
97  fbShowRate(kFALSE)
98 {
99  GO4TRACE((15,"TGo4AnalysisClient::TGo4AnalysisClient(int, char**...)",__LINE__, __FILE__));
100 
101  if(argc<5)
102  {
103  TGo4Log::Error("!!! AnalysisClient: missing commandline arguments, aborting !!");
104  gApplication->Terminate();
105  }
106  if(!strcmp("-lGUI",argv[1]))
107  {
108  TGo4Log::Error(" !!! AnalysisClient: GUI mode not specified, aborting !!");
109  gApplication->Terminate();
110  }
111 
112  if(analysis==0)
113  {
114  TGo4Log::Debug(" !!! AnalysisClient ''%s'': no external analysis specified !!",GetName());
116  }
117  else
118  {
119  fxAnalysis=analysis;
120  }
122  Constructor(histoserver,basename,passwd);
123 }
124 
125 void TGo4AnalysisClient::Constructor(Bool_t starthistserv, const char* basename, const char* passwd)
126 {
127  if (IsServer()) {
128  if (fxAnalysis->fServerObserverPass.Length()>0)
130  if (fxAnalysis->fServerCtrlPass.Length()>0)
132  if (fxAnalysis->fServerAdminPass.Length()>0)
134  }
135 
137  TGo4Log::Debug(" AnalysisClient ''%s'' started ",GetName());
138 
139  fcMainName = TString::Format("%s%s", fgcMAINTHREAD, GetName());
140  fcWatchName = TString::Format("%s%s", fgcWATCHTHREAD, GetName());
141 
142  TGo4AnalysisMainRunnable* mainrun =
143  new TGo4AnalysisMainRunnable(Form("MainRunnable of %s",GetName()), this);
144  TGo4AnalysisWatchRunnable* watchrun =
145  new TGo4AnalysisWatchRunnable(Form("WatchRunnable of %s",GetName()), this);
146 
147  // adding runnables to thread handler who takes over the responsibility...:
149  th->NewThread(fcMainName.Data(), mainrun);
150  th->NewThread(fcWatchName.Data(), watchrun);
151 
152  TGo4CommandInvoker::Instance(); // make sure we have an invoker instance!
154  TGo4CommandInvoker::Register("AnalysisClient",this); // register as command receiver at the global invoker
155  TGo4Slave::Stop();// prevent analysis to run before init
157  if(starthistserv) StartObjectServer(basename, passwd);
158  GetTask()->Launch();
159 }
160 
161 
163 {
164  GO4TRACE((15,"TGo4AnalysisClient::~TGo4AnalysisClient()",__LINE__, __FILE__));
165 // if(GetTask())
166 // {
167 // GetTask()->GetTaskHandler()->DisConnect(); // disconnect before we autosave etc.
168 // GetTask()->GetTaskHandler()->SetAborting(); // for superclass dtor: set fast abort mode
169 // }
170  fxAnalysis->LockAutoSave(); // wait until mainthread finishes the
171  { // final autosaving before we cancel
172  StopObjectServer(); // first cancel histoserver and its thread!
173  if(GetThreadHandler()) GetThreadHandler()->CancelAll(); // make sure threads wont work on application when its deleted
174  }
176 
177  delete fxRatemeter;
178  delete fxAnalysis;
180 }
181 
183 {
184  TGo4LockGuard mainguard; // threads are already up, protect next actions!
185  SendStatusMessage(1, kTRUE, TString::Format("AnalysisClient %s starting initialization...",GetName()));
186 
187  if(!fbAutoStart) { // normal mode: load last prefs and wait for submit
188 
189  // startup of analysis: get last saved status
190 
191  if (fbLoadPrefs) {
192  if(fxAnalysis->LoadStatus()) { // will load, close analysis and set the new status
193  // we have a status from file, i.e. go4 analysis: wait with init until gui command
194  SendStatusMessage(1,kTRUE, TString::Format("AnalysisClient %s: Status loaded from %s",
196  } else {
197  SendStatusMessage(2,kTRUE, TString::Format("AnalysisClient %s: Could not load status from %s",
199  }
200  }
201  // recover objects and dynamic list links from last autosave file:
202  if(!fxAnalysis->IsAutoSaveOn()){
203  SendStatusMessage(1,kTRUE, TString::Format("AnalysisClient %s: AUTOSAVE is DISABLED, Initialization did NOT load analysis objects!",
204  GetName()));
205  }
206  else if(fxAnalysis->LoadObjects()) {
207  SendStatusMessage(1,kTRUE, TString::Format("AnalysisClient %s: Objects loaded.",GetName()));
208  }
209  else {
210  //TGo4Log::Debug(" !!! Analysis Client Initialization -- Could not load dynamic list!!! ");
211  SendStatusMessage(2,kTRUE, TString::Format("AnalysisClient %s: Initialization could not load analysis objects!",GetName()));
212  }
213 
214  SendStatusMessage(1,kTRUE, TString::Format("Analysis Slave %s waiting for submit and start commands...",GetName()));
215  TGo4Slave::Stop(); // wait for command from master for start.
216  } else {
217  // in server mode, analysis slave will begin with analysis run
218  // before the master is connected. May not need master anyway!
219  // note: we do not recover preferences from file here anymore, all left to command line pars
220  SendStatusMessage(1,kTRUE, TString::Format("AnalysisSlave %s initializing analysis...",GetName()));
222  if(IsCintMode()) {
223  SendStatusMessage(1,kTRUE, TString::Format("Analysis CINTServer %s in MainCycle suspend mode.",GetName()));
224  TGo4Slave::Stop(); // no UserPostLoop
225  } else {
226  SendStatusMessage(1,kTRUE, TString::Format("AnalysisSlave %s starting analysis...",GetName()));
227  Start(); // UserPreLoop execution here!
228  }
229  } else {
230  SendStatusMessage(2,kTRUE, TString::Format("AnalysisSlave %s failed initializing analysis!",GetName()));
231  TGo4Slave::Stop();
232  }
233  } // if(!fbAutoStart)
234  SendAnalysisStatus(); // only send status if connections are up!
235  UpdateStatusBuffer(); // we need this for gui
236  //SendAnalysisClientStatus(); // JAM15 deadlock danger in analysis server mode!
237  SendStatusMessage(1,kFALSE, TString::Format("AnalysisClient %s has finished initialization.",GetName()));
238  return 0;
239 }
240 
241 
242 
244 {
245  GO4TRACE((12,"TGo4AnalysisClient::UpdateStatus(TGo4TaskStatus*)",__LINE__, __FILE__));
246  TGo4Slave::UpdateStatus(state); // fill superclass attributes
247  TGo4AnalysisClientStatus* anstate= dynamic_cast<TGo4AnalysisClientStatus*> (state);
248  if (anstate) {
250  // new: set true running state
251  anstate->SetRunning(fxAnalysis->IsRunning());
252  // new: set name of current eventsource
254  // <-note that stepname=0 will return the first active step
255  if(firststep) {
256  anstate->SetCurrentSource(firststep->GetEventSourceName());
258  } else {
259  anstate->SetCurrentSource("- No event source -");
260  fxRatemeter->SetCurrentSource("- No event source -");
261  }
262  }
263 }
264 
266 {
267  GO4TRACE((12,"TGo4AnalysisClient::CreateStatus()",__LINE__, __FILE__));
268  // note: ratemeter update done by mainthread loop
270  UpdateStatus(stat); // set the internals
271  return stat;
272 }
273 
275 {
276  GO4TRACE((12,"TGo4AnalysisClient::Start()",__LINE__, __FILE__));
277  if(fxAnalysis->IsInitDone())
278  {
279  if(GetThreadHandler()) GetThreadHandler()->Start(fcMainName.Data()); // this is useful anyway...
280  if(!MainIsRunning()) fxAnalysis->PreLoop(); // only call once
282  fxRatemeter->Reset();
283  fdBufferUpdateTime = TTimeStamp().AsDouble();
284  SendStatusMessage(1,kTRUE, TString::Format("AnalysisClient %s has started analysis processing.",GetName()));
285  UpdateRate(-2); // fake rate to display green light :)
287  //SendAnalysisClientStatus(); // JAM15 deadlock danger in analysis server mode! never do this from main thread
288  }
289  else
290  {
291  // user did not initialize analysis, we do not start!
292  SendStatusMessage(2,kTRUE, TString::Format("Analysis %s was not initialized! Please SUBMIT settings first.",fxAnalysis->GetName()));
293  }
294 }
295 
297 {
298  GO4TRACE((12,"TGo4AnalysisClient::SendAnalysisObject(char* name)",__LINE__, __FILE__));
299  TNamed* ob = fxAnalysis->GetObject(name);
300  SendObject(ob);
301 }
302 
304 {
305  GO4TRACE((12,"TGo4AnalysisClient::SendAnalysisStatus()",__LINE__, __FILE__));
306  TGo4Analysis* ana = GetAnalysis();
307  TGo4Log::Debug(" AnalysisClient - sending current analysis settings ");
308  if(ana) {
309  TGo4AnalysisStatus* state = ana->CreateStatus();
310  SendStatus(state);
311  delete state;
312  } else {
313  SendStatusMessage(3,kFALSE, "ERROR sending analysis status: no analysis ");
314  }
315 }
316 
317 
319 {
320  GO4TRACE((12,"TGo4AnalysisClient::SendAnalysisClientStatus()",__LINE__, __FILE__));
321 
322  TGo4Log::Debug(" AnalysisClient - sending current analysis client status ");
324  //TGo4Log::SetIgnoreLevel(0);
325 // TGo4Log::Debug("current rate:\t%f",fxRatemeter->GetRate());
326 // TGo4Log::Debug("average rate:\t%f",fxRatemeter->GetAvRate());
327 // TGo4Log::Debug("running time:\t%f",fxRatemeter->GetTime());
328 // TGo4Log::Debug("event number:\t%d",fxRatemeter->GetCurrentCount());
329 }
330 
332 {
333  GO4TRACE((12,"TGo4AnalysisClient::SendNamesList()",__LINE__, __FILE__));
334 
337  if(state)
338  {
339  TGo4Log::Debug(" AnalysisClient - sending names list ");
340  //SendStatus(state);
341  SendObject(state);
342  }
343  else
344  {
345  SendStatusMessage(3,kTRUE,"Analysis Client: Send Names List - ERROR: no nameslist !!! ");
346  }
347 }
348 
350 {
351  GO4TRACE((12,"TGo4AnalysisClient::KillMain()",__LINE__, __FILE__));
353  // put dummy buffer to command queue. This will wake up the main thread from command wait.
354  if(GetTask()) GetTask()->WakeCommandQueue(); // note that the dummy command will not have the termination id here!
356  SendStatusMessage(2,kTRUE,TString::Format("AnalysisClient %s has killed main analysis thread.",GetName()));
357 }
358 
360 {
361  GO4TRACE((12,"TGo4AnalysisClient::RestartMain()",__LINE__, __FILE__));
363  // put dummy buffer to command queue. This will wake up the main thread from command wait.
364  if(GetTask()) GetTask()->WakeCommandQueue(); // note that the dummy command will not have the termination id here!
365  if(GetThreadHandler()) {
367  GetThreadHandler()->Start(fcMainName.Data());
368  }
369  fxRatemeter->Reset();
370  SendStatusMessage(2,kTRUE,TString::Format("AnalysisClient %s has killed and relaunched main analysis thread.",GetName()));
371 }
372 
374 {
375  GO4TRACE((12,"TGo4AnalysisClient::Stop()",__LINE__, __FILE__));
376 
377  if(MainIsRunning()) fxAnalysis->PostLoop(); // only call postloop once
378  TGo4Slave::Stop(); // will stop for command queue wait
379  SendStatusMessage(1,kTRUE, TString::Format("AnalysisClient %s has STOPPED analysis processing.",GetName()));
380  if(GetTask()->IsTerminating()) return; // do not update status buffer from terminating state
382  UpdateRate(-1);
384 
385  //SendAnalysisClientStatus(); // JAM15 deadlock danger in analysis server mode! never do this from main thread
386 
387  //std::cout<<"AAAAAAAAAAAA TGo4AnalysisClient::Stop() after SendAnalysisClientStatus "<< std::endl;
388 // if (fxAnalysis && fxAnalysis->IsStopWorking()) {
389 // if (IsCintMode()) {
390 // fxAnalysis->ResumeWorking();
391 // }
393 // std::cout <<"TGo4AnalysisClient::Stop() before close analysis" << std::endl;
394 // TGo4Log::StartTracing(); // debug
395 // fxAnalysis->CloseAnalysis();
396 // std::cout <<"TGo4AnalysisClient::Stop() after close analysis" << std::endl;
397 // TGo4Log::CloseLogfile();
398 // exit(0);
399 // }
400 // }
401 }
402 
404 {
405  GO4TRACE((12,"TGo4AnalysisClient::UpdateRate(Int_t)",__LINE__, __FILE__));
406  if (fxRatemeter->Update(counts)) {
407 
409  fxRatemeter->SetRunning(an ? an->IsRunning() : kFALSE);
410 
411  TDatime dt;
412  fxRatemeter->SetDateTime(dt.AsSQLString());
413 
415  if (sniff) sniff->RatemeterUpdate(fxRatemeter);
416 
417  if (fbShowRate)
419  }
420 }
421 
423 {
424  return fxRatemeter->GetCurrentCount();
425 }
426 
428 {
429  return fxRatemeter->TestUpdate();
430 }
431 
433 {
434  Double_t currenttime = TTimeStamp().AsDouble();
435  Double_t deltatime = currenttime - fdBufferUpdateTime;
436  UInt_t currentcount = GetCurrentCount();
437  if( (currentcount && (currentcount % fguSTATUSUPDATE == 0) && (deltatime>0.1*fgdSTATUSTIMEOUT))
438  || (deltatime > fgdSTATUSTIMEOUT) ) {
439  // buffer shall be updated if certain number of events is processed or the time is up
440  fdBufferUpdateTime = currenttime;
441  return kTRUE;
442  }
443 
444  return kFALSE;
445 }
446 
447 
448 void TGo4AnalysisClient::StartObjectServer(const char* basename, const char* passwd)
449 {
450  StopObjectServer(); // shutdown existing one with old basename/passwd
451  fxHistoServer= new TGo4HistogramServer(this,basename,passwd,kFALSE);
452  // switch last boolean true if you want to use Go4 object server support
453  // default will only enable gsi histogram server JA 9/2005
454  //std::cout <<"--------StartObjectServer started histoserver" << std::endl;
455  //SendStatusMessage(1,kTRUE, TString::Format("AnalysisClient %s Started Object server.",GetName()));
456 }
457 
459 {
460  //std::cout <<"--------StopObjectServer entered." << std::endl;
461  if(fxHistoServer) {
462  delete fxHistoServer;
463  fxHistoServer=0;
464  //std::cout <<"---------old histoserver is deleted!!!" << std::endl;
465  //SendStatusMessage(1,kTRUE, TString::Format("AnalysisClient %s: Object server was stopped.",GetName()));
466  }
467 }
468 
470 {
471  //std::cout <<"--------TGo4AnalysisClient::Quit() closing analysis" << std::endl;
472  Stop();
474 }
475 
476 
477 
478 void TGo4AnalysisClient::Terminate(Bool_t termapp)
479 {
480  SetCintMode(kFALSE);
481  StopObjectServer(); // shutdown objectserver and its threads properly
482  if(GetTask())
483  GetTask()->TGo4ThreadManager::Terminate(termapp); // stops all remaining threads and sets termination flag
484 }
485 
487 {
488  StopObjectServer(); // shutdown objectserver and its threads properly
489  TGo4Log::Debug("TGo4AnalysisClient::TerminateFast with delete analysis");
490  if(GetThreadHandler()) {
491  GetThreadHandler()->StopAll(); // this will not stop immeadeately, therefor:
493  GetThreadHandler()->Cancel(fcMainName.Data()); // maybe we not need this...
494  GetThreadHandler()->Cancel(GetTask()->GetTaskHandler()->GetDatName());
495  GetThreadHandler()->Cancel(GetTask()->GetTaskHandler()->GetStatName());
496  }
497  delete fxAnalysis;
498  fxAnalysis = 0;
499  gApplication->Terminate();
500 }
501 
503 {
504  if(GetTask())
505  {
507  //TGo4Log::StartTracing(); // debug
508  GetTask()->SubmitLocalCommand(com); // shutdown will be performed in local command thread
509  }
510 
511 }
512 
513 
514 void TGo4AnalysisClient::ExecuteString(const char* command)
515 {
516  if(strstr(command,"ANHServStart")) {
517  TString buffer = command;
518  strtok((char*) buffer.Data(), ":"); // first find the command itself
519  TString base = strtok(0,":");
520  TString pass = strtok(0,":");
521  // std::cout << "ExecuteString found base " << base << ", passwd " << pass << std::endl;
522  StartObjectServer(base.Data(), pass.Data());
523  } else
524  if (!strcmp(command,"ANHServStop")) {
526  } else{
527  fxAnalysis->ExecuteLine(command); // all scripting is handled in analysis singleton
528  fflush(stdout);
529  }
530 
531 
532 
533 }
535 {
536  //std::cout <<"++++++++TGo4AnalysisClient::StartWorkThreads()" << std::endl;
538  if(GetThreadHandler()) {
539  GetThreadHandler()->Start(fcMainName.Data());
541  }
542  return 0;
543 }
544 
546 {
547  //std::cout <<"++++++++TGo4AnalysisClient::StopWorkThreads()" << std::endl;
549  if(GetThreadHandler()) {
550  GetThreadHandler()->Stop(fcMainName.Data());
551  GetThreadHandler()->Stop(fcWatchName.Data());
552  }
553  return 0;
554 }
555 
557 {
558  fbCintMode = on;
559 
560  if (fbCintMode) {
561  gROOT->SetBatch(kFALSE);
562  fxAnalysis->SetAutoSave(kFALSE);
563  }
564 }
565 
566 void TGo4AnalysisClient::SendStatusMessage(Int_t level, Bool_t printout, const TString& text)
567 {
568  TGo4Slave::SendStatusMessage(level, printout, text);
569 
571  if (sniff) sniff->StatusMessage(level, printout, text);
572 
573 }
Bool_t IsInitDone() const
TGo4HistogramServer * fxHistoServer
TGo4ThreadHandler * GetThreadHandler()
Definition: TGo4Slave.cxx:137
void SendStatusBuffer()
Definition: TGo4Slave.cxx:143
Bool_t TestUpdate()
virtual void StatusMessage(int level, Bool_t printout, const TString &)
Bool_t SubmitLocalCommand(TGo4Command *com)
Definition: TGo4Task.cxx:529
Double_t GetTime() const
Definition: TGo4Ratemeter.h:52
Bool_t LoadStatus(const char *filename=0)
void SetDateTime(const char *str)
Definition: TGo4Ratemeter.h:70
virtual void SendStatusMessage(Int_t level, Bool_t printout, const TString &text)
Bool_t IsAutoSaveOn() const
void WakeCommandQueue(Int_t id=0)
Definition: TGo4Task.cxx:543
virtual void UpdateStatus(TGo4TaskStatus *state)
Definition: TGo4Slave.cxx:108
static void SetCommandList(TGo4CommandProtoList *list)
static void UnRegister(TGo4CommandReceiver *p)
virtual void CloseAnalysis()
TGo4AnalysisSniffer * GetSniffer() const
static void SetObservAccount(const char *name, const char *passwd)
void SetCurrentSource(const char *str)
Definition: TGo4Ratemeter.h:71
Bool_t LoadObjects(const char *filename=0)
virtual Int_t Initialization()
void Constructor(Bool_t starthistserv=kFALSE, const char *basename="Go4", const char *passwd="abcd")
Bool_t MainIsRunning()
Definition: TGo4Slave.h:92
void SetCintMode(Bool_t on=kTRUE)
TString fServerCtrlPass
static const char * fgcDEFAULTSTATUSFILENAME
Double_t GetAvRate() const
Definition: TGo4Ratemeter.h:56
void SetRates(Double_t rate, Double_t average, ULong64_t counts, Double_t time)
static void SetCtrlAccount(const char *name, const char *passwd)
TString fServerAdminPass
Bool_t ReCreate(const char *thname)
static void Register(const char *name, TGo4CommandReceiver *p)
virtual void RatemeterUpdate(TGo4Ratemeter *)
Bool_t NewThread(const char *name, TGo4Runnable *runnable)
void SetRunning(Bool_t on=kTRUE)
Definition: TGo4Ratemeter.h:69
virtual Int_t StartWorkThreads()
virtual Int_t StopWorkThreads()
virtual void Start()
Definition: TGo4Slave.cxx:66
virtual void Terminate(Bool_t termapp=kTRUE)
virtual void Stop()
Definition: TGo4Slave.cxx:73
TGo4AnalysisStep * GetAnalysisStep(const char *name)
Bool_t IsServer()
Definition: TGo4TaskOwner.h:39
static const Double_t fgdSTATUSTIMEOUT
static const char * fgcMAINTHREAD
void SendAnalysisObject(const char *name)
void SetAutoSave(Bool_t on=kTRUE)
TString fServerObserverPass
static TGo4CommandInvoker * Instance()
TGo4Task * GetTask()
Definition: TGo4TaskOwner.h:41
Double_t GetRate() const
Definition: TGo4Ratemeter.h:50
void SetCurrentSource(const char *name)
TGo4Analysis * GetAnalysis() const
void SendObject(TObject *obj, const char *receiver=0)
Definition: TGo4Slave.cxx:119
static const char * fgcWATCHTHREAD
Bool_t Stop(const char *thname)
virtual TGo4TaskStatus * CreateStatus()
const char * GetName() const
Bool_t Start(const char *thname)
virtual Int_t StopWorkThreads()
Bool_t Cancel(const char *thname)
virtual const char * GetName() const
virtual void SendStatusMessage(Int_t level, Bool_t printout, const TString &text)
Definition: TGo4Slave.cxx:149
Bool_t IsCintMode() const
Bool_t Update(Int_t increment=1)
virtual Bool_t InitEventClasses()
static void PrintRate(ULong64_t cnt, double rate)
Definition: TGo4Log.cxx:273
void SetAnalysisClient(TGo4AnalysisClient *cli)
#define GO4TRACE(X)
Definition: TGo4Log.h:26
Long_t ExecuteLine(const char *command, Int_t *errcode=0)
TGo4AnalysisObjectNames * GetNamesList() const
void SendStatus(TGo4Status *stat, const char *receiver=0)
Definition: TGo4Slave.cxx:125
ULong64_t GetCurrentCount() const
Definition: TGo4Ratemeter.h:54
TGo4Ratemeter * fxRatemeter
void UpdateStatusBuffer()
Definition: TGo4Slave.cxx:156
static void SetAdminAccount(const char *name, const char *passwd)
static const UInt_t fguCINTTIMERPERIOD
TNamed * GetObject(const char *name, const char *folder=0)
TGo4AnalysisStatus * CreateStatus()
void UpdateRate(Int_t counts=1)
void UpdateStatus(TGo4TaskStatus *state)
virtual void ExecuteString(const char *command)
static const UInt_t fguSTATUSUPDATE
static TGo4Analysis * Instance()
const char * GetEventSourceName()
static void Error(const char *text,...)
Definition: TGo4Log.cxx:323
virtual Int_t StartWorkThreads()
static void Debug(const char *text,...)
Definition: TGo4Log.cxx:284
void StartObjectServer(const char *basename, const char *passwd)