00001 #include "otsdaq-core/CoreSupervisors/FESupervisor.h"
00002 #include "otsdaq-core/FECore/FEVInterfacesManager.h"
00003 #include "otsdaq-core/ConfigurationInterface/ConfigurationManager.h"
00004 #include "otsdaq-core/FECore/FEVInterfacesManager.h"
00005
00006 using namespace ots;
00007
00008 XDAQ_INSTANTIATOR_IMPL(FESupervisor)
00009
00010
00011
00012
00013 FESupervisor::FESupervisor(xdaq::ApplicationStub * s)
00014 : CoreSupervisorBase(s)
00015
00016 {
00017 xoap::bind(this, &FESupervisor::macroMakerSupervisorRequest, "MacroMakerSupervisorRequest", XDAQ_NS_URI);
00018 xoap::bind(this, &FESupervisor::workLoopStatusRequest, "WorkLoopStatusRequest", XDAQ_NS_URI);
00019
00020 CoreSupervisorBase::theStateMachineImplementation_.push_back(
00021 new FEVInterfacesManager(
00022 CorePropertySupervisorBase::getContextTreeNode(),
00023 CorePropertySupervisorBase::supervisorConfigurationPath_
00024 )
00025 );
00026
00027 }
00028
00029
00030 FESupervisor::~FESupervisor(void)
00031 {
00032
00033 }
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043 xoap::MessageReference FESupervisor::macroMakerSupervisorRequest(
00044 xoap::MessageReference message)
00045
00046 {
00047 __COUT__ << "$$$$$$$$$$$$$$$$$" << std::endl;
00048
00049
00050 FEVInterfacesManager* theFEInterfacesManager = extractFEInterfaceManager();
00051
00052
00053 SOAPParameters parameters;
00054 parameters.addParameter("Request");
00055 parameters.addParameter("InterfaceID");
00056
00057
00058 parameters.addParameter("Address");
00059 parameters.addParameter("Data");
00060
00061
00062 parameters.addParameter("feMacroName");
00063 parameters.addParameter("inputArgs");
00064 parameters.addParameter("outputArgs");
00065
00066 SOAPMessenger::receive(message, parameters);
00067 std::string request = parameters.getValue("Request");
00068 std::string addressStr = parameters.getValue("Address");
00069 std::string dataStr = parameters.getValue("Data");
00070 std::string InterfaceID = parameters.getValue("InterfaceID");
00071
00072 __COUT__ << "request: " << request << std::endl;
00073
00074 __COUT__ << "Address: " << addressStr << " Data: "
00075 << dataStr << " InterfaceID: " << InterfaceID << std::endl;
00076
00077 SOAPParameters retParameters;
00078
00079 try
00080 {
00081 if (request == "GetInterfaces")
00082 {
00083 if (theFEInterfacesManager)
00084 retParameters.addParameter("FEList",
00085 theFEInterfacesManager->getFEListString(
00086 std::to_string(getApplicationDescriptor()->getLocalId())));
00087 else
00088 retParameters.addParameter("FEList", "");
00089
00090 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "Response",
00091 retParameters);
00092 }
00093 else if (request == "UniversalWrite")
00094 {
00095 if (!theFEInterfacesManager)
00096 {
00097 __COUT_INFO__ << "No FE Interface Manager! (So no write occurred)" << std::endl;
00098 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "DataWritten", retParameters);
00099 }
00100
00101
00102
00103
00104
00105
00106 __COUT__ << "theFEInterfacesManager->getInterfaceUniversalAddressSize(index) " <<
00107 theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID) << std::endl;
00108 __COUT__ << "theFEInterfacesManager->getInterfaceUniversalDataSize(index) " <<
00109 theFEInterfacesManager->getInterfaceUniversalDataSize(InterfaceID) << std::endl;
00110
00111
00112
00113
00114 char tmpHex[3];
00115 tmpHex[2] = '\0';
00116
00117
00118 __COUT__ << "Translating address: ";
00119
00120 std::string addressTmp; addressTmp.reserve(theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID));
00121 char* address = &addressTmp[0];
00122
00123 if (addressStr.size() % 2)
00124 addressStr = "0" + addressStr;
00125 unsigned int i = 0;
00126 for (; i < addressStr.size() &&
00127 i / 2 < theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID); i += 2)
00128 {
00129 tmpHex[0] = addressStr[addressStr.size() - 1 - i - 1];
00130 tmpHex[1] = addressStr[addressStr.size() - 1 - i];
00131 sscanf(tmpHex, "%hhX", (unsigned char*)&address[i / 2]);
00132 printf("%2.2X", (unsigned char)address[i / 2]);
00133 }
00134
00135 for (; i / 2 < theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID); i += 2)
00136 {
00137 address[i / 2] = 0;
00138 printf("%2.2X", (unsigned char)address[i / 2]);
00139 }
00140
00141 std::cout << std::endl;
00142
00143 __COUT__ << "Translating data: ";
00144
00145 std::string dataTmp; dataTmp.reserve(theFEInterfacesManager->getInterfaceUniversalDataSize(InterfaceID));
00146 char* data = &dataTmp[0];
00147
00148 if (dataStr.size() % 2)
00149 dataStr = "0" + dataStr;
00150
00151 i = 0;
00152 for (; i < dataStr.size() &&
00153 i / 2 < theFEInterfacesManager->getInterfaceUniversalDataSize(InterfaceID); i += 2)
00154 {
00155 tmpHex[0] = dataStr[dataStr.size() - 1 - i - 1];
00156 tmpHex[1] = dataStr[dataStr.size() - 1 - i];
00157 sscanf(tmpHex, "%hhX", (unsigned char*)&data[i / 2]);
00158 printf("%2.2X", (unsigned char)data[i / 2]);
00159 }
00160
00161 for (; i / 2 < theFEInterfacesManager->getInterfaceUniversalDataSize(InterfaceID); i += 2)
00162 {
00163 data[i / 2] = 0;
00164 printf("%2.2X", (unsigned char)data[i / 2]);
00165 }
00166
00167 std::cout << std::endl;
00168
00169
00170
00171
00172
00173
00174
00175
00176 theFEInterfacesManager->universalWrite(InterfaceID, address, data);
00177
00178
00179
00180
00181 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "DataWritten", retParameters);
00182 }
00183 else if (request == "UniversalRead")
00184 {
00185 if (!theFEInterfacesManager)
00186 {
00187 __COUT_INFO__ << "No FE Interface Manager! (So no read occurred)" << std::endl;
00188 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "aa", retParameters);
00189 }
00190
00191
00192
00193
00194
00195 __COUT__ << "theFEInterfacesManager->getInterfaceUniversalAddressSize(index) "
00196 << theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID) << std::endl;
00197 __COUT__ << "theFEInterfacesManager->getInterfaceUniversalDataSize(index) "
00198 << theFEInterfacesManager->getInterfaceUniversalDataSize(InterfaceID) << std::endl;
00199
00200 char tmpHex[3];
00201 tmpHex[2] = '\0';
00202
00203
00204 __COUT__ << "Translating address: ";
00205
00206 std::string addressTmp; addressTmp.reserve(theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID));
00207 char* address = &addressTmp[0];
00208
00209 if (addressStr.size() % 2)
00210 addressStr = "0" + addressStr;
00211
00212 unsigned int i = 0;
00213 for (; i < addressStr.size() &&
00214 i / 2 < theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID); i += 2)
00215 {
00216 tmpHex[0] = addressStr[addressStr.size() - 1 - i - 1];
00217 tmpHex[1] = addressStr[addressStr.size() - 1 - i];
00218 sscanf(tmpHex, "%hhX", (unsigned char*)&address[i / 2]);
00219 printf("%2.2X", (unsigned char)address[i / 2]);
00220 }
00221
00222 for (; i / 2 < theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID); i += 2)
00223 {
00224 address[i / 2] = 0;
00225 printf("%2.2X", (unsigned char)address[i / 2]);
00226 }
00227
00228 std::cout << std::endl;
00229
00230 unsigned int dataSz = theFEInterfacesManager->getInterfaceUniversalDataSize(InterfaceID);
00231 std::string dataStr; dataStr.resize(dataSz);
00232 char* data = &dataStr[0];
00233
00234
00235
00236
00237
00238 try
00239 {
00240 if (theFEInterfacesManager->universalRead(InterfaceID, address, data) < 0)
00241 {
00242 retParameters.addParameter("dataResult", "Time Out Error");
00243 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "aa", retParameters);
00244 }
00245 }
00246 catch (const std::runtime_error& e)
00247 {
00248
00249 __MOUT_ERR__ << "Exception caught during read: " << e.what() << std::endl;
00250 __COUT_ERR__ << "Exception caught during read: " << e.what() << std::endl;
00251 retParameters.addParameter("dataResult", "Time Out Error");
00252 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "aa", retParameters);
00253 }
00254 catch (...)
00255 {
00256
00257 __MOUT_ERR__ << "Exception caught during read." << std::endl;
00258 __COUT_ERR__ << "Exception caught during read." << std::endl;
00259 retParameters.addParameter("dataResult", "Time Out Error");
00260 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "aa", retParameters);
00261 }
00262
00263
00264 if (dataSz <= 8)
00265 {
00266 std::string str8(data);
00267 str8.resize(8);
00268 __COUT__ << "decResult[" << dataSz << " bytes]: " <<
00269 *((unsigned long long *)(&str8[0])) << std::endl;
00270
00271 }
00272
00273 std::string hexResultStr;
00274 hexResultStr.reserve(dataSz * 2 + 1);
00275 char* hexResult = &hexResultStr[0];
00276
00277
00278
00279 for (unsigned int i = 0; i < dataSz; ++i)
00280 {
00281 sprintf(&hexResult[i * 2], "%2.2X", (unsigned char)data[dataSz - 1 - i]);
00282 }
00283
00284 __COUT__ << "hexResult[" << strlen(hexResult) << " nibbles]: " << std::string(hexResult) << std::endl;
00285
00286
00287
00288 retParameters.addParameter("dataResult", hexResult);
00289 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "aa", retParameters);
00290
00291 }
00292 else if (request == "GetInterfaceMacros")
00293 {
00294 if (theFEInterfacesManager)
00295 retParameters.addParameter("FEMacros", theFEInterfacesManager->getFEMacrosString(
00296 std::to_string(getApplicationDescriptor()->getLocalId())));
00297 else
00298 retParameters.addParameter("FEMacros", "");
00299
00300 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "Response",
00301 retParameters);
00302 }
00303 else if (request == "RunInterfaceMacro")
00304 {
00305 if (!theFEInterfacesManager)
00306 {
00307 retParameters.addParameter("success", "0");
00308 retParameters.addParameter("outputArgs", "");
00309 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "Response",
00310 retParameters);
00311 }
00312
00313 std::string feMacroName = parameters.getValue("feMacroName");
00314 std::string inputArgs = parameters.getValue("inputArgs");
00315 std::string outputArgs = parameters.getValue("outputArgs");
00316
00317
00318
00319 bool success = true;
00320 try
00321 {
00322 theFEInterfacesManager->runFEMacro(InterfaceID, feMacroName, inputArgs, outputArgs);
00323 }
00324 catch (std::runtime_error &e)
00325 {
00326 __SS__ << "In Supervisor with LID=" << getApplicationDescriptor()->getLocalId()
00327 << " the FE Macro named '" << feMacroName << "' with tartget FE '"
00328 << InterfaceID << "' failed. Here is the error:\n\n" << e.what() << std::endl;
00329 __COUT_ERR__ << "\n" << ss.str();
00330 success = false;
00331 outputArgs = ss.str();
00332 }
00333
00334
00335 retParameters.addParameter("success", success ? "1" : "0");
00336 retParameters.addParameter("outputArgs", outputArgs);
00337
00338 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "Response",
00339 retParameters);
00340 }
00341 else
00342 {
00343 __COUT_WARN__ << "Unrecognized request received! '" << request << "'" << std::endl;
00344 }
00345 }
00346 catch (const std::runtime_error& e)
00347 {
00348 __SS__ << "Error occurred handling request: " << e.what() << __E__;
00349 __COUT_ERR__ << ss.str();
00350 }
00351 catch (...)
00352 {
00353 __SS__ << "Error occurred handling request." << __E__;
00354 __COUT_ERR__ << ss.str();
00355 }
00356
00357
00358
00359 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "FailRequest", retParameters);
00360
00361 }
00362
00363
00364
00365 xoap::MessageReference FESupervisor::workLoopStatusRequest(xoap::MessageReference message)
00366
00367 {
00368
00369 FEVInterfacesManager* theFEInterfacesManager = extractFEInterfaceManager();
00370
00371 if (!theFEInterfacesManager)
00372 {
00373 __SS__ << "Invalid request for front-end workloop status from Supervisor without a FEVInterfacesManager."
00374 << std::endl;
00375 __COUT_ERR__ << ss.str();
00376 throw std::runtime_error(ss.str());
00377 }
00378
00379 return SOAPUtilities::makeSOAPMessageReference(
00380 (theFEInterfacesManager->allFEWorkloopsAreDone() ?
00381 CoreSupervisorBase::WORK_LOOP_DONE :
00382 CoreSupervisorBase::WORK_LOOP_WORKING));
00383 }
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393 FEVInterfacesManager* FESupervisor::extractFEInterfaceManager()
00394 {
00395 FEVInterfacesManager* theFEInterfacesManager = 0;
00396
00397 for (unsigned int i = 0; i < theStateMachineImplementation_.size(); ++i)
00398 {
00399 try
00400 {
00401 theFEInterfacesManager =
00402 dynamic_cast<FEVInterfacesManager*>(theStateMachineImplementation_[i]);
00403 if (!theFEInterfacesManager)
00404 {
00405
00406 __SS__ << "Dynamic cast failure!" << std::endl;
00407 __COUT_ERR__ << ss.str();
00408 throw std::runtime_error(ss.str());
00409 }
00410 __COUT__ << "State Machine " << i << " WAS of type FEVInterfacesManager" << std::endl;
00411
00412 break;
00413 }
00414 catch (...)
00415 {
00416 __COUT__ << "State Machine " << i << " was NOT of type FEVInterfacesManager" << std::endl;
00417 }
00418 }
00419
00420 __COUT__ << "theFEInterfacesManager pointer = " << theFEInterfacesManager << std::endl;
00421
00422 return theFEInterfacesManager;
00423 }
00424
00425
00426
00427
00428
00429