otsdaq  v2_03_00
FESupervisor.cc
1 #include "otsdaq-core/CoreSupervisors/FESupervisor.h"
2 #include "otsdaq-core/ConfigurationInterface/ConfigurationManager.h"
3 #include "otsdaq-core/FECore/FEVInterfacesManager.h"
4 
5 using namespace ots;
6 
7 XDAQ_INSTANTIATOR_IMPL(FESupervisor)
8 
9 //========================================================================================================================
10 FESupervisor::FESupervisor(xdaq::ApplicationStub* stub)
11 : CoreSupervisorBase(stub)
12 {
13  xoap::bind(this,
14  &FESupervisor::macroMakerSupervisorRequest,
15  "MacroMakerSupervisorRequest",
16  XDAQ_NS_URI);
17 
18  xoap::bind(
19  this, &FESupervisor::workLoopStatusRequest, "WorkLoopStatusRequest", XDAQ_NS_URI);
20 
21  xoap::bind(this,
22  &FESupervisor::frontEndCommunicationRequest,
23  "FECommunication",
24  XDAQ_NS_URI);
25 
26  CoreSupervisorBase::theStateMachineImplementation_.push_back(new FEVInterfacesManager(
27  CorePropertySupervisorBase::getContextTreeNode(),
28  CorePropertySupervisorBase::getSupervisorConfigurationPath()));
29 
30  extractFEInterfacesManager();
31 
32  __SUP_COUT__ << "Destructed." << __E__;
33 } // end constructor
34 
35 //========================================================================================================================
36 FESupervisor::~FESupervisor(void)
37 {
38  __SUP_COUT__ << "Destroying..." << __E__;
39  // theStateMachineImplementation_ is reset and the object it points to deleted in
40  // ~CoreSupervisorBase()
41  __SUP_COUT__ << "Destructed." << __E__;
42 } // end destructor
43 
44 //========================================================================================================================
45 xoap::MessageReference FESupervisor::frontEndCommunicationRequest(
46  xoap::MessageReference message) try
47 {
48  __SUP_COUT__ << "FE Request received: " << SOAPUtilities::translate(message) << __E__;
49 
50  if(!theFEInterfacesManager_)
51  {
52  __SUP_SS__ << "No FE Interface Manager!" << __E__;
53  __SUP_SS_THROW__;
54  }
55  SOAPParameters typeParameter, rxParameters; // params for xoap to recv
56  typeParameter.addParameter("type");
57  SOAPUtilities::receive(message, typeParameter);
58 
59  std::string type = typeParameter.getValue("type");
60 
61  // types
62  // feSend
63  // feMacro
64  // feMacroMultiDimensionalStart
65  // macroMultiDimensionalStart
66  // feMacroMultiDimensionalCheck
67  // macroMultiDimensionalCheck
68 
69  rxParameters.addParameter("requester");
70  rxParameters.addParameter("targetInterfaceID");
71 
72  if(type == "feSend")
73  {
74  __SUP_COUTV__(type);
75 
76  rxParameters.addParameter("value");
77  SOAPUtilities::receive(message, rxParameters);
78 
79  std::string requester = rxParameters.getValue("requester");
80  std::string targetInterfaceID = rxParameters.getValue("targetInterfaceID");
81  std::string value = rxParameters.getValue("value");
82 
83  __SUP_COUTV__(requester);
84  __SUP_COUTV__(targetInterfaceID);
85  __SUP_COUTV__(value);
86 
87  // test that the interface exists
88  theFEInterfacesManager_->getFEInterface(targetInterfaceID);
89 
90  // mutex scope
91  {
92  std::lock_guard<std::mutex> lock(
93  theFEInterfacesManager_->frontEndCommunicationReceiveMutex_);
94 
95  theFEInterfacesManager_
96  ->frontEndCommunicationReceiveBuffer_[targetInterfaceID][requester]
97  .emplace(value);
98 
99  __SUP_COUT__ << "Number of target interface ID '" << targetInterfaceID
100  << "' buffers: "
101  << theFEInterfacesManager_
102  ->frontEndCommunicationReceiveBuffer_[targetInterfaceID]
103  .size()
104  << __E__;
105  __SUP_COUT__
106  << "Number of source interface ID '" << requester << "' values received: "
107  << theFEInterfacesManager_
108  ->frontEndCommunicationReceiveBuffer_[targetInterfaceID][requester]
109  .size()
110  << __E__;
111  }
112  return SOAPUtilities::makeSOAPMessageReference("Received");
113  } // end type feSend
114  else if(type == "feMacro")
115  {
116  __SUP_COUTV__(type);
117 
118  rxParameters.addParameter("feMacroName");
119  rxParameters.addParameter("inputArgs");
120 
121  SOAPUtilities::receive(message, rxParameters);
122 
123  std::string requester = rxParameters.getValue("requester");
124  std::string targetInterfaceID = rxParameters.getValue("targetInterfaceID");
125  std::string feMacroName = rxParameters.getValue("feMacroName");
126  std::string inputArgs = rxParameters.getValue("inputArgs");
127 
128  __SUP_COUTV__(requester);
129  __SUP_COUTV__(targetInterfaceID);
130  __SUP_COUTV__(feMacroName);
131  __SUP_COUTV__(inputArgs);
132 
133  std::string outputArgs;
134  try
135  {
136  theFEInterfacesManager_->runFEMacroByFE(
137  requester, targetInterfaceID, feMacroName, inputArgs, outputArgs);
138  }
139  catch(std::runtime_error& e)
140  {
141  __SUP_SS__ << "In Supervisor with LID="
142  << getApplicationDescriptor()->getLocalId()
143  << " the FE Macro named '" << feMacroName << "' with target FE '"
144  << targetInterfaceID << "' failed. Here is the error:\n\n"
145  << e.what() << __E__;
146  __SUP_SS_THROW__;
147  }
148  catch(...)
149  {
150  __SUP_SS__ << "In Supervisor with LID="
151  << getApplicationDescriptor()->getLocalId()
152  << " the FE Macro named '" << feMacroName << "' with target FE '"
153  << targetInterfaceID << "' failed due to an unknown error."
154  << __E__;
155  __SUP_SS_THROW__;
156  }
157 
158  __SUP_COUTV__(outputArgs);
159 
160  xoap::MessageReference replyMessage =
161  SOAPUtilities::makeSOAPMessageReference("feMacrosResponse");
162  SOAPParameters txParameters;
163  txParameters.addParameter("requester", requester);
164  txParameters.addParameter("targetInterfaceID", targetInterfaceID);
165  txParameters.addParameter("feMacroName", feMacroName);
166  txParameters.addParameter("outputArgs", outputArgs);
167  SOAPUtilities::addParameters(replyMessage, txParameters);
168 
169  __SUP_COUT__ << "Sending FE macro result: "
170  << SOAPUtilities::translate(replyMessage) << __E__;
171 
172  return replyMessage;
173  } // end type feMacro
174  else if(type == "feMacroMultiDimensionalStart" || // from iterator
175  type == "macroMultiDimensionalStart") // from iterator
176  {
177  __SUP_COUTV__(type);
178 
179  if(type[0] == 'm')
180  {
181  rxParameters.addParameter("macroString");
182  rxParameters.addParameter("macroName");
183  }
184  else
185  rxParameters.addParameter("feMacroName");
186 
187  rxParameters.addParameter("enableSavingOutput");
188  rxParameters.addParameter("outputFilePath");
189  rxParameters.addParameter("outputFileRadix");
190  rxParameters.addParameter("inputArgs");
191 
192  SOAPUtilities::receive(message, rxParameters);
193 
194  std::string requester = rxParameters.getValue("requester");
195  std::string targetInterfaceID = rxParameters.getValue("targetInterfaceID");
196  std::string macroName, macroString;
197  if(type[0] == 'm')
198  {
199  macroName = rxParameters.getValue("macroName");
200  macroString = rxParameters.getValue("macroString");
201  __SUP_COUTV__(macroString);
202  }
203  else
204  macroName = rxParameters.getValue("feMacroName");
205  bool enableSavingOutput = rxParameters.getValue("enableSavingOutput") == "1";
206  std::string outputFilePath = rxParameters.getValue("outputFilePath");
207  std::string outputFileRadix = rxParameters.getValue("outputFileRadix");
208  std::string inputArgs = rxParameters.getValue("inputArgs");
209 
210  __SUP_COUTV__(requester);
211  __SUP_COUTV__(targetInterfaceID);
212  __SUP_COUTV__(macroName);
213  __SUP_COUTV__(enableSavingOutput);
214  __SUP_COUTV__(outputFilePath);
215  __SUP_COUTV__(outputFileRadix);
216  __SUP_COUTV__(inputArgs);
217 
218  if(type[0] == 'm') // start Macro
219  {
220  try
221  {
222  theFEInterfacesManager_->startMacroMultiDimensional(requester,
223  targetInterfaceID,
224  macroName,
225  macroString,
226  enableSavingOutput,
227  outputFilePath,
228  outputFileRadix,
229  inputArgs);
230  }
231  catch(std::runtime_error& e)
232  {
233  __SUP_SS__ << "In Supervisor with LID="
234  << getApplicationDescriptor()->getLocalId()
235  << " the Macro named '" << macroName << "' with target FE '"
236  << targetInterfaceID
237  << "' failed to start multi-dimensional launch. "
238  << "Here is the error:\n\n"
239  << e.what() << __E__;
240  __SUP_SS_THROW__;
241  }
242  catch(...)
243  {
244  __SUP_SS__ << "In Supervisor with LID="
245  << getApplicationDescriptor()->getLocalId()
246  << " the Macro named '" << macroName << "' with target FE '"
247  << targetInterfaceID
248  << "' failed to start multi-dimensional launch "
249  << "due to an unknown error." << __E__;
250  __SUP_SS_THROW__;
251  }
252  }
253  else // start FE Macro
254  {
255  try
256  {
257  theFEInterfacesManager_->startFEMacroMultiDimensional(requester,
258  targetInterfaceID,
259  macroName,
260  enableSavingOutput,
261  outputFilePath,
262  outputFileRadix,
263  inputArgs);
264  }
265  catch(std::runtime_error& e)
266  {
267  __SUP_SS__ << "In Supervisor with LID="
268  << getApplicationDescriptor()->getLocalId()
269  << " the FE Macro named '" << macroName << "' with target FE '"
270  << targetInterfaceID
271  << "' failed to start multi-dimensional launch. "
272  << "Here is the error:\n\n"
273  << e.what() << __E__;
274  __SUP_SS_THROW__;
275  }
276  catch(...)
277  {
278  __SUP_SS__ << "In Supervisor with LID="
279  << getApplicationDescriptor()->getLocalId()
280  << " the FE Macro named '" << macroName << "' with target FE '"
281  << targetInterfaceID
282  << "' failed to start multi-dimensional launch "
283  << "due to an unknown error." << __E__;
284  __SUP_SS_THROW__;
285  }
286  }
287 
288  xoap::MessageReference replyMessage =
289  SOAPUtilities::makeSOAPMessageReference(type + "Done");
290  SOAPParameters txParameters;
291  // txParameters.addParameter("started", "1");
292  SOAPUtilities::addParameters(replyMessage, txParameters);
293 
294  __SUP_COUT__ << "Sending FE macro result: "
295  << SOAPUtilities::translate(replyMessage) << __E__;
296 
297  return replyMessage;
298  } // end type (fe)MacroMultiDimensionalStart
299  else if(type == "feMacroMultiDimensionalCheck" || // from iterator
300  type == "macroMultiDimensionalCheck")
301  {
302  __SUP_COUTV__(type);
303  if(type[0] == 'm')
304  rxParameters.addParameter("macroName");
305  else
306  rxParameters.addParameter("feMacroName");
307  rxParameters.addParameter("targetInterfaceID");
308 
309  SOAPUtilities::receive(message, rxParameters);
310 
311  std::string targetInterfaceID = rxParameters.getValue("targetInterfaceID");
312  std::string macroName;
313  if(type[0] == 'm')
314  macroName = rxParameters.getValue("macroName");
315  else
316  macroName = rxParameters.getValue("feMacroName");
317 
318  __SUP_COUTV__(targetInterfaceID);
319  __SUP_COUTV__(macroName);
320 
321  bool done = false;
322  try
323  {
324  done = theFEInterfacesManager_->checkMacroMultiDimensional(targetInterfaceID,
325  macroName);
326  }
327  catch(std::runtime_error& e)
328  {
329  __SUP_SS__ << "In Supervisor with LID="
330  << getApplicationDescriptor()->getLocalId()
331  << " the FE Macro named '" << macroName << "' with target FE '"
332  << targetInterfaceID
333  << "' failed to check multi-dimensional launch. "
334  << "Here is the error:\n\n"
335  << e.what() << __E__;
336  __SUP_SS_THROW__;
337  }
338  catch(...)
339  {
340  __SUP_SS__ << "In Supervisor with LID="
341  << getApplicationDescriptor()->getLocalId()
342  << " the FE Macro named '" << macroName << "' with target FE '"
343  << targetInterfaceID
344  << "' failed to check multi-dimensional launch "
345  << "due to an unknown error." << __E__;
346  __SUP_SS_THROW__;
347  }
348 
349  xoap::MessageReference replyMessage =
350  SOAPUtilities::makeSOAPMessageReference(type + "Done");
351  SOAPParameters txParameters;
352  txParameters.addParameter("Done", done ? "1" : "0");
353  SOAPUtilities::addParameters(replyMessage, txParameters);
354 
355  __SUP_COUT__ << "Sending FE macro result: "
356  << SOAPUtilities::translate(replyMessage) << __E__;
357 
358  return replyMessage;
359  } // end type (fe)MacroMultiDimensionalCheck
360  else
361  {
362  __SUP_SS__ << "Unrecognized FE Communication type: " << type << __E__;
363  __SUP_SS_THROW__;
364  }
365 }
366 catch(const std::runtime_error& e)
367 {
368  __SUP_SS__ << "Error encountered processing FE communication request: " << e.what()
369  << __E__;
370  __SUP_COUT_ERR__ << ss.str();
371 
372  SOAPParameters parameters;
373  parameters.addParameter("Error", ss.str());
374  return SOAPUtilities::makeSOAPMessageReference(
375  supervisorClassNoNamespace_ + "FailFECommunicationRequest", parameters);
376 }
377 catch(...)
378 {
379  __SUP_SS__ << "Unknown error encountered processing FE communication request."
380  << __E__;
381  __SUP_COUT_ERR__ << ss.str();
382 
383  SOAPParameters parameters;
384  parameters.addParameter("Error", ss.str());
385  return SOAPUtilities::makeSOAPMessageReference(
386  supervisorClassNoNamespace_ + "FailFECommunicationRequest", parameters);
387 } // end frontEndCommunicationRequest()
388 
389 //========================================================================================================================
390 // macroMakerSupervisorRequest
391 // Handles all MacroMaker Requests:
392 // - GetInterfaces (returns interface type and id)
393 //
394 // Note: this code assumes a CoreSupervisorBase has only one
395 // FEVInterfacesManager in its vector of state machines
396 xoap::MessageReference FESupervisor::macroMakerSupervisorRequest(
397  xoap::MessageReference message)
398 {
399  __SUP_COUT__ << "$$$$$$$$$$$$$$$$$" << __E__;
400 
401  // receive request parameters
402  SOAPParameters parameters;
403  parameters.addParameter("Request");
404 
405  __SUP_COUT__ << "Received Macro Maker message: " << SOAPUtilities::translate(message)
406  << __E__;
407 
408  SOAPUtilities::receive(message, parameters);
409  std::string request = parameters.getValue("Request");
410 
411  __SUP_COUT__ << "request: " << request << __E__;
412 
413  // request types:
414  // GetInterfaces
415  // UniversalWrite
416  // UniversalRead
417  // GetInterfaceMacros
418  // RunInterfaceMacro
419  // RunMacroMakerMacro
420 
421  SOAPParameters retParameters;
422 
423  try
424  {
425  if(request == "GetInterfaces")
426  {
427  if(theFEInterfacesManager_)
428  retParameters.addParameter(
429  "FEList",
430  theFEInterfacesManager_->getFEListString(
431  std::to_string(getApplicationDescriptor()->getLocalId())));
432  else // if no FE interfaces, return empty string
433  retParameters.addParameter("FEList", "");
434 
435  return SOAPUtilities::makeSOAPMessageReference(
436  supervisorClassNoNamespace_ + "Response", retParameters);
437  }
438  else if(request == "UniversalWrite")
439  {
440  if(!theFEInterfacesManager_)
441  {
442  __SUP_SS__ << "No FE Interface Manager! Are you configured?" << __E__;
443  __SUP_SS_THROW__;
444  }
445  // params for running macros
446  SOAPParameters requestParameters;
447  requestParameters.addParameter("InterfaceID");
448  requestParameters.addParameter("Address");
449  requestParameters.addParameter("Data");
450  SOAPUtilities::receive(message, requestParameters);
451  std::string interfaceID = requestParameters.getValue("InterfaceID");
452  std::string addressStr = requestParameters.getValue("Address");
453  std::string dataStr = requestParameters.getValue("Data");
454 
455  __SUP_COUT__ << "Address: " << addressStr << " Data: " << dataStr
456  << " InterfaceID: " << interfaceID << __E__;
457 
458  // parameters interface index!
459  // unsigned int index = stoi(indexStr); // As long as the supervisor has only
460  // one interface, this index will remain 0?
461 
462  __SUP_COUT__
463  << "theFEInterfacesManager_->getInterfaceUniversalAddressSize(index) "
464  << theFEInterfacesManager_->getInterfaceUniversalAddressSize(interfaceID)
465  << __E__;
466  __SUP_COUT__
467  << "theFEInterfacesManager_->getInterfaceUniversalDataSize(index) "
468  << theFEInterfacesManager_->getInterfaceUniversalDataSize(interfaceID)
469  << __E__;
470 
471  // Converting std::string to char*
472  // char address
473 
474  char tmpHex[3]; // for use converting hex to binary
475  tmpHex[2] = '\0';
476 
477  __SUP_COUT__ << "Translating address: ";
478 
479  std::string addressTmp;
480  addressTmp.reserve(
481  theFEInterfacesManager_->getInterfaceUniversalAddressSize(interfaceID));
482  char* address = &addressTmp[0];
483 
484  if(addressStr.size() % 2) // if odd, make even
485  addressStr = "0" + addressStr;
486  unsigned int i = 0;
487  for(; i < addressStr.size() &&
488  i / 2 < theFEInterfacesManager_->getInterfaceUniversalAddressSize(
489  interfaceID);
490  i += 2)
491  {
492  tmpHex[0] = addressStr[addressStr.size() - 1 - i - 1];
493  tmpHex[1] = addressStr[addressStr.size() - 1 - i];
494  sscanf(tmpHex, "%hhX", (unsigned char*)&address[i / 2]);
495  printf("%2.2X", (unsigned char)address[i / 2]);
496  }
497  // finish and fill with 0s
498  for(; i / 2 <
499  theFEInterfacesManager_->getInterfaceUniversalAddressSize(interfaceID);
500  i += 2)
501  {
502  address[i / 2] = 0;
503  printf("%2.2X", (unsigned char)address[i / 2]);
504  }
505 
506  std::cout << __E__;
507 
508  __SUP_COUT__ << "Translating data: ";
509 
510  std::string dataTmp;
511  dataTmp.reserve(
512  theFEInterfacesManager_->getInterfaceUniversalDataSize(interfaceID));
513  char* data = &dataTmp[0];
514 
515  if(dataStr.size() % 2) // if odd, make even
516  dataStr = "0" + dataStr;
517 
518  i = 0;
519  for(; i < dataStr.size() &&
520  i / 2 <
521  theFEInterfacesManager_->getInterfaceUniversalDataSize(interfaceID);
522  i += 2)
523  {
524  tmpHex[0] = dataStr[dataStr.size() - 1 - i - 1];
525  tmpHex[1] = dataStr[dataStr.size() - 1 - i];
526  sscanf(tmpHex, "%hhX", (unsigned char*)&data[i / 2]);
527  printf("%2.2X", (unsigned char)data[i / 2]);
528  }
529  // finish and fill with 0s
530  for(; i / 2 <
531  theFEInterfacesManager_->getInterfaceUniversalDataSize(interfaceID);
532  i += 2)
533  {
534  data[i / 2] = 0;
535  printf("%2.2X", (unsigned char)data[i / 2]);
536  }
537 
538  std::cout << __E__;
539 
540  // char* address = new char[addressStr.size() + 1];
541  // std::copy(addressStr.begin(), addressStr.end(), address);
542  // address[addressStr.size()] = '\0';
543  // char* data = new char[dataStr.size() + 1];
544  // std::copy(dataStr.begin(), dataStr.end(), data);
545  // data[dataStr.size()] = '\0';
546 
547  theFEInterfacesManager_->universalWrite(interfaceID, address, data);
548 
549  // delete[] address;
550  // delete[] data;
551 
552  return SOAPUtilities::makeSOAPMessageReference(
553  supervisorClassNoNamespace_ + "DataWritten", retParameters);
554  }
555  else if(request == "UniversalRead")
556  {
557  if(!theFEInterfacesManager_)
558  {
559  __SUP_SS__ << "No FE Interface Manager! Are you configured?" << __E__;
560  __SUP_SS_THROW__;
561  }
562 
563  // params for running macros
564  SOAPParameters requestParameters;
565  requestParameters.addParameter("InterfaceID");
566  requestParameters.addParameter("Address");
567  SOAPUtilities::receive(message, requestParameters);
568  std::string interfaceID = requestParameters.getValue("InterfaceID");
569  std::string addressStr = requestParameters.getValue("Address");
570 
571  __SUP_COUT__ << "Address: " << addressStr << " InterfaceID: " << interfaceID
572  << __E__;
573 
574  // parameters interface index!
575  // parameter address and data
576  // unsigned int index = stoi(indexStr); // As long as the supervisor has only
577  // one interface, this index will remain 0?
578 
579  __SUP_COUT__
580  << "theFEInterfacesManager_->getInterfaceUniversalAddressSize(index) "
581  << theFEInterfacesManager_->getInterfaceUniversalAddressSize(interfaceID)
582  << __E__;
583  __SUP_COUT__
584  << "theFEInterfacesManager_->getInterfaceUniversalDataSize(index) "
585  << theFEInterfacesManager_->getInterfaceUniversalDataSize(interfaceID)
586  << __E__;
587 
588  char tmpHex[3]; // for use converting hex to binary
589  tmpHex[2] = '\0';
590 
591  __SUP_COUT__ << "Translating address: ";
592 
593  std::string addressTmp;
594  addressTmp.reserve(
595  theFEInterfacesManager_->getInterfaceUniversalAddressSize(interfaceID));
596  char* address = &addressTmp[0];
597 
598  if(addressStr.size() % 2) // if odd, make even
599  addressStr = "0" + addressStr;
600 
601  unsigned int i = 0;
602  for(; i < addressStr.size() &&
603  i / 2 < theFEInterfacesManager_->getInterfaceUniversalAddressSize(
604  interfaceID);
605  i += 2)
606  {
607  tmpHex[0] = addressStr[addressStr.size() - 1 - i - 1];
608  tmpHex[1] = addressStr[addressStr.size() - 1 - i];
609  sscanf(tmpHex, "%hhX", (unsigned char*)&address[i / 2]);
610  printf("%2.2X", (unsigned char)address[i / 2]);
611  }
612  // finish and fill with 0s
613  for(; i / 2 <
614  theFEInterfacesManager_->getInterfaceUniversalAddressSize(interfaceID);
615  i += 2)
616  {
617  address[i / 2] = 0;
618  printf("%2.2X", (unsigned char)address[i / 2]);
619  }
620 
621  std::cout << __E__;
622 
623  unsigned int dataSz =
624  theFEInterfacesManager_->getInterfaceUniversalDataSize(interfaceID);
625  std::string dataStr;
626  dataStr.resize(dataSz);
627  char* data = &dataStr[0];
628 
629  // std::string result =
630  // theFEInterfacesManager_->universalRead(index,address,data);
631  // __SUP_COUT__<< result << __E__ << __E__;
632 
633  try
634  {
635  theFEInterfacesManager_->universalRead(interfaceID, address, data);
636  }
637  catch(const std::runtime_error& e)
638  {
639  // do not allow read exception to crash everything when a macromaker
640  // command
641  __MOUT_ERR__ << "Exception caught during read: " << e.what() << __E__;
642  __SUP_COUT_ERR__ << "Exception caught during read: " << e.what() << __E__;
643  retParameters.addParameter("dataResult", "Time Out Error");
644  return SOAPUtilities::makeSOAPMessageReference(
645  supervisorClassNoNamespace_ + "aa", retParameters);
646  }
647  catch(...)
648  {
649  // do not allow read exception to crash everything when a macromaker
650  // command
651  __MOUT_ERR__ << "Exception caught during read." << __E__;
652  __SUP_COUT_ERR__ << "Exception caught during read." << __E__;
653  retParameters.addParameter("dataResult", "Time Out Error");
654  return SOAPUtilities::makeSOAPMessageReference(
655  supervisorClassNoNamespace_ + "aa", retParameters);
656  }
657 
658  // if dataSz is less than 8 show what the unsigned number would be
659  if(dataSz <= 8)
660  {
661  std::string str8(data);
662  str8.resize(8);
663  __SUP_COUT__ << "decResult[" << dataSz
664  << " bytes]: " << *((unsigned long long*)(&str8[0]))
665  << __E__;
666  }
667 
668  std::string hexResultStr;
669  hexResultStr.reserve(dataSz * 2 + 1);
670  char* hexResult = &hexResultStr[0];
671  // go through each byte and convert it to hex value (i.e. 2 0-F chars)
672  // go backwards through source data since should be provided in host order
673  // (i.e. a cast to unsigned long long should acquire expected value)
674  for(unsigned int i = 0; i < dataSz; ++i)
675  {
676  sprintf(&hexResult[i * 2], "%2.2X", (unsigned char)data[dataSz - 1 - i]);
677  }
678 
679  __SUP_COUT__ << "hexResult[" << strlen(hexResult)
680  << " nibbles]: " << std::string(hexResult) << __E__;
681 
682  retParameters.addParameter("dataResult", hexResult);
683  return SOAPUtilities::makeSOAPMessageReference(
684  supervisorClassNoNamespace_ + "aa", retParameters);
685  }
686  else if(request == "GetInterfaceMacros")
687  {
688  if(theFEInterfacesManager_)
689  retParameters.addParameter(
690  "FEMacros",
691  theFEInterfacesManager_->getFEMacrosString(
692  CorePropertySupervisorBase::getSupervisorUID(),
693  std::to_string(
694  CoreSupervisorBase::getSupervisorLID())));
695  else
696  retParameters.addParameter("FEMacros", "");
697 
698  return SOAPUtilities::makeSOAPMessageReference(
699  supervisorClassNoNamespace_ + "Response", retParameters);
700  }
701  else if(request == "RunInterfaceMacro")
702  {
703  if(!theFEInterfacesManager_)
704  {
705  __SUP_SS__ << "Missing FE Interface Manager! Are you configured?"
706  << __E__;
707  __SUP_SS_THROW__;
708  }
709 
710  // params for running macros
711  SOAPParameters requestParameters;
712  requestParameters.addParameter("feMacroName");
713  requestParameters.addParameter("inputArgs");
714  requestParameters.addParameter("outputArgs");
715  requestParameters.addParameter("InterfaceID");
716  SOAPUtilities::receive(message, requestParameters);
717  std::string interfaceID = requestParameters.getValue("InterfaceID");
718  std::string feMacroName = requestParameters.getValue("feMacroName");
719  std::string inputArgs = requestParameters.getValue("inputArgs");
720  std::string outputArgs = requestParameters.getValue("outputArgs");
721 
722  // outputArgs must be filled with the proper argument names
723  // and then the response output values will be returned in the string.
724  try
725  {
726  theFEInterfacesManager_->runFEMacro(
727  interfaceID, feMacroName, inputArgs, outputArgs);
728  }
729  catch(std::runtime_error& e)
730  {
731  __SUP_SS__ << "In Supervisor with LID="
732  << getApplicationDescriptor()->getLocalId()
733  << " the FE Macro named '" << feMacroName
734  << "' with target FE '" << interfaceID
735  << "' failed. Here is the error:\n\n"
736  << e.what() << __E__;
737  __SUP_SS_THROW__;
738  }
739  catch(...)
740  {
741  __SUP_SS__ << "In Supervisor with LID="
742  << getApplicationDescriptor()->getLocalId()
743  << " the FE Macro named '" << feMacroName
744  << "' with target FE '" << interfaceID
745  << "' failed due to an unknown error." << __E__;
746  __SUP_SS_THROW__;
747  }
748 
749  // retParameters.addParameter("success", success ? "1" : "0");
750  retParameters.addParameter("outputArgs", outputArgs);
751 
752  return SOAPUtilities::makeSOAPMessageReference(
753  supervisorClassNoNamespace_ + "Response", retParameters);
754  }
755  else if(request == "RunMacroMakerMacro")
756  {
757  if(!theFEInterfacesManager_)
758  {
759  __SUP_SS__ << "Missing FE Interface Manager! Are you configured?"
760  << __E__;
761  __SUP_SS_THROW__;
762  }
763 
764  // params for running macros
765  SOAPParameters requestParameters;
766  requestParameters.addParameter("macroName");
767  requestParameters.addParameter("macroString");
768  requestParameters.addParameter("inputArgs");
769  requestParameters.addParameter("outputArgs");
770  requestParameters.addParameter("InterfaceID");
771  SOAPUtilities::receive(message, requestParameters);
772  std::string interfaceID = requestParameters.getValue("InterfaceID");
773  std::string macroName = requestParameters.getValue("macroName");
774  std::string macroString = requestParameters.getValue("macroString");
775  std::string inputArgs = requestParameters.getValue("inputArgs");
776  std::string outputArgs = requestParameters.getValue("outputArgs");
777 
778  // outputArgs must be filled with the proper argument names
779  // and then the response output values will be returned in the string.
780  try
781  {
782  theFEInterfacesManager_->runMacro(
783  interfaceID, macroString, inputArgs, outputArgs);
784  }
785  catch(std::runtime_error& e)
786  {
787  __SUP_SS__ << "In Supervisor with LID="
788  << getApplicationDescriptor()->getLocalId()
789  << " the MacroMaker Macro named '" << macroName
790  << "' with target FE '" << interfaceID
791  << "' failed. Here is the error:\n\n"
792  << e.what() << __E__;
793  __SUP_SS_THROW__;
794  }
795  catch(...)
796  {
797  __SUP_SS__ << "In Supervisor with LID="
798  << getApplicationDescriptor()->getLocalId()
799  << " the MacroMaker Macro named '" << macroName
800  << "' with target FE '" << interfaceID
801  << "' failed due to an unknown error." << __E__;
802  __SUP_SS_THROW__;
803  }
804 
805  retParameters.addParameter("outputArgs", outputArgs);
806 
807  return SOAPUtilities::makeSOAPMessageReference(
808  supervisorClassNoNamespace_ + "Response", retParameters);
809  }
810  else
811  {
812  __SUP_SS__ << "Unrecognized request received! '" << request << "'" << __E__;
813  __SUP_SS_THROW__;
814  }
815  }
816  catch(const std::runtime_error& e)
817  {
818  __SUP_SS__ << "Error occurred handling request: " << e.what() << __E__;
819  __SUP_COUT_ERR__ << ss.str();
820  retParameters.addParameter("Error", ss.str());
821  }
822  catch(...)
823  {
824  __SUP_SS__ << "Error occurred handling request." << __E__;
825  __SUP_COUT_ERR__ << ss.str();
826  retParameters.addParameter("Error", ss.str());
827  }
828 
829  return SOAPUtilities::makeSOAPMessageReference(
830  supervisorClassNoNamespace_ + "FailRequest", retParameters);
831 
832 } // end macroMakerSupervisorRequest()
833 
834 //========================================================================================================================
835 xoap::MessageReference FESupervisor::workLoopStatusRequest(xoap::MessageReference message)
836 {
837  if(!theFEInterfacesManager_)
838  {
839  __SUP_SS__ << "Invalid request for front-end workloop status from Supervisor "
840  "without a FEVInterfacesManager."
841  << __E__;
842  __SUP_SS_THROW__;
843  }
844 
845  return SOAPUtilities::makeSOAPMessageReference(
846  (theFEInterfacesManager_->allFEWorkloopsAreDone()
847  ? CoreSupervisorBase::WORK_LOOP_DONE
848  : CoreSupervisorBase::WORK_LOOP_WORKING));
849 } // end workLoopStatusRequest()
850 
851 //========================================================================================================================
852 // extractFEInterfaceManager
853 //
854 // locates theFEInterfacesManager in state machines vector and
855 // returns 0 if not found.
856 //
857 // Note: this code assumes a CoreSupervisorBase has only one
858 // FEVInterfacesManager in its vector of state machines
859 FEVInterfacesManager* FESupervisor::extractFEInterfacesManager()
860 {
861  theFEInterfacesManager_ = 0;
862 
863  for(unsigned int i = 0; i < theStateMachineImplementation_.size(); ++i)
864  {
865  try
866  {
867  theFEInterfacesManager_ =
868  dynamic_cast<FEVInterfacesManager*>(theStateMachineImplementation_[i]);
869  if(!theFEInterfacesManager_)
870  {
871  // dynamic_cast returns null pointer on failure
872  __SUP_SS__ << "Dynamic cast failure!" << __E__;
873  __SUP_SS_THROW__;
874  }
875  __SUP_COUT__ << "State Machine " << i << " WAS of type FEVInterfacesManager"
876  << __E__;
877 
878  break;
879  }
880  catch(...)
881  {
882  __SUP_COUT__ << "State Machine " << i
883  << " was NOT of type FEVInterfacesManager" << __E__;
884  }
885  }
886 
887  __SUP_COUT__ << "theFEInterfacesManager pointer = " << theFEInterfacesManager_
888  << __E__;
889 
890  return theFEInterfacesManager_;
891 } // end extractFEInterfaceManager()
void startMacroMultiDimensional(const std::string &requester, const std::string &interfaceID, const std::string &macroName, const std::string &macroString, const bool enableSavingOutput, const std::string &outputFilePath, const std::string &outputFileRadix, const std::string &inputArgs)