00001 #include "otsdaq-core/CoreSupervisors/CoreSupervisorBase.h"
00002 #include "otsdaq-core/XmlUtilities/HttpXmlDocument.h"
00003 #include "otsdaq-core/SOAPUtilities/SOAPUtilities.h"
00004 #include "otsdaq-core/SOAPUtilities/SOAPCommand.h"
00005 #include "otsdaq-core/CgiDataUtilities/CgiDataUtilities.h"
00006
00007
00008 #include "otsdaq-core/ConfigurationDataFormats/ConfigurationGroupKey.h"
00009 #include "otsdaq-core/ConfigurationInterface/ConfigurationManager.h"
00010 #include "otsdaq-core/ConfigurationInterface/ConfigurationTree.h"
00011 #include "otsdaq-core/ConfigurationPluginDataFormats/XDAQContextConfiguration.h"
00012 #include "otsdaq-core/MessageFacility/MessageFacility.h"
00013 #include "otsdaq-core/Macros/CoutHeaderMacros.h"
00014 #include "otsdaq-core/FiniteStateMachine/VStateMachine.h"
00015 #include "otsdaq-core/FECore/FEVInterfacesManager.h"
00016
00017
00018 #include <toolbox/fsm/FailedEvent.h>
00019
00020 #include <xdaq/NamespaceURI.h>
00021 #include <xoap/Method.h>
00022
00023 #include <iostream>
00024
00025 using namespace ots;
00026
00027
00028
00029
00030 CoreSupervisorBase::CoreSupervisorBase(xdaq::ApplicationStub * s)
00031 throw (xdaq::exception::Exception)
00032 : xdaq::Application (s)
00033 , SOAPMessenger (this)
00034 , stateMachineWorkLoopManager_ (toolbox::task::bind(this, &CoreSupervisorBase::stateMachineThread, "StateMachine"))
00035 , stateMachineSemaphore_ (toolbox::BSem::FULL)
00036 , theConfigurationManager_ (new ConfigurationManager)
00037 , XDAQContextConfigurationName_ (theConfigurationManager_->__GET_CONFIG__(XDAQContextConfiguration)->getConfigurationName())
00038 , supervisorConfigurationPath_ ("INITIALIZED INSIDE THE CONTRUCTOR BECAUSE IT NEEDS supervisorContextUID_ and supervisorApplicationUID_")
00039 , supervisorContextUID_ ("INITIALIZED INSIDE THE CONTRUCTOR TO LAUNCH AN EXCEPTION")
00040 , supervisorApplicationUID_ ("INITIALIZED INSIDE THE CONTRUCTOR TO LAUNCH AN EXCEPTION")
00041 , supervisorClass_ (getApplicationDescriptor()->getClassName())
00042 , supervisorClassNoNamespace_ (supervisorClass_.substr(supervisorClass_.find_last_of(":")+1, supervisorClass_.length()-supervisorClass_.find_last_of(":")))
00043 {
00044 __MOUT__ << "Begin!" << std::endl;
00045 __MOUT__ << "Begin!" << std::endl;
00046 __MOUT__ << "Begin!" << std::endl;
00047 __MOUT__ << "Begin!" << std::endl;
00048 __MOUT__ << "Begin!" << std::endl;
00049 xgi::bind (this, &CoreSupervisorBase::Default, "Default" );
00050 xgi::bind (this, &CoreSupervisorBase::stateMachineXgiHandler, "StateMachineXgiHandler");
00051 xgi::bind (this, &CoreSupervisorBase::request, "Request");
00052
00053 xoap::bind(this, &CoreSupervisorBase::stateMachineStateRequest, "StateMachineStateRequest", XDAQ_NS_URI );
00054 xoap::bind(this, &CoreSupervisorBase::macroMakerSupervisorRequest, "MacroMakerSupervisorRequest", XDAQ_NS_URI );
00055
00056 try
00057 {
00058 supervisorContextUID_ = theConfigurationManager_->__GET_CONFIG__(XDAQContextConfiguration)->getContextUID(getApplicationContext()->getContextDescriptor()->getURL());
00059 }
00060 catch(...)
00061 {
00062 __MOUT_ERR__ << "XDAQ Supervisor could not access it's configuration through the Configuration Context Group." <<
00063 " The XDAQContextConfigurationName = " << XDAQContextConfigurationName_ <<
00064 ". The supervisorApplicationUID = " << supervisorApplicationUID_ << std::endl;
00065 throw;
00066 }
00067 try
00068 {
00069 supervisorApplicationUID_ = theConfigurationManager_->__GET_CONFIG__(XDAQContextConfiguration)->getApplicationUID
00070 (
00071 getApplicationContext()->getContextDescriptor()->getURL(),
00072 getApplicationDescriptor()->getLocalId()
00073 );
00074 }
00075 catch(...)
00076 {
00077 __MOUT_ERR__ << "XDAQ Supervisor could not access it's configuration through the Configuration Application Group."
00078 << " The supervisorApplicationUID = " << supervisorApplicationUID_ << std::endl;
00079 throw;
00080 }
00081 supervisorConfigurationPath_ = "/" + supervisorContextUID_ + "/LinkToApplicationConfiguration/" + supervisorApplicationUID_ + "/LinkToSupervisorConfiguration";
00082
00083 setStateMachineName(supervisorApplicationUID_);
00084 __MOUT__ << "Done!" << std::endl;
00085 __MOUT__ << "Done!" << std::endl;
00086 __MOUT__ << "Done!" << std::endl;
00087 __MOUT__ << "Done!" << std::endl;
00088
00089 init();
00090 }
00091
00092
00093 CoreSupervisorBase::~CoreSupervisorBase(void)
00094 {
00095 destroy();
00096 }
00097
00098 void CoreSupervisorBase::init(void)
00099 {
00100
00101 __MOUT__ << "CONTEXT!" << std::endl;
00102 __MOUT__ << "CONTEXT!" << std::endl;
00103 __MOUT__ << "CONTEXT!" << std::endl;
00104 supervisorDescriptorInfo_.init(getApplicationContext());
00105 __MOUT__ << "Done!" << std::endl;
00106 __MOUT__ << "Done!" << std::endl;
00107 __MOUT__ << "Done!" << std::endl;
00108
00109 }
00110
00111
00112 void CoreSupervisorBase::destroy(void)
00113 {
00114 for(auto& it: theStateMachineImplementation_)
00115 delete it;
00116 theStateMachineImplementation_.clear();
00117 }
00118
00119
00120 void CoreSupervisorBase::Default(xgi::Input * in, xgi::Output * out )
00121 throw (xgi::exception::Exception)
00122 {
00123
00124
00125 __MOUT__<< "Supervisor class " << supervisorClass_ << std::endl;
00126
00127 *out << "<!DOCTYPE HTML><html lang='en'><frameset col='100%' row='100%'><frame src='/WebPath/html/" << supervisorClassNoNamespace_ << "Supervisor.html?urn=" <<
00128 this->getApplicationDescriptor()->getLocalId() <<
00129 "'></frameset></html>";
00130 }
00131
00132
00133 void CoreSupervisorBase::request(xgi::Input * in, xgi::Output * out )
00134 throw (xgi::exception::Exception)
00135 {
00136
00137
00138 cgicc::Cgicc cgi(in);
00139 std::string write = CgiDataUtilities::getOrPostData(cgi,"write");
00140 std::string addr = CgiDataUtilities::getOrPostData(cgi,"addr");
00141 std::string data = CgiDataUtilities::getOrPostData(cgi,"data");
00142
00143 __MOUT__<< "write " << write << " addr: " << addr << " data: " << data << std::endl;
00144
00145 unsigned long long int addr64,data64;
00146 sscanf(addr.c_str(),"%llu",&addr64);
00147 sscanf(data.c_str(),"%llu",&data64);
00148 __MOUT__<< "write " << write << " addr: " << addr64 << " data: " << data64 << std::endl;
00149
00150 *out << "done";
00151 }
00152
00153
00154 void CoreSupervisorBase::stateMachineXgiHandler(xgi::Input * in, xgi::Output * out )
00155 throw (xgi::exception::Exception)
00156 {}
00157
00158
00159 void CoreSupervisorBase::stateMachineResultXgiHandler(xgi::Input* in, xgi::Output* out )
00160 throw (xgi::exception::Exception)
00161 {}
00162
00163
00164 xoap::MessageReference CoreSupervisorBase::stateMachineXoapHandler(xoap::MessageReference message )
00165 throw (xoap::exception::Exception)
00166 {
00167 __MOUT__<< "Soap Handler!" << std::endl;
00168 stateMachineWorkLoopManager_.removeProcessedRequests();
00169 stateMachineWorkLoopManager_.processRequest(message);
00170 __MOUT__<< "Done - Soap Handler!" << std::endl;
00171 return message;
00172 }
00173
00174
00175 xoap::MessageReference CoreSupervisorBase::stateMachineResultXoapHandler(xoap::MessageReference message )
00176 throw (xoap::exception::Exception)
00177 {
00178 __MOUT__<< "Soap Handler!" << std::endl;
00179
00180
00181 __MOUT__<< "Done - Soap Handler!" << std::endl;
00182 return message;
00183 }
00184
00185
00186 bool CoreSupervisorBase::stateMachineThread(toolbox::task::WorkLoop* workLoop)
00187 {
00188 stateMachineSemaphore_.take();
00189 __MOUT__<< "Re-sending message..." << SOAPUtilities::translate(stateMachineWorkLoopManager_.getMessage(workLoop)).getCommand() << std::endl;
00190 std::string reply = send(this->getApplicationDescriptor(),stateMachineWorkLoopManager_.getMessage(workLoop));
00191 stateMachineWorkLoopManager_.report(workLoop, reply, 100, true);
00192 __MOUT__<< "Done with message" << std::endl;
00193 stateMachineSemaphore_.give();
00194 return false;
00195
00196 }
00197
00198
00199 xoap::MessageReference CoreSupervisorBase::stateMachineStateRequest(xoap::MessageReference message)
00200 throw (xoap::exception::Exception)
00201 {
00202 __MOUT__<< theStateMachine_.getCurrentStateName() << std::endl;
00203 return SOAPUtilities::makeSOAPMessageReference(theStateMachine_.getCurrentStateName());
00204 }
00205
00206
00207
00208
00209
00210
00211
00212
00213 xoap::MessageReference CoreSupervisorBase::macroMakerSupervisorRequest(
00214 xoap::MessageReference message)
00215 throw (xoap::exception::Exception)
00216 {
00217 __MOUT__<< "$$$$$$$$$$$$$$$$$" << std::endl;
00218
00219
00220 FEVInterfacesManager* theFEInterfacesManager = 0;
00221 for(unsigned int i = 0; i<theStateMachineImplementation_.size();++i)
00222 {
00223 try
00224 {
00225 theFEInterfacesManager =
00226 dynamic_cast<FEVInterfacesManager*>(theStateMachineImplementation_[i]);
00227 if(!theFEInterfacesManager) throw std::runtime_error("");
00228 __MOUT__ << "State Machine " << i << " WAS of type FEVInterfacesManager" << std::endl;
00229
00230 break;
00231 }
00232 catch(...)
00233 {
00234 __MOUT__ << "State Machine " << i << " was NOT of type FEVInterfacesManager" << std::endl;
00235 }
00236 }
00237
00238
00239 __MOUT__ << "theFEInterfacesManager pointer = " << theFEInterfacesManager << std::endl;
00240
00241
00242 SOAPParameters parameters;
00243 parameters.addParameter("Request");
00244 parameters.addParameter("InterfaceID");
00245
00246
00247 parameters.addParameter("Address");
00248 parameters.addParameter("Data");
00249
00250
00251 parameters.addParameter("feMacroName");
00252 parameters.addParameter("inputArgs");
00253 parameters.addParameter("outputArgs");
00254
00255 SOAPMessenger::receive(message, parameters);
00256 std::string request = parameters.getValue("Request");
00257 std::string addressStr = parameters.getValue("Address");
00258 std::string dataStr = parameters.getValue("Data");
00259 std::string InterfaceID = parameters.getValue("InterfaceID");
00260
00261 __MOUT__<< "request: " << request << std::endl;
00262
00263 __MOUT__<< "Address: " << addressStr << " Data: "
00264 << dataStr << " InterfaceID: " << InterfaceID << std::endl;
00265
00266 SOAPParameters retParameters;
00267
00268 if(request == "GetInterfaces")
00269 {
00270 if(theFEInterfacesManager)
00271 retParameters.addParameter("FEList",theFEInterfacesManager->getFEListString(
00272 std::to_string(getApplicationDescriptor()->getLocalId())));
00273 else
00274 retParameters.addParameter("FEList","");
00275
00276 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "Response",
00277 retParameters);
00278 }
00279 else if(request == "UniversalWrite")
00280 {
00281 if(!theFEInterfacesManager)
00282 {
00283 __MOUT_INFO__ << "No FE Interface Manager! (So no write occurred)" << std::endl;
00284 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "DataWritten",retParameters);
00285 }
00286
00287
00288
00289
00290
00291
00292 __MOUT__<< "theFEInterfacesManager->getInterfaceUniversalAddressSize(index) " <<
00293 theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID) << std::endl;
00294 __MOUT__<< "theFEInterfacesManager->getInterfaceUniversalDataSize(index) " <<
00295 theFEInterfacesManager->getInterfaceUniversalDataSize(InterfaceID) << std::endl;
00296
00297
00298
00299
00300 char tmpHex[3];
00301 tmpHex[2] = '\0';
00302
00303
00304 __MOUT__<< "Translating address: ";
00305
00306 char address[theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID)];
00307
00308 if(addressStr.size()%2)
00309 addressStr = "0" + addressStr;
00310 unsigned int i=0;
00311 for(;i<addressStr.size() &&
00312 i/2 < theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID) ; i+=2)
00313 {
00314 tmpHex[0] = addressStr[addressStr.size()-1-i-1];
00315 tmpHex[1] = addressStr[addressStr.size()-1-i];
00316 sscanf(tmpHex,"%hhX",(unsigned char*)&address[i/2]);
00317 printf("%2.2X",(unsigned char)address[i/2]);
00318 }
00319
00320 for(;i/2 < theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID) ; i+=2)
00321 {
00322 address[i/2] = 0;
00323 printf("%2.2X",(unsigned char)address[i/2]);
00324 }
00325
00326 std::cout << std::endl;
00327
00328 __MOUT__<< "Translating data: ";
00329
00330 char data[theFEInterfacesManager->getInterfaceUniversalDataSize(InterfaceID)];
00331
00332 if(dataStr.size()%2)
00333 dataStr = "0" + dataStr;
00334
00335 i=0;
00336 for(;i<dataStr.size() &&
00337 i/2 < theFEInterfacesManager->getInterfaceUniversalDataSize(InterfaceID) ; i+=2)
00338 {
00339 tmpHex[0] = dataStr[dataStr.size()-1-i-1];
00340 tmpHex[1] = dataStr[dataStr.size()-1-i];
00341 sscanf(tmpHex,"%hhX",(unsigned char*)&data[i/2]);
00342 printf("%2.2X",(unsigned char)data[i/2]);
00343 }
00344
00345 for(;i/2 < theFEInterfacesManager->getInterfaceUniversalDataSize(InterfaceID) ; i+=2)
00346 {
00347 data[i/2] = 0;
00348 printf("%2.2X",(unsigned char)data[i/2]);
00349 }
00350
00351 std::cout << std::endl;
00352
00353
00354
00355
00356
00357
00358
00359
00360 theFEInterfacesManager->universalWrite(InterfaceID,address,data);
00361
00362
00363
00364
00365 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "DataWritten",retParameters);
00366 }
00367 else if(request == "UniversalRead")
00368 {
00369 if(!theFEInterfacesManager)
00370 {
00371 __MOUT_INFO__ << "No FE Interface Manager! (So no read occurred)" << std::endl;
00372 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "aa",retParameters);
00373 }
00374
00375
00376
00377
00378
00379 __MOUT__<< "theFEInterfacesManager->getInterfaceUniversalAddressSize(index) "
00380 << theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID) << std::endl;
00381 __MOUT__<< "theFEInterfacesManager->getInterfaceUniversalDataSize(index) "
00382 <<theFEInterfacesManager->getInterfaceUniversalDataSize(InterfaceID) << std::endl;
00383
00384 char tmpHex[3];
00385 tmpHex[2] = '\0';
00386
00387
00388 __MOUT__<< "Translating address: ";
00389
00390 char address[theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID)];
00391
00392 if(addressStr.size()%2)
00393 addressStr = "0" + addressStr;
00394
00395 unsigned int i=0;
00396 for(;i<addressStr.size() &&
00397 i/2 < theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID) ; i+=2)
00398 {
00399 tmpHex[0] = addressStr[addressStr.size()-1-i-1];
00400 tmpHex[1] = addressStr[addressStr.size()-1-i];
00401 sscanf(tmpHex,"%hhX",(unsigned char*)&address[i/2]);
00402 printf("%2.2X",(unsigned char)address[i/2]);
00403 }
00404
00405 for(;i/2 < theFEInterfacesManager->getInterfaceUniversalAddressSize(InterfaceID) ; i+=2)
00406 {
00407 address[i/2] = 0;
00408 printf("%2.2X",(unsigned char)address[i/2]);
00409 }
00410
00411 std::cout << std::endl;
00412
00413 unsigned int dataSz = theFEInterfacesManager->getInterfaceUniversalDataSize(InterfaceID);
00414 char data[dataSz];
00415
00416
00417
00418
00419
00420 if(theFEInterfacesManager->universalRead(InterfaceID, address, data) < 0)
00421 {
00422 retParameters.addParameter("dataResult","Time Out Error");
00423 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "aa",retParameters);
00424 }
00425
00426
00427 if(dataSz <= 8)
00428 {
00429 std::string str8(data);
00430 str8.resize(8);
00431 __MOUT__<< "decResult[" << dataSz << " bytes]: " <<
00432 *((unsigned long long *)(&str8[0])) << std::endl;
00433
00434 }
00435
00436 char hexResult[dataSz*2+1];
00437
00438
00439
00440 for(unsigned int i=0;i<dataSz;++i)
00441 {
00442 sprintf(&hexResult[i*2],"%2.2X", (unsigned char)data[dataSz-1-i]);
00443 }
00444
00445 __MOUT__<< "hexResult[" << strlen(hexResult) << " nibbles]: " << std::string(hexResult) << std::endl;
00446
00447
00448
00449 retParameters.addParameter("dataResult",hexResult);
00450 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "aa",retParameters);
00451
00452 }
00453 else if(request == "GetInterfaceMacros")
00454 {
00455 if(theFEInterfacesManager)
00456 retParameters.addParameter("FEMacros",theFEInterfacesManager->getFEMacrosString(
00457 std::to_string(getApplicationDescriptor()->getLocalId())));
00458 else
00459 retParameters.addParameter("FEMacros","");
00460
00461 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "Response",
00462 retParameters);
00463 }
00464 else if(request == "RunInterfaceMacro")
00465 {
00466 if(!theFEInterfacesManager)
00467 {
00468 retParameters.addParameter("success","0");
00469 retParameters.addParameter("outputArgs","");
00470 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "Response",
00471 retParameters);
00472 }
00473
00474 std::string feMacroName = parameters.getValue("feMacroName");
00475 std::string inputArgs = parameters.getValue("inputArgs");
00476 std::string outputArgs = parameters.getValue("outputArgs");
00477
00478
00479
00480 bool success = true;
00481 try
00482 {
00483 theFEInterfacesManager->runFEMacro(InterfaceID,feMacroName,inputArgs,outputArgs);
00484 }
00485 catch(std::runtime_error &e)
00486 {
00487 __SS__ << "In Supervisor with LID=" << getApplicationDescriptor()->getLocalId()
00488 << " the FE Macro named '" << feMacroName << "' with tartget FE '"
00489 << InterfaceID << "' failed. Here is the error:\n\n" << e.what() << std::endl;
00490 __MOUT_ERR__ << "\n" << ss.str();
00491 success = false;
00492 outputArgs = ss.str();
00493 }
00494
00495
00496 retParameters.addParameter("success",success?"1":"0");
00497 retParameters.addParameter("outputArgs",outputArgs);
00498
00499 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "Response",
00500 retParameters);
00501 }
00502 else
00503 {
00504 __MOUT_WARN__ << "Unrecognized request received! '" << request << "'" << std::endl;
00505 }
00506
00507
00508 return SOAPUtilities::makeSOAPMessageReference(supervisorClassNoNamespace_ + "FailRequest",retParameters);
00509 }
00510
00511
00512 void CoreSupervisorBase::stateInitial(toolbox::fsm::FiniteStateMachine& fsm)
00513 throw (toolbox::fsm::exception::Exception)
00514 {
00515 __MOUT__ << "CoreSupervisorBase::stateInitial" << std::endl;
00516 }
00517
00518
00519 void CoreSupervisorBase::stateHalted(toolbox::fsm::FiniteStateMachine& fsm)
00520 throw (toolbox::fsm::exception::Exception)
00521 {
00522 __MOUT__ << "CoreSupervisorBase::stateHalted" << std::endl;
00523 }
00524
00525
00526 void CoreSupervisorBase::stateRunning(toolbox::fsm::FiniteStateMachine& fsm)
00527 throw (toolbox::fsm::exception::Exception)
00528 {
00529 __MOUT__ << "CoreSupervisorBase::stateRunning" << std::endl;
00530 }
00531
00532
00533 void CoreSupervisorBase::stateConfigured(toolbox::fsm::FiniteStateMachine& fsm)
00534 throw (toolbox::fsm::exception::Exception)
00535 {
00536 __MOUT__ << "CoreSupervisorBase::stateConfigured" << std::endl;
00537 }
00538
00539
00540 void CoreSupervisorBase::statePaused(toolbox::fsm::FiniteStateMachine& fsm)
00541 throw (toolbox::fsm::exception::Exception)
00542 {
00543 __MOUT__ << "CoreSupervisorBase::statePaused" << std::endl;
00544 }
00545
00546
00547 void CoreSupervisorBase::inError (toolbox::fsm::FiniteStateMachine & fsm)
00548 throw (toolbox::fsm::exception::Exception)
00549 {
00550 __MOUT__<< "Fsm current state: " << theStateMachine_.getCurrentStateName()<< std::endl;
00551
00552 }
00553
00554
00555 void CoreSupervisorBase::enteringError (toolbox::Event::Reference e)
00556 throw (toolbox::fsm::exception::Exception)
00557 {
00558 __MOUT__<< "Fsm current state: " << theStateMachine_.getCurrentStateName()<< std::endl;
00559 toolbox::fsm::FailedEvent& failedEvent = dynamic_cast<toolbox::fsm::FailedEvent&>(*e);
00560 std::ostringstream error;
00561 error << "Failure performing transition from "
00562 << failedEvent.getFromState()
00563 << " to "
00564 << failedEvent.getToState()
00565 << " exception: " << failedEvent.getException().what();
00566 __MOUT__<< error.str() << std::endl;
00567
00568
00569 }
00570
00571
00572 void CoreSupervisorBase::transitionConfiguring(toolbox::Event::Reference e)
00573 throw (toolbox::fsm::exception::Exception)
00574 {
00575
00576 std::pair<std::string , ConfigurationGroupKey> theGroup(
00577 SOAPUtilities::translate(theStateMachine_.getCurrentMessage()).
00578 getParameters().getValue("ConfigurationGroupName"),
00579 ConfigurationGroupKey(SOAPUtilities::translate(theStateMachine_.getCurrentMessage()).
00580 getParameters().getValue("ConfigurationGroupKey")));
00581
00582 __MOUT__ << "Configuration group name: " << theGroup.first << " key: " <<
00583 theGroup.second << std::endl;
00584
00585 theConfigurationManager_->loadConfigurationGroup(
00586 theGroup.first,
00587 theGroup.second, true);
00588
00589
00590
00591 for(auto& it: theStateMachineImplementation_)
00592 it->configure();
00593
00594 }
00595
00596
00597 void CoreSupervisorBase::transitionHalting(toolbox::Event::Reference e)
00598 throw (toolbox::fsm::exception::Exception)
00599 {
00600
00601 for(auto& it: theStateMachineImplementation_)
00602 it->halt();
00603 }
00604
00605
00606 void CoreSupervisorBase::transitionInitializing(toolbox::Event::Reference e)
00607 throw (toolbox::fsm::exception::Exception)
00608 {
00609
00610
00611
00612 }
00613
00614
00615 void CoreSupervisorBase::transitionPausing(toolbox::Event::Reference e)
00616 throw (toolbox::fsm::exception::Exception)
00617 {
00618
00619 for(auto& it: theStateMachineImplementation_)
00620 it->pause();
00621 }
00622
00623
00624 void CoreSupervisorBase::transitionResuming(toolbox::Event::Reference e)
00625 throw (toolbox::fsm::exception::Exception)
00626 {
00627
00628
00629 for(auto it = theStateMachineImplementation_.rbegin(); it != theStateMachineImplementation_.rend(); it++)
00630 (*it)->resume();
00631 }
00632
00633
00634 void CoreSupervisorBase::transitionStarting(toolbox::Event::Reference e)
00635 throw (toolbox::fsm::exception::Exception)
00636 {
00637
00638
00639 for(auto it = theStateMachineImplementation_.rbegin(); it != theStateMachineImplementation_.rend(); it++)
00640 (*it)->start(SOAPUtilities::translate(theStateMachine_.getCurrentMessage()).getParameters().getValue("RunNumber"));
00641 }
00642
00643
00644 void CoreSupervisorBase::transitionStopping(toolbox::Event::Reference e)
00645 throw (toolbox::fsm::exception::Exception)
00646 {
00647
00648 for(auto& it: theStateMachineImplementation_)
00649 it->stop();
00650 }