$treeview $search $mathjax $extrastylesheet
otsdaq
v2_03_00
$projectbrief
|
$projectbrief
|
$searchbox |
00001 #include "otsdaq-core/CoreSupervisors/FESupervisor.h" 00002 #include "otsdaq-core/ConfigurationInterface/ConfigurationManager.h" 00003 #include "otsdaq-core/FECore/FEVInterfacesManager.h" 00004 00005 using namespace ots; 00006 00007 XDAQ_INSTANTIATOR_IMPL(FESupervisor) 00008 00009 //======================================================================================================================== 00010 FESupervisor::FESupervisor(xdaq::ApplicationStub* stub) 00011 : CoreSupervisorBase(stub) 00012 { 00013 xoap::bind(this, 00014 &FESupervisor::macroMakerSupervisorRequest, 00015 "MacroMakerSupervisorRequest", 00016 XDAQ_NS_URI); 00017 00018 xoap::bind( 00019 this, &FESupervisor::workLoopStatusRequest, "WorkLoopStatusRequest", XDAQ_NS_URI); 00020 00021 xoap::bind(this, 00022 &FESupervisor::frontEndCommunicationRequest, 00023 "FECommunication", 00024 XDAQ_NS_URI); 00025 00026 CoreSupervisorBase::theStateMachineImplementation_.push_back(new FEVInterfacesManager( 00027 CorePropertySupervisorBase::getContextTreeNode(), 00028 CorePropertySupervisorBase::getSupervisorConfigurationPath())); 00029 00030 extractFEInterfacesManager(); 00031 00032 __SUP_COUT__ << "Destructed." << __E__; 00033 } // end constructor 00034 00035 //======================================================================================================================== 00036 FESupervisor::~FESupervisor(void) 00037 { 00038 __SUP_COUT__ << "Destroying..." << __E__; 00039 // theStateMachineImplementation_ is reset and the object it points to deleted in 00040 // ~CoreSupervisorBase() 00041 __SUP_COUT__ << "Destructed." << __E__; 00042 } // end destructor 00043 00044 //======================================================================================================================== 00045 xoap::MessageReference FESupervisor::frontEndCommunicationRequest( 00046 xoap::MessageReference message) try 00047 { 00048 __SUP_COUT__ << "FE Request received: " << SOAPUtilities::translate(message) << __E__; 00049 00050 if(!theFEInterfacesManager_) 00051 { 00052 __SUP_SS__ << "No FE Interface Manager!" << __E__; 00053 __SUP_SS_THROW__; 00054 } 00055 SOAPParameters typeParameter, rxParameters; // params for xoap to recv 00056 typeParameter.addParameter("type"); 00057 SOAPUtilities::receive(message, typeParameter); 00058 00059 std::string type = typeParameter.getValue("type"); 00060 00061 // types 00062 // feSend 00063 // feMacro 00064 // feMacroMultiDimensionalStart 00065 // macroMultiDimensionalStart 00066 // feMacroMultiDimensionalCheck 00067 // macroMultiDimensionalCheck 00068 00069 rxParameters.addParameter("requester"); 00070 rxParameters.addParameter("targetInterfaceID"); 00071 00072 if(type == "feSend") 00073 { 00074 __SUP_COUTV__(type); 00075 00076 rxParameters.addParameter("value"); 00077 SOAPUtilities::receive(message, rxParameters); 00078 00079 std::string requester = rxParameters.getValue("requester"); 00080 std::string targetInterfaceID = rxParameters.getValue("targetInterfaceID"); 00081 std::string value = rxParameters.getValue("value"); 00082 00083 __SUP_COUTV__(requester); 00084 __SUP_COUTV__(targetInterfaceID); 00085 __SUP_COUTV__(value); 00086 00087 // test that the interface exists 00088 theFEInterfacesManager_->getFEInterface(targetInterfaceID); 00089 00090 // mutex scope 00091 { 00092 std::lock_guard<std::mutex> lock( 00093 theFEInterfacesManager_->frontEndCommunicationReceiveMutex_); 00094 00095 theFEInterfacesManager_ 00096 ->frontEndCommunicationReceiveBuffer_[targetInterfaceID][requester] 00097 .emplace(value); 00098 00099 __SUP_COUT__ << "Number of target interface ID '" << targetInterfaceID 00100 << "' buffers: " 00101 << theFEInterfacesManager_ 00102 ->frontEndCommunicationReceiveBuffer_[targetInterfaceID] 00103 .size() 00104 << __E__; 00105 __SUP_COUT__ 00106 << "Number of source interface ID '" << requester << "' values received: " 00107 << theFEInterfacesManager_ 00108 ->frontEndCommunicationReceiveBuffer_[targetInterfaceID][requester] 00109 .size() 00110 << __E__; 00111 } 00112 return SOAPUtilities::makeSOAPMessageReference("Received"); 00113 } // end type feSend 00114 else if(type == "feMacro") 00115 { 00116 __SUP_COUTV__(type); 00117 00118 rxParameters.addParameter("feMacroName"); 00119 rxParameters.addParameter("inputArgs"); 00120 00121 SOAPUtilities::receive(message, rxParameters); 00122 00123 std::string requester = rxParameters.getValue("requester"); 00124 std::string targetInterfaceID = rxParameters.getValue("targetInterfaceID"); 00125 std::string feMacroName = rxParameters.getValue("feMacroName"); 00126 std::string inputArgs = rxParameters.getValue("inputArgs"); 00127 00128 __SUP_COUTV__(requester); 00129 __SUP_COUTV__(targetInterfaceID); 00130 __SUP_COUTV__(feMacroName); 00131 __SUP_COUTV__(inputArgs); 00132 00133 std::string outputArgs; 00134 try 00135 { 00136 theFEInterfacesManager_->runFEMacroByFE( 00137 requester, targetInterfaceID, feMacroName, inputArgs, outputArgs); 00138 } 00139 catch(std::runtime_error& e) 00140 { 00141 __SUP_SS__ << "In Supervisor with LID=" 00142 << getApplicationDescriptor()->getLocalId() 00143 << " the FE Macro named '" << feMacroName << "' with target FE '" 00144 << targetInterfaceID << "' failed. Here is the error:\n\n" 00145 << e.what() << __E__; 00146 __SUP_SS_THROW__; 00147 } 00148 catch(...) 00149 { 00150 __SUP_SS__ << "In Supervisor with LID=" 00151 << getApplicationDescriptor()->getLocalId() 00152 << " the FE Macro named '" << feMacroName << "' with target FE '" 00153 << targetInterfaceID << "' failed due to an unknown error." 00154 << __E__; 00155 __SUP_SS_THROW__; 00156 } 00157 00158 __SUP_COUTV__(outputArgs); 00159 00160 xoap::MessageReference replyMessage = 00161 SOAPUtilities::makeSOAPMessageReference("feMacrosResponse"); 00162 SOAPParameters txParameters; 00163 txParameters.addParameter("requester", requester); 00164 txParameters.addParameter("targetInterfaceID", targetInterfaceID); 00165 txParameters.addParameter("feMacroName", feMacroName); 00166 txParameters.addParameter("outputArgs", outputArgs); 00167 SOAPUtilities::addParameters(replyMessage, txParameters); 00168 00169 __SUP_COUT__ << "Sending FE macro result: " 00170 << SOAPUtilities::translate(replyMessage) << __E__; 00171 00172 return replyMessage; 00173 } // end type feMacro 00174 else if(type == "feMacroMultiDimensionalStart" || // from iterator 00175 type == "macroMultiDimensionalStart") // from iterator 00176 { 00177 __SUP_COUTV__(type); 00178 00179 if(type[0] == 'm') 00180 { 00181 rxParameters.addParameter("macroString"); 00182 rxParameters.addParameter("macroName"); 00183 } 00184 else 00185 rxParameters.addParameter("feMacroName"); 00186 00187 rxParameters.addParameter("enableSavingOutput"); 00188 rxParameters.addParameter("outputFilePath"); 00189 rxParameters.addParameter("outputFileRadix"); 00190 rxParameters.addParameter("inputArgs"); 00191 00192 SOAPUtilities::receive(message, rxParameters); 00193 00194 std::string requester = rxParameters.getValue("requester"); 00195 std::string targetInterfaceID = rxParameters.getValue("targetInterfaceID"); 00196 std::string macroName, macroString; 00197 if(type[0] == 'm') 00198 { 00199 macroName = rxParameters.getValue("macroName"); 00200 macroString = rxParameters.getValue("macroString"); 00201 __SUP_COUTV__(macroString); 00202 } 00203 else 00204 macroName = rxParameters.getValue("feMacroName"); 00205 bool enableSavingOutput = rxParameters.getValue("enableSavingOutput") == "1"; 00206 std::string outputFilePath = rxParameters.getValue("outputFilePath"); 00207 std::string outputFileRadix = rxParameters.getValue("outputFileRadix"); 00208 std::string inputArgs = rxParameters.getValue("inputArgs"); 00209 00210 __SUP_COUTV__(requester); 00211 __SUP_COUTV__(targetInterfaceID); 00212 __SUP_COUTV__(macroName); 00213 __SUP_COUTV__(enableSavingOutput); 00214 __SUP_COUTV__(outputFilePath); 00215 __SUP_COUTV__(outputFileRadix); 00216 __SUP_COUTV__(inputArgs); 00217 00218 if(type[0] == 'm') // start Macro 00219 { 00220 try 00221 { 00222 theFEInterfacesManager_->startMacroMultiDimensional(requester, 00223 targetInterfaceID, 00224 macroName, 00225 macroString, 00226 enableSavingOutput, 00227 outputFilePath, 00228 outputFileRadix, 00229 inputArgs); 00230 } 00231 catch(std::runtime_error& e) 00232 { 00233 __SUP_SS__ << "In Supervisor with LID=" 00234 << getApplicationDescriptor()->getLocalId() 00235 << " the Macro named '" << macroName << "' with target FE '" 00236 << targetInterfaceID 00237 << "' failed to start multi-dimensional launch. " 00238 << "Here is the error:\n\n" 00239 << e.what() << __E__; 00240 __SUP_SS_THROW__; 00241 } 00242 catch(...) 00243 { 00244 __SUP_SS__ << "In Supervisor with LID=" 00245 << getApplicationDescriptor()->getLocalId() 00246 << " the Macro named '" << macroName << "' with target FE '" 00247 << targetInterfaceID 00248 << "' failed to start multi-dimensional launch " 00249 << "due to an unknown error." << __E__; 00250 __SUP_SS_THROW__; 00251 } 00252 } 00253 else // start FE Macro 00254 { 00255 try 00256 { 00257 theFEInterfacesManager_->startFEMacroMultiDimensional(requester, 00258 targetInterfaceID, 00259 macroName, 00260 enableSavingOutput, 00261 outputFilePath, 00262 outputFileRadix, 00263 inputArgs); 00264 } 00265 catch(std::runtime_error& e) 00266 { 00267 __SUP_SS__ << "In Supervisor with LID=" 00268 << getApplicationDescriptor()->getLocalId() 00269 << " the FE Macro named '" << macroName << "' with target FE '" 00270 << targetInterfaceID 00271 << "' failed to start multi-dimensional launch. " 00272 << "Here is the error:\n\n" 00273 << e.what() << __E__; 00274 __SUP_SS_THROW__; 00275 } 00276 catch(...) 00277 { 00278 __SUP_SS__ << "In Supervisor with LID=" 00279 << getApplicationDescriptor()->getLocalId() 00280 << " the FE Macro named '" << macroName << "' with target FE '" 00281 << targetInterfaceID 00282 << "' failed to start multi-dimensional launch " 00283 << "due to an unknown error." << __E__; 00284 __SUP_SS_THROW__; 00285 } 00286 } 00287 00288 xoap::MessageReference replyMessage = 00289 SOAPUtilities::makeSOAPMessageReference(type + "Done"); 00290 SOAPParameters txParameters; 00291 // txParameters.addParameter("started", "1"); 00292 SOAPUtilities::addParameters(replyMessage, txParameters); 00293 00294 __SUP_COUT__ << "Sending FE macro result: " 00295 << SOAPUtilities::translate(replyMessage) << __E__; 00296 00297 return replyMessage; 00298 } // end type (fe)MacroMultiDimensionalStart 00299 else if(type == "feMacroMultiDimensionalCheck" || // from iterator 00300 type == "macroMultiDimensionalCheck") 00301 { 00302 __SUP_COUTV__(type); 00303 if(type[0] == 'm') 00304 rxParameters.addParameter("macroName"); 00305 else 00306 rxParameters.addParameter("feMacroName"); 00307 rxParameters.addParameter("targetInterfaceID"); 00308 00309 SOAPUtilities::receive(message, rxParameters); 00310 00311 std::string targetInterfaceID = rxParameters.getValue("targetInterfaceID"); 00312 std::string macroName; 00313 if(type[0] == 'm') 00314 macroName = rxParameters.getValue("macroName"); 00315 else 00316 macroName = rxParameters.getValue("feMacroName"); 00317 00318 __SUP_COUTV__(targetInterfaceID); 00319 __SUP_COUTV__(macroName); 00320 00321 bool done = false; 00322 try 00323 { 00324 done = theFEInterfacesManager_->checkMacroMultiDimensional(targetInterfaceID, 00325 macroName); 00326 } 00327 catch(std::runtime_error& e) 00328 { 00329 __SUP_SS__ << "In Supervisor with LID=" 00330 << getApplicationDescriptor()->getLocalId() 00331 << " the FE Macro named '" << macroName << "' with target FE '" 00332 << targetInterfaceID 00333 << "' failed to check multi-dimensional launch. " 00334 << "Here is the error:\n\n" 00335 << e.what() << __E__; 00336 __SUP_SS_THROW__; 00337 } 00338 catch(...) 00339 { 00340 __SUP_SS__ << "In Supervisor with LID=" 00341 << getApplicationDescriptor()->getLocalId() 00342 << " the FE Macro named '" << macroName << "' with target FE '" 00343 << targetInterfaceID 00344 << "' failed to check multi-dimensional launch " 00345 << "due to an unknown error." << __E__; 00346 __SUP_SS_THROW__; 00347 } 00348 00349 xoap::MessageReference replyMessage = 00350 SOAPUtilities::makeSOAPMessageReference(type + "Done"); 00351 SOAPParameters txParameters; 00352 txParameters.addParameter("Done", done ? "1" : "0"); 00353 SOAPUtilities::addParameters(replyMessage, txParameters); 00354 00355 __SUP_COUT__ << "Sending FE macro result: " 00356 << SOAPUtilities::translate(replyMessage) << __E__; 00357 00358 return replyMessage; 00359 } // end type (fe)MacroMultiDimensionalCheck 00360 else 00361 { 00362 __SUP_SS__ << "Unrecognized FE Communication type: " << type << __E__; 00363 __SUP_SS_THROW__; 00364 } 00365 } 00366 catch(const std::runtime_error& e) 00367 { 00368 __SUP_SS__ << "Error encountered processing FE communication request: " << e.what() 00369 << __E__; 00370 __SUP_COUT_ERR__ << ss.str(); 00371 00372 SOAPParameters parameters; 00373 parameters.addParameter("Error", ss.str()); 00374 return SOAPUtilities::makeSOAPMessageReference( 00375 supervisorClassNoNamespace_ + "FailFECommunicationRequest", parameters); 00376 } 00377 catch(...) 00378 { 00379 __SUP_SS__ << "Unknown error encountered processing FE communication request." 00380 << __E__; 00381 __SUP_COUT_ERR__ << ss.str(); 00382 00383 SOAPParameters parameters; 00384 parameters.addParameter("Error", ss.str()); 00385 return SOAPUtilities::makeSOAPMessageReference( 00386 supervisorClassNoNamespace_ + "FailFECommunicationRequest", parameters); 00387 } // end frontEndCommunicationRequest() 00388 00389 //======================================================================================================================== 00390 // macroMakerSupervisorRequest 00391 // Handles all MacroMaker Requests: 00392 // - GetInterfaces (returns interface type and id) 00393 // 00394 // Note: this code assumes a CoreSupervisorBase has only one 00395 // FEVInterfacesManager in its vector of state machines 00396 xoap::MessageReference FESupervisor::macroMakerSupervisorRequest( 00397 xoap::MessageReference message) 00398 { 00399 __SUP_COUT__ << "$$$$$$$$$$$$$$$$$" << __E__; 00400 00401 // receive request parameters 00402 SOAPParameters parameters; 00403 parameters.addParameter("Request"); 00404 00405 __SUP_COUT__ << "Received Macro Maker message: " << SOAPUtilities::translate(message) 00406 << __E__; 00407 00408 SOAPUtilities::receive(message, parameters); 00409 std::string request = parameters.getValue("Request"); 00410 00411 __SUP_COUT__ << "request: " << request << __E__; 00412 00413 // request types: 00414 // GetInterfaces 00415 // UniversalWrite 00416 // UniversalRead 00417 // GetInterfaceMacros 00418 // RunInterfaceMacro 00419 // RunMacroMakerMacro 00420 00421 SOAPParameters retParameters; 00422 00423 try 00424 { 00425 if(request == "GetInterfaces") 00426 { 00427 if(theFEInterfacesManager_) 00428 retParameters.addParameter( 00429 "FEList", 00430 theFEInterfacesManager_->getFEListString( 00431 std::to_string(getApplicationDescriptor()->getLocalId()))); 00432 else // if no FE interfaces, return empty string 00433 retParameters.addParameter("FEList", ""); 00434 00435 return SOAPUtilities::makeSOAPMessageReference( 00436 supervisorClassNoNamespace_ + "Response", retParameters); 00437 } 00438 else if(request == "UniversalWrite") 00439 { 00440 if(!theFEInterfacesManager_) 00441 { 00442 __SUP_SS__ << "No FE Interface Manager! Are you configured?" << __E__; 00443 __SUP_SS_THROW__; 00444 } 00445 // params for running macros 00446 SOAPParameters requestParameters; 00447 requestParameters.addParameter("InterfaceID"); 00448 requestParameters.addParameter("Address"); 00449 requestParameters.addParameter("Data"); 00450 SOAPUtilities::receive(message, requestParameters); 00451 std::string interfaceID = requestParameters.getValue("InterfaceID"); 00452 std::string addressStr = requestParameters.getValue("Address"); 00453 std::string dataStr = requestParameters.getValue("Data"); 00454 00455 __SUP_COUT__ << "Address: " << addressStr << " Data: " << dataStr 00456 << " InterfaceID: " << interfaceID << __E__; 00457 00458 // parameters interface index! 00459 // unsigned int index = stoi(indexStr); // As long as the supervisor has only 00460 // one interface, this index will remain 0? 00461 00462 __SUP_COUT__ 00463 << "theFEInterfacesManager_->getInterfaceUniversalAddressSize(index) " 00464 << theFEInterfacesManager_->getInterfaceUniversalAddressSize(interfaceID) 00465 << __E__; 00466 __SUP_COUT__ 00467 << "theFEInterfacesManager_->getInterfaceUniversalDataSize(index) " 00468 << theFEInterfacesManager_->getInterfaceUniversalDataSize(interfaceID) 00469 << __E__; 00470 00471 // Converting std::string to char* 00472 // char address 00473 00474 char tmpHex[3]; // for use converting hex to binary 00475 tmpHex[2] = '\0'; 00476 00477 __SUP_COUT__ << "Translating address: "; 00478 00479 std::string addressTmp; 00480 addressTmp.reserve( 00481 theFEInterfacesManager_->getInterfaceUniversalAddressSize(interfaceID)); 00482 char* address = &addressTmp[0]; 00483 00484 if(addressStr.size() % 2) // if odd, make even 00485 addressStr = "0" + addressStr; 00486 unsigned int i = 0; 00487 for(; i < addressStr.size() && 00488 i / 2 < theFEInterfacesManager_->getInterfaceUniversalAddressSize( 00489 interfaceID); 00490 i += 2) 00491 { 00492 tmpHex[0] = addressStr[addressStr.size() - 1 - i - 1]; 00493 tmpHex[1] = addressStr[addressStr.size() - 1 - i]; 00494 sscanf(tmpHex, "%hhX", (unsigned char*)&address[i / 2]); 00495 printf("%2.2X", (unsigned char)address[i / 2]); 00496 } 00497 // finish and fill with 0s 00498 for(; i / 2 < 00499 theFEInterfacesManager_->getInterfaceUniversalAddressSize(interfaceID); 00500 i += 2) 00501 { 00502 address[i / 2] = 0; 00503 printf("%2.2X", (unsigned char)address[i / 2]); 00504 } 00505 00506 std::cout << __E__; 00507 00508 __SUP_COUT__ << "Translating data: "; 00509 00510 std::string dataTmp; 00511 dataTmp.reserve( 00512 theFEInterfacesManager_->getInterfaceUniversalDataSize(interfaceID)); 00513 char* data = &dataTmp[0]; 00514 00515 if(dataStr.size() % 2) // if odd, make even 00516 dataStr = "0" + dataStr; 00517 00518 i = 0; 00519 for(; i < dataStr.size() && 00520 i / 2 < 00521 theFEInterfacesManager_->getInterfaceUniversalDataSize(interfaceID); 00522 i += 2) 00523 { 00524 tmpHex[0] = dataStr[dataStr.size() - 1 - i - 1]; 00525 tmpHex[1] = dataStr[dataStr.size() - 1 - i]; 00526 sscanf(tmpHex, "%hhX", (unsigned char*)&data[i / 2]); 00527 printf("%2.2X", (unsigned char)data[i / 2]); 00528 } 00529 // finish and fill with 0s 00530 for(; i / 2 < 00531 theFEInterfacesManager_->getInterfaceUniversalDataSize(interfaceID); 00532 i += 2) 00533 { 00534 data[i / 2] = 0; 00535 printf("%2.2X", (unsigned char)data[i / 2]); 00536 } 00537 00538 std::cout << __E__; 00539 00540 // char* address = new char[addressStr.size() + 1]; 00541 // std::copy(addressStr.begin(), addressStr.end(), address); 00542 // address[addressStr.size()] = '\0'; 00543 // char* data = new char[dataStr.size() + 1]; 00544 // std::copy(dataStr.begin(), dataStr.end(), data); 00545 // data[dataStr.size()] = '\0'; 00546 00547 theFEInterfacesManager_->universalWrite(interfaceID, address, data); 00548 00549 // delete[] address; 00550 // delete[] data; 00551 00552 return SOAPUtilities::makeSOAPMessageReference( 00553 supervisorClassNoNamespace_ + "DataWritten", retParameters); 00554 } 00555 else if(request == "UniversalRead") 00556 { 00557 if(!theFEInterfacesManager_) 00558 { 00559 __SUP_SS__ << "No FE Interface Manager! Are you configured?" << __E__; 00560 __SUP_SS_THROW__; 00561 } 00562 00563 // params for running macros 00564 SOAPParameters requestParameters; 00565 requestParameters.addParameter("InterfaceID"); 00566 requestParameters.addParameter("Address"); 00567 SOAPUtilities::receive(message, requestParameters); 00568 std::string interfaceID = requestParameters.getValue("InterfaceID"); 00569 std::string addressStr = requestParameters.getValue("Address"); 00570 00571 __SUP_COUT__ << "Address: " << addressStr << " InterfaceID: " << interfaceID 00572 << __E__; 00573 00574 // parameters interface index! 00575 // parameter address and data 00576 // unsigned int index = stoi(indexStr); // As long as the supervisor has only 00577 // one interface, this index will remain 0? 00578 00579 __SUP_COUT__ 00580 << "theFEInterfacesManager_->getInterfaceUniversalAddressSize(index) " 00581 << theFEInterfacesManager_->getInterfaceUniversalAddressSize(interfaceID) 00582 << __E__; 00583 __SUP_COUT__ 00584 << "theFEInterfacesManager_->getInterfaceUniversalDataSize(index) " 00585 << theFEInterfacesManager_->getInterfaceUniversalDataSize(interfaceID) 00586 << __E__; 00587 00588 char tmpHex[3]; // for use converting hex to binary 00589 tmpHex[2] = '\0'; 00590 00591 __SUP_COUT__ << "Translating address: "; 00592 00593 std::string addressTmp; 00594 addressTmp.reserve( 00595 theFEInterfacesManager_->getInterfaceUniversalAddressSize(interfaceID)); 00596 char* address = &addressTmp[0]; 00597 00598 if(addressStr.size() % 2) // if odd, make even 00599 addressStr = "0" + addressStr; 00600 00601 unsigned int i = 0; 00602 for(; i < addressStr.size() && 00603 i / 2 < theFEInterfacesManager_->getInterfaceUniversalAddressSize( 00604 interfaceID); 00605 i += 2) 00606 { 00607 tmpHex[0] = addressStr[addressStr.size() - 1 - i - 1]; 00608 tmpHex[1] = addressStr[addressStr.size() - 1 - i]; 00609 sscanf(tmpHex, "%hhX", (unsigned char*)&address[i / 2]); 00610 printf("%2.2X", (unsigned char)address[i / 2]); 00611 } 00612 // finish and fill with 0s 00613 for(; i / 2 < 00614 theFEInterfacesManager_->getInterfaceUniversalAddressSize(interfaceID); 00615 i += 2) 00616 { 00617 address[i / 2] = 0; 00618 printf("%2.2X", (unsigned char)address[i / 2]); 00619 } 00620 00621 std::cout << __E__; 00622 00623 unsigned int dataSz = 00624 theFEInterfacesManager_->getInterfaceUniversalDataSize(interfaceID); 00625 std::string dataStr; 00626 dataStr.resize(dataSz); 00627 char* data = &dataStr[0]; 00628 00629 // std::string result = 00630 // theFEInterfacesManager_->universalRead(index,address,data); 00631 // __SUP_COUT__<< result << __E__ << __E__; 00632 00633 try 00634 { 00635 theFEInterfacesManager_->universalRead(interfaceID, address, data); 00636 } 00637 catch(const std::runtime_error& e) 00638 { 00639 // do not allow read exception to crash everything when a macromaker 00640 // command 00641 __MOUT_ERR__ << "Exception caught during read: " << e.what() << __E__; 00642 __SUP_COUT_ERR__ << "Exception caught during read: " << e.what() << __E__; 00643 retParameters.addParameter("dataResult", "Time Out Error"); 00644 return SOAPUtilities::makeSOAPMessageReference( 00645 supervisorClassNoNamespace_ + "aa", retParameters); 00646 } 00647 catch(...) 00648 { 00649 // do not allow read exception to crash everything when a macromaker 00650 // command 00651 __MOUT_ERR__ << "Exception caught during read." << __E__; 00652 __SUP_COUT_ERR__ << "Exception caught during read." << __E__; 00653 retParameters.addParameter("dataResult", "Time Out Error"); 00654 return SOAPUtilities::makeSOAPMessageReference( 00655 supervisorClassNoNamespace_ + "aa", retParameters); 00656 } 00657 00658 // if dataSz is less than 8 show what the unsigned number would be 00659 if(dataSz <= 8) 00660 { 00661 std::string str8(data); 00662 str8.resize(8); 00663 __SUP_COUT__ << "decResult[" << dataSz 00664 << " bytes]: " << *((unsigned long long*)(&str8[0])) 00665 << __E__; 00666 } 00667 00668 std::string hexResultStr; 00669 hexResultStr.reserve(dataSz * 2 + 1); 00670 char* hexResult = &hexResultStr[0]; 00671 // go through each byte and convert it to hex value (i.e. 2 0-F chars) 00672 // go backwards through source data since should be provided in host order 00673 // (i.e. a cast to unsigned long long should acquire expected value) 00674 for(unsigned int i = 0; i < dataSz; ++i) 00675 { 00676 sprintf(&hexResult[i * 2], "%2.2X", (unsigned char)data[dataSz - 1 - i]); 00677 } 00678 00679 __SUP_COUT__ << "hexResult[" << strlen(hexResult) 00680 << " nibbles]: " << std::string(hexResult) << __E__; 00681 00682 retParameters.addParameter("dataResult", hexResult); 00683 return SOAPUtilities::makeSOAPMessageReference( 00684 supervisorClassNoNamespace_ + "aa", retParameters); 00685 } 00686 else if(request == "GetInterfaceMacros") 00687 { 00688 if(theFEInterfacesManager_) 00689 retParameters.addParameter( 00690 "FEMacros", 00691 theFEInterfacesManager_->getFEMacrosString( 00692 CorePropertySupervisorBase::getSupervisorUID(), 00693 std::to_string( 00694 CoreSupervisorBase::getSupervisorLID()))); 00695 else 00696 retParameters.addParameter("FEMacros", ""); 00697 00698 return SOAPUtilities::makeSOAPMessageReference( 00699 supervisorClassNoNamespace_ + "Response", retParameters); 00700 } 00701 else if(request == "RunInterfaceMacro") 00702 { 00703 if(!theFEInterfacesManager_) 00704 { 00705 __SUP_SS__ << "Missing FE Interface Manager! Are you configured?" 00706 << __E__; 00707 __SUP_SS_THROW__; 00708 } 00709 00710 // params for running macros 00711 SOAPParameters requestParameters; 00712 requestParameters.addParameter("feMacroName"); 00713 requestParameters.addParameter("inputArgs"); 00714 requestParameters.addParameter("outputArgs"); 00715 requestParameters.addParameter("InterfaceID"); 00716 SOAPUtilities::receive(message, requestParameters); 00717 std::string interfaceID = requestParameters.getValue("InterfaceID"); 00718 std::string feMacroName = requestParameters.getValue("feMacroName"); 00719 std::string inputArgs = requestParameters.getValue("inputArgs"); 00720 std::string outputArgs = requestParameters.getValue("outputArgs"); 00721 00722 // outputArgs must be filled with the proper argument names 00723 // and then the response output values will be returned in the string. 00724 try 00725 { 00726 theFEInterfacesManager_->runFEMacro( 00727 interfaceID, feMacroName, inputArgs, outputArgs); 00728 } 00729 catch(std::runtime_error& e) 00730 { 00731 __SUP_SS__ << "In Supervisor with LID=" 00732 << getApplicationDescriptor()->getLocalId() 00733 << " the FE Macro named '" << feMacroName 00734 << "' with target FE '" << interfaceID 00735 << "' failed. Here is the error:\n\n" 00736 << e.what() << __E__; 00737 __SUP_SS_THROW__; 00738 } 00739 catch(...) 00740 { 00741 __SUP_SS__ << "In Supervisor with LID=" 00742 << getApplicationDescriptor()->getLocalId() 00743 << " the FE Macro named '" << feMacroName 00744 << "' with target FE '" << interfaceID 00745 << "' failed due to an unknown error." << __E__; 00746 __SUP_SS_THROW__; 00747 } 00748 00749 // retParameters.addParameter("success", success ? "1" : "0"); 00750 retParameters.addParameter("outputArgs", outputArgs); 00751 00752 return SOAPUtilities::makeSOAPMessageReference( 00753 supervisorClassNoNamespace_ + "Response", retParameters); 00754 } 00755 else if(request == "RunMacroMakerMacro") 00756 { 00757 if(!theFEInterfacesManager_) 00758 { 00759 __SUP_SS__ << "Missing FE Interface Manager! Are you configured?" 00760 << __E__; 00761 __SUP_SS_THROW__; 00762 } 00763 00764 // params for running macros 00765 SOAPParameters requestParameters; 00766 requestParameters.addParameter("macroName"); 00767 requestParameters.addParameter("macroString"); 00768 requestParameters.addParameter("inputArgs"); 00769 requestParameters.addParameter("outputArgs"); 00770 requestParameters.addParameter("InterfaceID"); 00771 SOAPUtilities::receive(message, requestParameters); 00772 std::string interfaceID = requestParameters.getValue("InterfaceID"); 00773 std::string macroName = requestParameters.getValue("macroName"); 00774 std::string macroString = requestParameters.getValue("macroString"); 00775 std::string inputArgs = requestParameters.getValue("inputArgs"); 00776 std::string outputArgs = requestParameters.getValue("outputArgs"); 00777 00778 // outputArgs must be filled with the proper argument names 00779 // and then the response output values will be returned in the string. 00780 try 00781 { 00782 theFEInterfacesManager_->runMacro( 00783 interfaceID, macroString, inputArgs, outputArgs); 00784 } 00785 catch(std::runtime_error& e) 00786 { 00787 __SUP_SS__ << "In Supervisor with LID=" 00788 << getApplicationDescriptor()->getLocalId() 00789 << " the MacroMaker Macro named '" << macroName 00790 << "' with target FE '" << interfaceID 00791 << "' failed. Here is the error:\n\n" 00792 << e.what() << __E__; 00793 __SUP_SS_THROW__; 00794 } 00795 catch(...) 00796 { 00797 __SUP_SS__ << "In Supervisor with LID=" 00798 << getApplicationDescriptor()->getLocalId() 00799 << " the MacroMaker Macro named '" << macroName 00800 << "' with target FE '" << interfaceID 00801 << "' failed due to an unknown error." << __E__; 00802 __SUP_SS_THROW__; 00803 } 00804 00805 retParameters.addParameter("outputArgs", outputArgs); 00806 00807 return SOAPUtilities::makeSOAPMessageReference( 00808 supervisorClassNoNamespace_ + "Response", retParameters); 00809 } 00810 else 00811 { 00812 __SUP_SS__ << "Unrecognized request received! '" << request << "'" << __E__; 00813 __SUP_SS_THROW__; 00814 } 00815 } 00816 catch(const std::runtime_error& e) 00817 { 00818 __SUP_SS__ << "Error occurred handling request: " << e.what() << __E__; 00819 __SUP_COUT_ERR__ << ss.str(); 00820 retParameters.addParameter("Error", ss.str()); 00821 } 00822 catch(...) 00823 { 00824 __SUP_SS__ << "Error occurred handling request." << __E__; 00825 __SUP_COUT_ERR__ << ss.str(); 00826 retParameters.addParameter("Error", ss.str()); 00827 } 00828 00829 return SOAPUtilities::makeSOAPMessageReference( 00830 supervisorClassNoNamespace_ + "FailRequest", retParameters); 00831 00832 } // end macroMakerSupervisorRequest() 00833 00834 //======================================================================================================================== 00835 xoap::MessageReference FESupervisor::workLoopStatusRequest(xoap::MessageReference message) 00836 { 00837 if(!theFEInterfacesManager_) 00838 { 00839 __SUP_SS__ << "Invalid request for front-end workloop status from Supervisor " 00840 "without a FEVInterfacesManager." 00841 << __E__; 00842 __SUP_SS_THROW__; 00843 } 00844 00845 return SOAPUtilities::makeSOAPMessageReference( 00846 (theFEInterfacesManager_->allFEWorkloopsAreDone() 00847 ? CoreSupervisorBase::WORK_LOOP_DONE 00848 : CoreSupervisorBase::WORK_LOOP_WORKING)); 00849 } // end workLoopStatusRequest() 00850 00851 //======================================================================================================================== 00852 // extractFEInterfaceManager 00853 // 00854 // locates theFEInterfacesManager in state machines vector and 00855 // returns 0 if not found. 00856 // 00857 // Note: this code assumes a CoreSupervisorBase has only one 00858 // FEVInterfacesManager in its vector of state machines 00859 FEVInterfacesManager* FESupervisor::extractFEInterfacesManager() 00860 { 00861 theFEInterfacesManager_ = 0; 00862 00863 for(unsigned int i = 0; i < theStateMachineImplementation_.size(); ++i) 00864 { 00865 try 00866 { 00867 theFEInterfacesManager_ = 00868 dynamic_cast<FEVInterfacesManager*>(theStateMachineImplementation_[i]); 00869 if(!theFEInterfacesManager_) 00870 { 00871 // dynamic_cast returns null pointer on failure 00872 __SUP_SS__ << "Dynamic cast failure!" << __E__; 00873 __SUP_SS_THROW__; 00874 } 00875 __SUP_COUT__ << "State Machine " << i << " WAS of type FEVInterfacesManager" 00876 << __E__; 00877 00878 break; 00879 } 00880 catch(...) 00881 { 00882 __SUP_COUT__ << "State Machine " << i 00883 << " was NOT of type FEVInterfacesManager" << __E__; 00884 } 00885 } 00886 00887 __SUP_COUT__ << "theFEInterfacesManager pointer = " << theFEInterfacesManager_ 00888 << __E__; 00889 00890 return theFEInterfacesManager_; 00891 } // end extractFEInterfaceManager()