GSI Object Oriented Online Offline (Go4) GO4-6.4.0
Loading...
Searching...
No Matches
TGo4AnalysisWebStatus.cxx
Go to the documentation of this file.
1// $Id$
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 "TGo4AnalysisWebStatus.h"
15
16#include "TUrl.h"
17
18#include "TGo4AnalysisStepStatus.h"
19
20#include "TGo4Analysis.h"
21#include "TGo4AnalysisClient.h"
22
23TString TGo4AnalysisWebStatus::fgxURL_STARTRUN = "start";
24TString TGo4AnalysisWebStatus::fgxURL_CLOSE = "close";
25
26TString TGo4AnalysisWebStatus::fgxURL_ENABLESTEP = "stepenabled";
27TString TGo4AnalysisWebStatus::fgxURL_ENABLESOURCE = "sourceenabled";
28TString TGo4AnalysisWebStatus::fgxURL_ENABLESTORE = "storeenabled";
29
30TString TGo4AnalysisWebStatus::fgxURL_SOURCE_TYPE = "sourcesel";
31TString TGo4AnalysisWebStatus::fgxURL_SOURCE_NAME = "sourcename";
32TString TGo4AnalysisWebStatus::fgxURL_SOURCE_TAG = "sourcetag";
33TString TGo4AnalysisWebStatus::fgxURL_SOURCE_PORT = "sourceport";
34TString TGo4AnalysisWebStatus::fgxURL_SOURCE_TIMEOUT = "sourcetmout";
35TString TGo4AnalysisWebStatus::fgxURL_SOURCE_RETRY = "sourceretry";
36TString TGo4AnalysisWebStatus::fgxURL_SOURCE_FIRST = "sourcefirst";
37TString TGo4AnalysisWebStatus::fgxURL_SOURCE_LAST = "sourcelast";
38TString TGo4AnalysisWebStatus::fgxURL_SOURCE_SKIP = "sourceskip";
39TString TGo4AnalysisWebStatus::fgxURL_STORE_TYPE = "storesel";
40TString TGo4AnalysisWebStatus::fgxURL_STORE_NAME = "storename";
41TString TGo4AnalysisWebStatus::fgxURL_STORE_SPLIT = "storesplit";
42TString TGo4AnalysisWebStatus::fgxURL_STORE_BUF = "storebuf";
43TString TGo4AnalysisWebStatus::fgxURL_STORE_COMP = "storecomp";
44TString TGo4AnalysisWebStatus::fgxURL_STORE_ASF = "storeasf";
45TString TGo4AnalysisWebStatus::fgxURL_STORE_OVERWRITE = "storeover";
46
47TString TGo4AnalysisWebStatus::fgxURL_ASF_SAVE = "saveasf";
48TString TGo4AnalysisWebStatus::fgxURL_ASF_ENABLED = "asfenabled";
49TString TGo4AnalysisWebStatus::fgxURL_ASF_NAME = "asfname";
50TString TGo4AnalysisWebStatus::fgxURL_ASF_INTERVAL = "asftime";
51TString TGo4AnalysisWebStatus::fgxURL_ASF_COMP = "asfcomp";
52TString TGo4AnalysisWebStatus::fgxURL_ASF_OVERWRITE = "asfoverwrite";
53
54TString TGo4AnalysisWebStatus::fgxURL_PREFS_NAME = "anaprefsname";
55TString TGo4AnalysisWebStatus::fgxURL_PREFS_LOAD = "loadprefs";
56TString TGo4AnalysisWebStatus::fgxURL_PREFS_SAVE = "saveprefs";
57
58
59Bool_t TGo4AnalysisWebStatus::UpdateFromUrl(const char *rest_url_opt)
60{
61 std::cout << "\nTGo4AnalysisWebStatus Update From Url with " << rest_url_opt << std::endl;
62// TGo4LockGuard gard; // test: can we avoid deadlock with monitoring sniffer here?
63// std::cout << "\nTGo4AnalysisWebStatus AFTER lockguard." << std::endl;
64 TString message;
65 message.Form("TGo4AnalysisWebStatus::UpdateFromUrl ");
66 TGo4Analysis *ana = TGo4Analysis::Instance();
67 TUrl url;
68 url.SetOptions(rest_url_opt); // this time try to use ROOT default class
69 TString theKey;
70
71 //handle first pseudo commands that should not initialize analysis:
72
73 // close analysis:
74 theKey = TGo4AnalysisWebStatus::fgxURL_CLOSE;
75 if (url.HasOption(theKey.Data()))
76 {
77 ana->StopAnalysis();
78 ana->CloseAnalysis();
79 message.Append(TString::Format(", CLOSING analysis"));
80 TGo4Log::Message(1, "%s", message.Data());
81 return kTRUE;
82 }
83
84 // save asf:
85 theKey = TGo4AnalysisWebStatus::fgxURL_ASF_SAVE;
86 if (url.HasOption(theKey.Data()))
87 {
88 const char *filename = url.GetValueFromOptions(theKey.Data());
89 WriteAutoSave(filename, fbAutoSaveOverwrite, fiAutoSaveCompression);
90 message.Append(TString::Format(", saving autosave file %s", filename));
91 TGo4Log::Message(1, "%s", message.Data());
92 return kTRUE;
93 }
94
95 // save setup:
96 theKey = TGo4AnalysisWebStatus::fgxURL_PREFS_SAVE;
97 if (url.HasOption(theKey.Data())) {
98 const char *filename = url.GetValueFromOptions(theKey.Data());
99 SaveStatus(filename);
100 message.Append(TString::Format(", saving configuration file %s", filename));
101 TGo4Log::Message(1, "%s", message.Data());
102 return kTRUE;
103 }
104
105 // load setup and initialize:
106 theKey = TGo4AnalysisWebStatus::fgxURL_PREFS_LOAD;
107 if (url.HasOption(theKey.Data())) {
108 const char *filename = url.GetValueFromOptions(theKey.Data());
109 ana->StopAnalysis();
110 if (LoadStatus(filename)) {
111 ana->InitEventClasses();
112 message.Append(TString::Format(", loaded configuration file %s", filename));
113 } else {
114 message.Append(TString::Format(", /!\\ FAILED to load configuration file %s !!!", filename));
115 }
116 TGo4Log::Message(1, "%s", message.Data());
117 return kTRUE;
118 }
119
120 // first stepwise options here:
121
122 ResetStepIterator();
123 Int_t stepindex = 0;
124 while (auto step = NextStepStatus()) {
125 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_ENABLESTEP.Data(), stepindex);
126 if (url.HasOption(theKey.Data())) {
127 Bool_t enablestep = TString(url.GetValueFromOptions(theKey.Data())) == "true";
128 message.Append(TString::Format(", %s=%d", theKey.Data(), enablestep));
129 step->SetProcessEnabled(enablestep);
130 }
131 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_ENABLESOURCE.Data(), stepindex);
132 if (url.HasOption(theKey.Data())) {
133 Bool_t enablesource = TString(url.GetValueFromOptions(theKey.Data())) == "true";
134 message.Append(TString::Format(", %s=%d", theKey.Data(), enablesource));
135 step->SetSourceEnabled(enablesource);
136 }
137 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_ENABLESTORE.Data(), stepindex);
138 if (url.HasOption(theKey.Data())) {
139 Bool_t enablestore = TString(url.GetValueFromOptions(theKey.Data())) == "true";
140 message.Append(TString::Format(", %s=%d", theKey.Data(), enablestore));
141 step->SetStoreEnabled(enablestore);
142 }
143
144 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_SOURCE_TYPE.Data(), stepindex);
145 if (url.HasOption(theKey.Data())) {
146 Int_t srctype = url.GetIntValueFromOptions(theKey.Data());
147 message.Append(TString::Format(", %s=%d", theKey.Data(), srctype));
148
149 // extract values of old source parameter and save them into the new if matching:
150 TGo4EventSourceParameter *oldsrcpar = step->GetSourcePar();
151 TGo4MbsSourceParameter* oldmbspar = dynamic_cast<TGo4MbsSourceParameter*>(oldsrcpar);
152 TGo4UserSourceParameter* olduserpar = dynamic_cast<TGo4UserSourceParameter*>(oldsrcpar);
153 TString srcname = oldsrcpar->GetName();
154 Int_t port = oldmbspar ? oldmbspar->GetPort() : 0;
155 if (port == 0)
156 port = olduserpar ? olduserpar->GetPort() : 0;
157 // JAM: the above shows that event source hierarchy interface is still not optimized
158 // however, currently (March 2015) no manpower to improve or redesign Go4 if it is working...
159
160 TGo4EventSourceParameter *newpar = nullptr;
161 switch (srctype)
162 {
163 case GO4EV_FILE:
164 newpar = new TGo4FileSourceParameter(srcname);
165 break;
166
167 case GO4EV_MBS_FILE:
168 newpar = new TGo4MbsFileParameter(srcname);
169 break;
170
171 case GO4EV_MBS_STREAM:
172 newpar = new TGo4MbsStreamParameter(srcname);
173 break;
174
175 case GO4EV_MBS_TRANSPORT:
176 newpar = new TGo4MbsTransportParameter(srcname);
177 break;
178
179 case GO4EV_MBS_EVENTSERVER:
180 newpar = new TGo4MbsEventServerParameter(srcname);
181 break;
182
183 case GO4EV_MBS_REVSERV:
184 newpar = new TGo4RevServParameter(srcname);
185 break;
186
187 case GO4EV_MBS_RANDOM:
188 newpar = new TGo4MbsRandomParameter("random");
189 break;
190
191 case GO4EV_USER:
192 newpar = new TGo4UserSourceParameter(srcname, "", port);
193 break;
194 };
195
196 TGo4MbsSourceParameter* newmbspar = dynamic_cast<TGo4MbsSourceParameter*>(newpar);
197 if (newmbspar)
198 {
199 newmbspar->SetPort(port);
200 if (oldmbspar)
201 {
202 newmbspar->SetStartEvent(oldmbspar->GetStartEvent());
203 newmbspar->SetStopEvent(oldmbspar->GetStopEvent());
204 newmbspar->SetEventInterval(oldmbspar->GetEventInterval());
205 }
206 }
207 newpar->SetTimeout(oldsrcpar->GetTimeout());
208
209 step->SetSourcePar(newpar);
210 delete newpar; // SetSourcePar does clone argument, we do not need it further
211 } // fgxURL_SOURCE_TYPE
212
213 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_SOURCE_NAME.Data(), stepindex);
214 if (url.HasOption(theKey.Data())) {
215 TString srcname = url.GetValueFromOptions(theKey.Data());
216 message.Append(TString::Format(", %s=%s", theKey.Data(), srcname.Data()));
217 TGo4EventSourceParameter *srcpar = step->GetSourcePar();
218 srcpar->SetName(srcname.Data());
219 } // fgxURL_SOURCE_NAME;
220
221 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_SOURCE_TAG.Data(), stepindex);
222 if (url.HasOption(theKey.Data())) {
223 TString tagname = url.GetValueFromOptions(theKey.Data());
224 message.Append(TString::Format(", %s=%s", theKey.Data(), tagname.Data()));
225 TGo4EventSourceParameter *srcpar = step->GetSourcePar();
226 TGo4MbsFileParameter* mbsfilepar = dynamic_cast<TGo4MbsFileParameter*>(srcpar);
227 if (mbsfilepar)
228 mbsfilepar->SetTagName(tagname.Data());
229 else
230 message.Append(TString::Format(" - /!\\ NEVER COME HERE: Could not set tag name to type %s ", srcpar->ClassName()));
231 } // fgxURL_SOURCE_TAG;
232
233 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_SOURCE_PORT.Data(), stepindex);
234 if (url.HasOption(theKey.Data())) {
235 Int_t port = url.GetIntValueFromOptions(theKey.Data());
236 message.Append(TString::Format(", %s=%d", theKey.Data(), port));
237 TGo4EventSourceParameter *srcpar = step->GetSourcePar();
238 TGo4MbsSourceParameter* mbspar = dynamic_cast<TGo4MbsSourceParameter*>(srcpar);
239 TGo4UserSourceParameter* userpar = dynamic_cast<TGo4UserSourceParameter*>(srcpar);
240 if (mbspar)
241 mbspar->SetPort(port);
242 else if (userpar)
243 userpar->SetPort(port);
244 else
245 message.Append(TString::Format(" - /!\\ NEVER COME HERE: Could not set port to type %s ", srcpar->ClassName()));
246 } //fgxURL_SOURCE_PORT;
247
248 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_SOURCE_TIMEOUT.Data(), stepindex);
249 if (url.HasOption(theKey.Data())) {
250 Int_t timeout = url.GetIntValueFromOptions(theKey.Data());
251 message.Append(TString::Format(", %s=%d", theKey.Data(), timeout));
252 TGo4EventSourceParameter *srcpar = step->GetSourcePar();
253 srcpar->SetTimeout(timeout);
254 } //fgxURL_SOURCE_TIMEOUT;
255
256 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_SOURCE_RETRY.Data(), stepindex);
257 if (url.HasOption(theKey.Data())) {
258 Int_t retry = url.GetIntValueFromOptions(theKey.Data());
259 message.Append(TString::Format(", %s=%d", theKey.Data(), retry));
260 TGo4EventSourceParameter *srcpar = step->GetSourcePar();
261 TGo4MbsSourceParameter* mbspar = dynamic_cast<TGo4MbsSourceParameter*>(srcpar);
262 if (mbspar)
263 mbspar->SetRetryCnt(retry);
264 else
265 message.Append(
266 TString::Format(" - /!\\ NEVER COME HERE: Could not set retry count to type %s ",
267 srcpar->ClassName()));
268 } //fgxURL_SOURCE_RETRY;
269
270 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_SOURCE_FIRST.Data(), stepindex);
271 if (url.HasOption(theKey.Data())) {
272 Int_t startevent = url.GetIntValueFromOptions(theKey.Data());
273 message.Append(TString::Format(", %s=%d", theKey.Data(), startevent));
274 TGo4EventSourceParameter *srcpar = step->GetSourcePar();
275 TGo4MbsSourceParameter* mbspar = dynamic_cast<TGo4MbsSourceParameter*>(srcpar);
276 if (mbspar)
277 mbspar->SetStartEvent(startevent);
278 else
279 message.Append(
280 TString::Format(" - /!\\ NEVER COME HERE: Could not set start event to type %s ",
281 srcpar->ClassName()));
282 } //fgxURL_SOURCE_FIRST;
283
284 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_SOURCE_LAST.Data(), stepindex);
285 if (url.HasOption(theKey.Data()))
286 {
287 Int_t stopevent = url.GetIntValueFromOptions(theKey.Data());
288 message.Append(TString::Format(", %s=%d", theKey.Data(), stopevent));
289 TGo4EventSourceParameter *srcpar = step->GetSourcePar();
290 TGo4MbsSourceParameter* mbspar = dynamic_cast<TGo4MbsSourceParameter*>(srcpar);
291 if (mbspar)
292 mbspar->SetStopEvent(stopevent);
293 else
294 message.Append(
295 TString::Format(" - /!\\ NEVER COME HERE: Could not set stop event to type %s ",
296 srcpar->ClassName()));
297 } //fgxURL_SOURCE_LAST;
298
299 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_SOURCE_SKIP.Data(), stepindex);
300 if (url.HasOption(theKey.Data()))
301 {
302 Int_t skipevents = url.GetIntValueFromOptions(theKey.Data());
303 message.Append(TString::Format(", %s=%d", theKey.Data(), skipevents));
304 TGo4EventSourceParameter *srcpar = step->GetSourcePar();
305 TGo4MbsSourceParameter* mbspar = dynamic_cast<TGo4MbsSourceParameter*>(srcpar);
306 if (mbspar)
307 mbspar->SetEventInterval(skipevents);
308 else
309 message.Append(
310 TString::Format(" - /!\\ NEVER COME HERE: Could not set event interval to type %s ",
311 srcpar->ClassName()));
312 } //fgxURL_SOURCE_SKIP;
313
314 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_STORE_TYPE.Data(), stepindex);
315 if (url.HasOption(theKey.Data()))
316 {
317 Int_t storetype = url.GetIntValueFromOptions(theKey.Data());
318 message.Append(TString::Format(", %s=%d", theKey.Data(), storetype));
319
320 // extract values of old store parameter and save them into the new if matching:
321 TGo4EventStoreParameter *oldstorepar = step->GetStorePar();
322 TString storename = oldstorepar->GetName();
323 TGo4FileStoreParameter* oldfilepar = dynamic_cast<TGo4FileStoreParameter*>(oldstorepar);
324 TGo4BackStoreParameter* oldbackpar = dynamic_cast<TGo4BackStoreParameter*>(oldstorepar);
325
326 // JAM NOTE: what is missing here completely is support of user defined storages!
327 // this does not exist in Qt GUI either, because nobody has ever used this feature... ;-(
328 // shall we provide this in the future?
329
330 Int_t oldsplit = -1, oldbuf = -1, oldcomp = -1, oldauto = -1, oldover = -1;
331 if (oldfilepar)
332 {
333 oldsplit = oldfilepar->GetSplitlevel();
334 oldbuf = oldfilepar->GetBufsize();
335 oldcomp = oldfilepar->GetCompression();
336 oldauto = oldfilepar->GetAutosaveSize();
337 oldover = oldfilepar->IsOverwriteMode();
338 }
339 else if (oldbackpar)
340 {
341 oldsplit = oldbackpar->GetSplitlevel();
342 oldbuf = oldbackpar->GetBufsize();
343 }
344 else
345 {
346 message.Append(
347 TString::Format(" - /!\\ NEVER COME HERE: old event store parameter is type %s ",
348 oldstorepar ? oldstorepar->ClassName() : "nullpointer"));
349 }
350
351 TGo4EventStoreParameter *newpar = nullptr;
352 switch (storetype) {
353 default:
354 case GO4EV_FILE:
355 {
356 auto filestore = new TGo4FileStoreParameter(storename);
357 if (oldsplit >= 0)
358 filestore->SetSplitlevel(oldsplit); // restore my soul...
359 if (oldbuf >= 0)
360 filestore->SetBufsize(oldbuf);
361 if (oldcomp >= 0)
362 filestore->SetCompression(oldcomp);
363 if (oldauto >= 0)
364 filestore->SetAutosaveSize(oldauto);
365 if (oldover >= 0)
366 filestore->SetOverwriteMode(oldover);
367 newpar = filestore;
368 }
369 break;
370 case GO4EV_BACK:
371 {
372 auto bckstore = new TGo4BackStoreParameter(storename);
373 if (oldsplit >= 0)
374 bckstore->SetSplitlevel(oldsplit);
375 if (oldbuf >= 0)
376 bckstore->SetBufsize(oldbuf);
377 newpar = bckstore;
378 }
379 break;
380 };
381 step->SetStorePar(newpar);
382 delete newpar; // SetStorePar does clone argument, we do not need it further
383
384 } //fgxURL_STORE_TYPE;
385
386 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_STORE_NAME.Data(), stepindex);
387 if (url.HasOption(theKey.Data()))
388 {
389 TString storename = url.GetValueFromOptions(theKey.Data());
390 message.Append(TString::Format(", %s=%s", theKey.Data(), storename.Data()));
391 TGo4EventStoreParameter *storepar = step->GetStorePar();
392 storepar->SetName(storename.Data());
393 } // fgxURL_STORE_NAME
394
395 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_STORE_SPLIT.Data(), stepindex);
396 if (url.HasOption(theKey.Data())) {
397 Int_t split = url.GetIntValueFromOptions(theKey.Data());
398 message.Append(TString::Format(", %s=%d", theKey.Data(), split));
399 TGo4EventStoreParameter *storepar = step->GetStorePar();
400 TGo4FileStoreParameter *filepar = dynamic_cast<TGo4FileStoreParameter *>(storepar);
401 TGo4BackStoreParameter *backpar = dynamic_cast<TGo4BackStoreParameter *>(storepar);
402 if (filepar)
403 filepar->SetSplitlevel(split);
404 else if (backpar)
405 backpar->SetSplitlevel(split);
406 else
407 message.Append(TString::Format(" - /!\\ NEVER COME HERE: can not set split level to eventstore type %s ",
408 storepar ? storepar->ClassName() : "nullpointer"));
409
410 } // ffgxURL_STORE_SPLIT
411
412 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_STORE_BUF.Data(), stepindex);
413 if (url.HasOption(theKey.Data()))
414 {
415 Int_t bufsize = url.GetIntValueFromOptions(theKey.Data());
416 message.Append(TString::Format(", %s=%d", theKey.Data(), bufsize));
417 TGo4EventStoreParameter *storepar = step->GetStorePar();
418 TGo4FileStoreParameter* filepar = dynamic_cast<TGo4FileStoreParameter*>(storepar);
419 TGo4BackStoreParameter* backpar = dynamic_cast<TGo4BackStoreParameter*>(storepar);
420 if (filepar)
421 filepar->SetBufsize(bufsize);
422 else if (backpar)
423 backpar->SetBufsize(bufsize);
424 else
425 message.Append(
426 TString::Format(" - /!\\ NEVER COME HERE: can not set bufsize to eventstore type %s ",
427 storepar ? storepar->ClassName() : "nullpointer"));
428 } //fgxURL_STORE_BUF
429
430 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_STORE_COMP.Data(), stepindex);
431 if (url.HasOption(theKey.Data()))
432 {
433 Int_t bufsize = url.GetIntValueFromOptions(theKey.Data());
434 message.Append(TString::Format(", %s=%d", theKey.Data(), bufsize));
435 TGo4EventStoreParameter *storepar = step->GetStorePar();
436 TGo4FileStoreParameter* filepar = dynamic_cast<TGo4FileStoreParameter*>(storepar);
437 if (filepar)
438 filepar->SetBufsize(bufsize);
439 else
440 message.Append(
441 TString::Format(" - /!\\ NEVER COME HERE: can not set compression to eventstore type %s ",
442 storepar ? storepar->ClassName() : "nullpointer"));
443 } //fgxURL_STORE_COMP
444
445 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_STORE_ASF.Data(), stepindex);
446 if (url.HasOption(theKey.Data()))
447 {
448 Int_t treeautosave = url.GetIntValueFromOptions(theKey.Data());
449 message.Append(TString::Format(", %s=%d", theKey.Data(), treeautosave));
450 TGo4EventStoreParameter *storepar = step->GetStorePar();
451 TGo4FileStoreParameter* filepar = dynamic_cast<TGo4FileStoreParameter*>(storepar);
452 if (filepar)
453 filepar->SetAutosaveSize(treeautosave);
454 else
455 message.Append(
456 TString::Format(" - /!\\ NEVER COME HERE: can not set tree autosave interval to eventstore type %s ",
457 storepar ? storepar->ClassName() : "nullpointer"));
458 } //fgxURL_STORE_COMP
459
460 theKey.Form("%s_%d", TGo4AnalysisWebStatus::fgxURL_STORE_OVERWRITE.Data(), stepindex);
461 if (url.HasOption(theKey.Data()))
462 {
463 Int_t overwrite = url.GetIntValueFromOptions(theKey.Data());
464 message.Append(TString::Format(", %s=%d", theKey.Data(), overwrite));
465 TGo4EventStoreParameter *storepar = step->GetStorePar();
466 TGo4FileStoreParameter* filepar = dynamic_cast<TGo4FileStoreParameter*>(storepar);
467 if (filepar)
468 filepar->SetOverwriteMode(overwrite);
469 else
470 message.Append(
471 TString::Format(" - /!\\ NEVER COME HERE: can not set overwrite mode to eventstore type %s ",
472 storepar ? storepar->ClassName() : "nullpointer"));
473 } //fgxURL_STORE_OVERWRITE
474
475 step->Print();
476 stepindex++;
477 } // while step
478
480 // step independent options:
481
482 theKey = TGo4AnalysisWebStatus::fgxURL_ASF_ENABLED;
483 if (url.HasOption(theKey.Data()))
484 {
485 Int_t asfenabled = url.GetIntValueFromOptions(theKey.Data());
486 message.Append(TString::Format(", %s=%d", theKey.Data(), asfenabled));
487 SetAutoSaveOn(asfenabled);
488 } //fgxURL_ASF_ENABLED
489
490 theKey = TGo4AnalysisWebStatus::fgxURL_ASF_NAME;
491 if (url.HasOption(theKey.Data()))
492 {
493 TString asfname = url.GetValueFromOptions(theKey.Data());
494 message.Append(TString::Format(", %s=%s", theKey.Data(), asfname.Data()));
495 SetAutoFileName(asfname.Data());
496 } //fgxURL_ASF_NAME
497
498 theKey = TGo4AnalysisWebStatus::fgxURL_ASF_INTERVAL;
499 if (url.HasOption(theKey.Data()))
500 {
501 Int_t asftime = url.GetIntValueFromOptions(theKey.Data());
502 message.Append(TString::Format(", %s=%d", theKey.Data(), asftime));
503 SetAutoSaveInterval(asftime);
504 } //fgxURL_ASF_INTERVAL
505
506 theKey = TGo4AnalysisWebStatus::fgxURL_ASF_COMP;
507 if (url.HasOption(theKey.Data()))
508 {
509 Int_t asfcomp = url.GetIntValueFromOptions(theKey.Data());
510 message.Append(TString::Format(", %s=%d", theKey.Data(), asfcomp));
511 SetAutoSaveCompression(asfcomp);
512 } //fgxURL_ASF_COMP
513
514 theKey = TGo4AnalysisWebStatus::fgxURL_ASF_OVERWRITE;
515 if (url.HasOption(theKey.Data()))
516 {
517 Int_t asfover = url.GetIntValueFromOptions(theKey.Data());
518 message.Append(TString::Format(", %s=%d", theKey.Data(), asfover));
519 SetAutoSaveOverwrite(asfover);
520 } //fgxURL_ASF_OVERWRITE
521
522 theKey = TGo4AnalysisWebStatus::fgxURL_PREFS_NAME;
523 if (url.HasOption(theKey.Data()))
524 {
525 TString prefsname = url.GetValueFromOptions(theKey.Data());
526 message.Append(TString::Format(", %s=%s", theKey.Data(), prefsname.Data()));
527 SetConfigFileName(prefsname.Data());
528 } //fgxURL_PREFS_NAME
529
530 // apply this setup to analysis:
531 std::cout << "\nTGo4AnalysisWebStatus Update From Url :StopAnalysis..."<< std::endl;
532 ana->StopAnalysis(); // need this to correctly invoke UserPreLoop later!
533 std::cout << "\nTGo4AnalysisWebStatus Update From Url :SetStatus..."<< std::endl;
534 ana->SetStatus(this);
535
536 // update status for ourself
537 ana->UpdateStatus(this);
538
539 std::cout << "\nTGo4AnalysisWebStatus Update From Url :InitEventClasses..."<< std::endl;
540 ana->InitEventClasses();
541
542 // if we find start key restart analysis for submit and start button:
543 if (url.HasOption(TGo4AnalysisWebStatus::fgxURL_STARTRUN.Data()))
544 {
545 std::cout << "\nTGo4AnalysisWebStatus Update From Url :StartAnalysis..."<< std::endl;
546 ana->StartAnalysis(); // this can cause deadlock ?!
547 std::cout << "\nTGo4AnalysisWebStatus Update From Url :After StartAnalysis"<< std::endl;
548 message.Append("\n Analysis was started!");
549 }
550
551 TGo4Log::Message(1, "%s", message.Data());
552 return kTRUE;
553}
554
560
561
562Bool_t TGo4AnalysisWebStatus::ApplyStatus(TGo4AnalysisStatus *status)
563{
564 TGo4Analysis *an = TGo4Analysis::Instance();
565 TGo4AnalysisClient *cli = an ? an->GetAnalysisClient() : nullptr;
566
567 if (!an || !status) return kFALSE;
568
569 if(cli) {
570 if (cli->MainIsRunning()) an->PostLoop(); // if submit is done on running analysis,
571 } else {
572 if (!an->IsStopWorking()) an->PostLoop();
573 }
574
575 an->SetStatus(status);
576
577 // also copy values to ourself
578 an->UpdateStatus(this);
579
580 if (an->InitEventClasses()) {
581 if(cli) {
582 if (cli->MainIsRunning()) an->PreLoop(); // if submit is done on running analysis,
583 } else {
584 if (!an->IsStopWorking()) an->PreLoop();
585 }
586 }
587
588 return kTRUE;
589}
590
591
592Bool_t TGo4AnalysisWebStatus::LoadStatus(const char *fname)
593{
594 // make it here to be able use via http interface
595
596 TGo4Analysis *ana = TGo4Analysis::Instance();
597
598 return ana ? ana->LoadStatus(fname) : kFALSE;
599
600}
601
602Bool_t TGo4AnalysisWebStatus::SaveStatus(const char *fname)
603{
604 // make it here to be able use via http interface
605
606 TGo4Analysis *ana = TGo4Analysis::Instance();
607
608 return ana ? ana->SaveStatus(fname) : kFALSE;
609}
610
611
612Bool_t TGo4AnalysisWebStatus::WriteAutoSave(const char *fname,
613 Bool_t overwrite,
614 Int_t complevel)
615{
616 // make it here to be able use via http interface
617
618 TGo4Analysis *ana = TGo4Analysis::Instance();
619 if (!ana) return kFALSE;
620
621 ana->SetAutoSaveFile(fname, overwrite, complevel);
622 ana->AutoSave();
623
624 return kTRUE;
625}
626
627Bool_t TGo4AnalysisWebStatus::ExecuteLine(const char *exeline)
628{
629 if (!exeline || (*exeline == 0)) return kFALSE;
630 TGo4Analysis *ana = TGo4Analysis::Instance();
631 if(!ana) return kFALSE;
632
633 Int_t errcode = 0;
634 ana->ExecuteLine(exeline, &errcode);
635 fflush(stdout);
636 return errcode != 0 ? kFALSE : kTRUE;
637}
GO4EV_FILE
@ GO4EV_FILE
Definition Go4EventServerTypes.h:26
GO4EV_MBS_TRANSPORT
@ GO4EV_MBS_TRANSPORT
Definition Go4EventServerTypes.h:30
GO4EV_BACK
@ GO4EV_BACK
Definition Go4EventServerTypes.h:33
GO4EV_MBS_REVSERV
@ GO4EV_MBS_REVSERV
Definition Go4EventServerTypes.h:32
GO4EV_MBS_RANDOM
@ GO4EV_MBS_RANDOM
Definition Go4EventServerTypes.h:35
GO4EV_MBS_EVENTSERVER
@ GO4EV_MBS_EVENTSERVER
Definition Go4EventServerTypes.h:31
GO4EV_MBS_STREAM
@ GO4EV_MBS_STREAM
Definition Go4EventServerTypes.h:29
GO4EV_USER
@ GO4EV_USER
Definition Go4EventServerTypes.h:34
GO4EV_MBS_FILE
@ GO4EV_MBS_FILE
Definition Go4EventServerTypes.h:28
TGo4AnalysisStatus::TGo4AnalysisStatus
TGo4AnalysisStatus()
default ctor for streamer.
Definition TGo4AnalysisStatus.cxx:24
TGo4AnalysisStatus::SetAutoSaveInterval
void SetAutoSaveInterval(Int_t i)
Definition TGo4AnalysisStatus.h:52
TGo4AnalysisStatus::SetConfigFileName
void SetConfigFileName(const char *name)
Definition TGo4AnalysisStatus.h:64
TGo4AnalysisStatus::fbAutoSaveOverwrite
Int_t fbAutoSaveOverwrite
overwrite mode for autosave yes or no.
Definition TGo4AnalysisStatus.h:133
TGo4AnalysisStatus::SetAutoSaveCompression
void SetAutoSaveCompression(Int_t i=5)
Definition TGo4AnalysisStatus.h:55
TGo4AnalysisStatus::fiAutoSaveCompression
Int_t fiAutoSaveCompression
compression level for autosave file
Definition TGo4AnalysisStatus.h:129
TGo4AnalysisStatus::SetAutoSaveOverwrite
void SetAutoSaveOverwrite(Bool_t over=kTRUE)
Definition TGo4AnalysisStatus.h:58
TGo4AnalysisStatus::NextStepStatus
TGo4AnalysisStepStatus * NextStepStatus()
Gives next analysis step status.
Definition TGo4AnalysisStatus.cxx:78
TGo4AnalysisStatus::SetAutoFileName
void SetAutoFileName(const char *name)
Definition TGo4AnalysisStatus.h:61
TGo4AnalysisStatus::SetAutoSaveOn
void SetAutoSaveOn(Bool_t on=kTRUE)
Definition TGo4AnalysisStatus.h:67
TGo4AnalysisWebStatus::SaveStatus
Bool_t SaveStatus(const char *fname)
Definition TGo4AnalysisWebStatus.cxx:602
TGo4AnalysisWebStatus::fgxURL_STORE_OVERWRITE
static TString fgxURL_STORE_OVERWRITE
Definition TGo4AnalysisWebStatus.h:81
TGo4AnalysisWebStatus::UpdateFromUrl
Bool_t UpdateFromUrl(const char *rest_url_opt)
Method used by HTTP server to update some fields, specified in URL syntax.
Definition TGo4AnalysisWebStatus.cxx:59
TGo4AnalysisWebStatus::WriteAutoSave
Bool_t WriteAutoSave(const char *fname, Bool_t overwrite, Int_t complevel)
Definition TGo4AnalysisWebStatus.cxx:612
TGo4AnalysisWebStatus::ApplyStatus
Bool_t ApplyStatus(TGo4AnalysisStatus *status)
Method used by Go4GUI via HTTP to set status to analysis.
Definition TGo4AnalysisWebStatus.cxx:562
TGo4AnalysisWebStatus::ExecuteLine
Bool_t ExecuteLine(const char *cmd)
Definition TGo4AnalysisWebStatus.cxx:627
TGo4AnalysisWebStatus::fgxURL_STARTRUN
static TString fgxURL_STARTRUN
web condition editor keywords used in UpdateFromUrl:
Definition TGo4AnalysisWebStatus.h:61
TGo4AnalysisWebStatus::fgxURL_SOURCE_TIMEOUT
static TString fgxURL_SOURCE_TIMEOUT
Definition TGo4AnalysisWebStatus.h:70
TGo4AnalysisWebStatus::CreateStatus
TGo4AnalysisStatus * CreateStatus()
Methods used by Go4GUI via HTTP to obtain status of analysis.
Definition TGo4AnalysisWebStatus.cxx:555
TGo4AnalysisWebStatus::LoadStatus
Bool_t LoadStatus(const char *fname)
Definition TGo4AnalysisWebStatus.cxx:592
TGo4AnalysisWebStatus::fgxURL_ASF_OVERWRITE
static TString fgxURL_ASF_OVERWRITE
Definition TGo4AnalysisWebStatus.h:88
TGo4Analysis::UpdateStatus
void UpdateStatus(TGo4AnalysisStatus *state)
Create a copy of the analysis internal state.
Definition TGo4AnalysisImp.cxx:816
TGo4Analysis::IsStopWorking
Bool_t IsStopWorking() const
Returns true when event loop execution was stopped, only in batch mode.
Definition TGo4AnalysisImp.h:1090
TGo4Analysis::Instance
static TGo4Analysis * Instance()
return analysis instance
Definition TGo4AnalysisImp.cxx:112
TGo4Analysis::CloseAnalysis
virtual void CloseAnalysis()
Finish the analysis run and close all event sources/storages.
Definition TGo4AnalysisImp.cxx:976
TGo4Analysis::PostLoop
Int_t PostLoop()
Method executed once after the main analysis event loop.
Definition TGo4AnalysisImp.cxx:1006
TGo4Analysis::InitEventClasses
virtual Bool_t InitEventClasses()
Initialization of the event class plugins which are delivered from the user defined event factory.
Definition TGo4AnalysisImp.cxx:330
TGo4Analysis::SaveStatus
Bool_t SaveStatus(const char *filename=nullptr)
Save current analysis settings into file of given name.
Definition TGo4AnalysisImp.cxx:892
TGo4Analysis::StartAnalysis
void StartAnalysis()
(Re)Start analysis event loop, works in both batch and gui-controlled mode
Definition TGo4AnalysisImp.cxx:2499
TGo4Analysis::StopAnalysis
void StopAnalysis()
Stop analysis event loop, works in both batch and gui-controlled mode.
Definition TGo4AnalysisImp.cxx:2488
TGo4Analysis::AutoSave
void AutoSave()
Perform autosave of all active stores, save existing calibration objects, write known objects into us...
Definition TGo4AnalysisImp.cxx:1086
TGo4Analysis::SetAutoSaveFile
void SetAutoSaveFile(const char *filename=nullptr, Bool_t overwrite=kFALSE, Int_t compression=5)
Set file for autosave action.
Definition TGo4AnalysisImp.cxx:1047
TGo4Analysis::ExecuteLine
Long64_t ExecuteLine(const char *command, Int_t *errcode=nullptr)
Process ROOT command line.
Definition TGo4AnalysisImp.cxx:2426
TGo4Analysis::PreLoop
Int_t PreLoop()
Method executed once before the main analysis event loop.
Definition TGo4AnalysisImp.cxx:989
TGo4Analysis::SetStatus
void SetStatus(TGo4AnalysisStatus *state)
Set all analysis parameters to that of given status object.
Definition TGo4AnalysisImp.cxx:830
TGo4Analysis::GetAnalysisClient
TGo4AnalysisClient * GetAnalysisClient() const
Returns pointer on analysis client.
Definition TGo4AnalysisImp.h:976
TGo4Analysis::LoadStatus
Bool_t LoadStatus(const char *filename=nullptr)
Load Analysis Status from file and set analysis to these settings.
Definition TGo4AnalysisImp.cxx:846
TGo4Analysis::CreateStatus
TGo4AnalysisStatus * CreateStatus()
Create a copy of the analysis internal state.
Definition TGo4AnalysisImp.cxx:927
TGo4BackStoreParameter::SetBufsize
void SetBufsize(Int_t bufsize)
Definition TGo4BackStoreParameter.h:44
TGo4EventSourceParameter
Basic type for all classes containing information to parameterize the event source.
Definition TGo4EventSourceParameter.h:27
TGo4EventStoreParameter
Basic type for all classes containing information to parametrize the event store.
Definition TGo4EventStoreParameter.h:27
TGo4FileStoreParameter::SetOverwriteMode
void SetOverwriteMode(Bool_t over=kTRUE)
Definition TGo4FileStoreParameter.h:53
TGo4FileStoreParameter::SetBufsize
void SetBufsize(Int_t bufsize)
Definition TGo4FileStoreParameter.h:44
TGo4FileStoreParameter::SetAutosaveSize
void SetAutosaveSize(Int_t interval)
Definition TGo4FileStoreParameter.h:50
TGo4Log::Message
static const char * Message(Int_t prio, const char *text,...) GO4_PRINTF2_ARGS
Display a message.
Definition TGo4Log.cxx:206
TGo4MbsFileParameter
MBS file parameter.
Definition TGo4MbsFileParameter.h:26
TGo4MbsFileParameter::SetTagName
void SetTagName(const char *name)
Name of the Tagfile.
Definition TGo4MbsFileParameter.h:38
TGo4MbsSourceParameter::SetStartEvent
void SetStartEvent(UInt_t firstindex)
Define the Start index for the NextEvent.
Definition TGo4MbsSourceParameter.h:32
TGo4MbsSourceParameter::SetPort
void SetPort(Int_t port)
Set optional port number, 0 or negative value means that default port number will be used.
Definition TGo4MbsSourceParameter.h:50
TGo4MbsSourceParameter::GetPort
Int_t GetPort() const
Return optional port number, 0 or negative value means that default port number will be used.
Definition TGo4MbsSourceParameter.h:53
TGo4MbsSourceParameter::GetEventInterval
UInt_t GetEventInterval() const
Returns event interval.
Definition TGo4MbsSourceParameter.h:47
TGo4MbsSourceParameter::GetStopEvent
UInt_t GetStopEvent() const
Returns the index of Stop event.
Definition TGo4MbsSourceParameter.h:41
TGo4MbsSourceParameter::SetStopEvent
void SetStopEvent(UInt_t lastindex)
Define the index of Stop event.
Definition TGo4MbsSourceParameter.h:38
TGo4MbsSourceParameter::SetRetryCnt
void SetRetryCnt(Int_t cnt)
Set number of allowed reconnection retries.
Definition TGo4MbsSourceParameter.h:56
TGo4MbsSourceParameter::GetStartEvent
UInt_t GetStartEvent() const
Returns the Start index for the NextEvent.
Definition TGo4MbsSourceParameter.h:35
TGo4MbsSourceParameter::SetEventInterval
void SetEventInterval(UInt_t skipinterval)
Defines event interval.
Definition TGo4MbsSourceParameter.h:44
TGo4RevServParameter
Rev serv parameter.
Definition TGo4RevServParameter.h:22
TGo4Slave::MainIsRunning
Bool_t MainIsRunning() const
Definition TGo4Slave.h:98
Generated by doxygen 1.13.2