00001 #include "CalibrationControllerImpl.h"
00002 #include "ScanLibraryImpl.h"
00003 #include "TestLibraryImpl.h"
00004 #include "SequenceLibraryImpl.h"
00005 #include "SequenceRequestWorker.h"
00006 #include "RunController.h"
00007 #include "SctApiAccessException.h"
00008 #include "ipc/SequenceRequest.h"
00009 #include "scripts/DefaultSequence.h"
00010 #include "scripts/DefaultTest.h"
00011 #include "Sequence.h"
00012 #include "Test.h"
00013 #include "SctApiCall.h"
00014 #include "ConfigUpdater/ConfigUpdaterManager.h"
00015
00016 #include "Sct/SctNames.h"
00017 #include "Sct/LogicErrors.h"
00018 #include "Sct/IoExceptions.h"
00019 #include "Sct/ISUtilities.h"
00020 #include "Sct/CorbaExceptionWrapper.h"
00021 #include "Sct/StdExceptionWrapper.h"
00022 #include "Sct/IS/IOManagerIS.h"
00023 #include "Sct/IS/IONameIS.h"
00024 #include "Sct/OmniMarshalling.h"
00025 #include "SctData/TestResult.h"
00026 #include "Sct/UniqueID.h"
00027 #include <ipc/server.h>
00028 #include <is/isinfotmpl.h>
00029
00030 #include <boost/utility.hpp>
00031 #include <unistd.h>
00032 #include <iostream>
00033 #include "Sct/BugReport.h"
00034 #include "Sct/CorbaExceptionWrapper.h"
00035
00036 #ifndef __Sct_SctApi_H_
00037 #include "Sct_SctApi/SctApi.hh"
00038 #endif
00039
00040
00041 using namespace std;
00042 using namespace Sct;
00043 using namespace SctData;
00044
00045 namespace SctCalibrationController {
00046
00047 using namespace Scripts;
00048
00049 CalibrationControllerImpl::CalibrationControllerImpl(RunControl& rc) : rc(rc), runNumber(0),
00050 nextScanNumber(0), abortNow(false), abortRightNow(false) {
00051 status.currentScanIndex = 0;
00052 publish();
00053 updateStatus();
00054 }
00055
00056 CalibrationControllerImpl::~CalibrationControllerImpl() {
00057 withdraw();
00058
00059
00060 string name = SctNames::getControlDataName();
00061 name += ".Status";
00062 ISInfoDictionary& is = SctNames::getISDictionary();
00063 is.remove(name.c_str());
00064 inst->_destroy();
00065 }
00066
00067 Sct_SctApi::SctApiIPC_ptr CalibrationControllerImpl::getApi() {
00068 if (CORBA::is_nil(m_api)){
00069
00070 m_api=SctNames::getPartition().lookup<Sct_SctApi::SctApiIPC>(Sct_SctApi::SctApiIPC::instanceName);
00071 if (CORBA::is_nil(m_api)) {
00072 SctNames::Mrs() << "CC" << MRS_TEXT("Calibration Controller failed to find SctApi") << MRS_ERROR << ENDM;
00073 } else {
00074 SctNames::Mrs() << "CC" << MRS_TEXT("Calibration Controller refreshed SctApi handle") << MRS_DIAGNOSTIC << ENDM;
00075 }
00076 }
00077 Sct_SctApi::SctApiIPC_ptr ret = Sct_SctApi::SctApiIPC::_duplicate(m_api);
00078 if (CORBA::is_nil(ret)) {
00079 SctNames::Mrs() << "CC" << MRS_TEXT("Calibration Controller failed to duplicate handle") << MRS_ERROR << ENDM;
00080 };
00081 return ret;
00082 }
00083
00084 void CalibrationControllerImpl::setApi(Sct_SctApi::SctApiIPC_ptr api) {
00085 this->m_api = Sct_SctApi::SctApiIPC::_duplicate(api);
00086 }
00087
00088 void CalibrationControllerImpl::reset() {
00089 SctNames::Mrs() << "CC_RESET" << MRS_TEXT("Calibration controller was reset") << MRS_DIAGNOSTIC << ENDM;
00090 status.status = status.LOADED;
00091 updateStatus();
00092 m_api = Sct_SctApi::SctApiIPC::_nil();
00093 }
00094
00095 void CalibrationControllerImpl::sctApiError(SctApiAccessException& e) {
00096 rc.sctApiError(e.what());
00097
00098 updateStatus();
00099 }
00100
00101 void CalibrationControllerImpl::takeControl(unsigned int runNumber) {
00102 if (status.status != status.LOADED || CORBA::is_nil(m_api) )
00103 return;
00104 this->runNumber = runNumber;
00105 nextScanNumber = 0;
00106 status.status = status.INCONTROL;
00107
00108 SctNames::Mrs() << "CC_START" << MRS_TEXT("Calibration Controller taking control") << MRS_INFORMATION << ENDM;
00109 updateStatus();
00110 }
00111
00112 void CalibrationControllerImpl::giveupControl() {
00113 if (status.status == status.INCONTROL) {
00114 SctNames::Mrs() << "CC_END" << MRS_TEXT("Calibration Controller giving up control") << MRS_INFORMATION << ENDM;
00115
00116 status.status = status.LOADED;
00117 updateStatus();
00118 }
00119 }
00120
00121 bool CalibrationControllerImpl::isInControl() {
00122 return status.status == status.INCONTROL;
00123 }
00124
00125 bool CalibrationControllerImpl::isBusy() {
00126 return status.status == status.BUSY;
00127 }
00128
00129 void CalibrationControllerImpl::setBusy(bool busy) {
00130 if (busy && status.status == status.INCONTROL)
00131 status.status = status.BUSY;
00132 else if (!busy && status.status == status.BUSY)
00133 status.status = status.INCONTROL;
00134 updateStatus();
00135 }
00136
00137 unsigned int CalibrationControllerImpl::getRunNumber() const {
00138 return runNumber;
00139 }
00140
00141 unsigned int CalibrationControllerImpl::getNextScanNumber() const {
00142 return nextScanNumber;
00143 }
00144
00145 void CalibrationControllerImpl::setNextScanNumber(unsigned int scanNumber) {
00146 nextScanNumber = scanNumber;
00147 Sct_SctApi::SctApiIPC_var api = getApi();
00148 APICALL(api, setScanNumber(scanNumber), "setScanNumber failed in setNextScanNumber")
00149 }
00150
00151 void CalibrationControllerImpl::abort() {
00153 if (status.status != status.BUSY) return;
00154
00155 abortNow = true;
00156
00157 SctNames::Mrs() << "CC_ABORT" << MRS_TEXT("User requested abort Sequence") << MRS_INFORMATION << ENDM;
00158
00159
00160
00161 try{
00162 Sct_SctApi::SctApiIPC_var api = getApi();
00163 ipc::servant::info_var info = api->information();
00164 }catch(CORBA::Exception& e){
00165 abortRightNow = true;
00166 }
00167 }
00168
00169 void CalibrationControllerImpl::executeSequence(Sct_CalibrationController::SequenceRequest_ptr sr) {
00170 SctNames::Mrs() << "CC_SEQ_START" << MRS_TEXT("Calibration Controller starting sequence") << MRS_INFORMATION << ENDM;
00171
00172 string name;
00173 Sct_SctApi::SctApiIPC_var api = getApi();
00174
00175 Sct::BugReport("BUG01", "CCImpl.cpp", "Just before startSequence try block");
00176 try {
00177 Sct::BugReport("BUG01", "CCImpl.cpp", "Just before xx1 startSequence try block");
00178 if (CORBA::is_nil(sr)) {
00179 Sct::BugReport("BUG01", "CCImpl.cpp", "Oh dear, sr was nil!");
00180 throw Sct::IllegalStateError("Null Sequence pointer ", __FILE__, __LINE__);
00181 };
00182 Sct::BugReport("BUG01", "CCImpl.cpp", "Just before xx2 startSequence try block");
00183
00184 APIRETCALL(api, nextScanNumber, getScanNumber(), "Couldn't synchronise scan numbers")
00185
00186 Sct::BugReport("BUG01", "CCImpl.cpp", "Just before xx3 startSequence try block");
00187 CORBA::String_var corbaname = sr->startSequence(api);
00188 Sct::BugReport("BUG01", "CCImpl.cpp", "Just before xx4 startSequence try block");
00189 name = corbaname;
00190 Sct::BugReport("BUG01", "CCImpl.cpp", "Just before xx5 the startSequence we are trying to understand.");
00191 std::cout << "CC: name of sequence is : " << name << std::endl;
00192 } catch (SctApiAccessException& e) {
00193 Sct::BugReport("BUG01", "CCImpl.cpp", "In first catch");
00194 sctApiError(e);
00195 throw;
00196 } catch (CorbaExceptionWrapper& e) {
00197 Sct::BugReport("BUG01", "CCImpl.cpp", "In second catch");
00198 e.sendToMrs();
00199 return;
00200 }
00201 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 2");
00202
00203 shared_ptr<Sequence> s;
00204 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 3");
00205 try {
00206 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 4");
00207 sctConf::ModuleList_var mlist;
00208 std::cout << "CC Getting module List" << std::endl;
00209 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 5");
00210 APIRETCALL(api, mlist, getModuleList(), "Couldn't get module list")
00211 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 6");
00212 std::cout << "CC Got module List" << std::endl;
00213 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 7");
00214
00215 list<string> list = copyCorbaToList<sctConf::ModuleList, string>(&(mlist.in()));
00216 s = Sequence::create(name, runNumber, nextScanNumber, list);
00217
00218 status.currentSequence = s->getUniqueID();
00219 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 8");
00220 updateStatus();
00221 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 9");
00222
00223 Sct_CalibrationController::TestRequest_var tr = Sct_CalibrationController::TestRequest::_nil();
00224 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 10");
00225 unsigned long index = 0;
00226
00227 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 11");
00228 do {
00229 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 12");
00230 tr = sr->getNextTest(index);
00231 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 12.5");
00232 if (!CORBA::is_nil(tr)) {
00233 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 13");
00234 unsigned firstScanInTest = getNextScanNumber();
00235 unsigned runNumber = getRunNumber();
00236 s->addTest(executeTest(tr, s));
00237 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 14");
00238
00239
00240 if (s->getTest(index)->getData().status != TestData::COMPLETED) {
00241 SctNames::Mrs() << "CC_SEQ_END" << MRS_TEXT("Calibration Controller aborting sequence") << MRS_INFORMATION << ENDM;
00242 s->setStatus(SequenceData::ABORTED);
00243 return;
00244 }
00245 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 15");
00246
00247 if (tr->canFeedback()) {
00248 std::list<std::string> moduleList = s->getModuleList();
00249 applyChanges(runNumber, firstScanInTest, moduleList);
00250 }
00251 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 16");
00252 } else {
00253 Sct::BugReport("BUG01", "CCImpl.cpp","posn 16.5 -- tr was null!");
00254 };
00255 ++index;
00256 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 17");
00257 } while (!CORBA::is_nil(tr));
00258
00259 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 18");
00260
00261 APICALL(api, setABCDModules(Sct_SctApi::CALIBRATION_CONFIG), "setABCDModules failed after update")
00262 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 19");
00263
00264 SctNames::Mrs() << "CC_SEQ_END" << MRS_TEXT("Calibration Controller ending sequence") << MRS_INFORMATION << ENDM;
00265 sr->endSequence();
00266 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 20");
00267 s->setStatus(SequenceData::COMPLETED);
00268 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 21");
00269
00270 } catch (SctApiAccessException& e) {
00271 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 22");
00272 sctApiError(e);
00273 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 23");
00274 throw;
00275 } catch (Throwable& e) {
00276 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 24");
00277 e.sendToMrs(MRS_INFORMATION);
00278 if (s) s->setStatus(SequenceData::ABORTED);
00279 }
00280 Sct::BugReport("BUG01", "CCImpl.cpp", "posn 25");
00281 }
00282
00283 void CalibrationControllerImpl::applyChanges(const unsigned long runNumber, const unsigned long scanNumber, const std::list<std::string>& modulelist ) {
00284 Sct_SctApi::SctApiIPC_var api = getApi();
00285
00286 cout << "Update option = " << status.updateOption << endl;
00287
00288 bool printed=false;
00289 while (status.updateOption=="WAIT") {
00290 if (!printed)
00291 cerr << "CalibrationController awaiting instructions as to whether to apply changes" << endl;
00292 printed=true;
00293 }
00294
00295
00296 if (status.updateOption!="UPDATE")
00297 return;
00298
00299 cout << "updating " << modulelist.size() << "" << " modules" << endl;
00300
00301 std::ostringstream regexp;
00302 regexp << ".*TestResult\\." << runNumber << "\\." << scanNumber << "\\..*";
00303 cout << "Cal Controller looking for " << regexp.str() << endl;
00304
00305 unsigned nprinted=0;
00306
00307
00308 std::list<std::string> mylist=modulelist;
00309
00310 while (!mylist.empty() && status.updateOption=="UPDATE") {
00311 ISInfoIterator ii(SctNames::getPartition(),
00312 SctNames::getTestDataName().c_str(),
00313 regexp.str().c_str() );
00314
00315 while (ii() && status.updateOption=="UPDATE") {
00316 if (nprinted<10)
00317 cout << " checking " << ii.name() << endl;
00318
00319
00320
00321 Sct::IS::IONameIS isname(ii.name());
00322 std::string moduleName=isname.getUniqueID().getModule();
00323
00324
00325 std::list<string>::iterator it = std::find( mylist.begin(), mylist.end(), moduleName);
00326
00327 if ( it != mylist.end() ) {
00328 shared_ptr<const Serializable> ob ( Sct::IS::IOManagerIS::instance().read(ii.name()) );
00329 shared_ptr<const SctData::TestResult> testResult = boost::dynamic_pointer_cast<const SctData::TestResult>(ob);
00330 if (!testResult)
00331 throw Sct::InvalidArgumentError("Fitter::applyChangesCallback not a SctData::TestResult.", __FILE__, __LINE__);
00332
00333 cout << "about to update " << moduleName << endl;
00334 ConfigUpdaterManager::instance().update(*testResult, api);
00335 it=mylist.erase(it);
00336 }
00337 }
00338
00339 sleep (1);
00340
00341 if (nprinted<10) {
00342 cout << "Cal Controller waiting for TestResults (have "
00343 << mylist.size() << " still to go)" << endl;
00344 }
00345 nprinted ++;
00346 }
00347 }
00348
00349 void CalibrationControllerImpl::updateWith(const char * testResultInIs, bool force){
00350 setBusy(true);
00351 try{
00352 Sct_SctApi::SctApiIPC_var api = getApi();
00353 shared_ptr<const TestResult> tr = dynamic_pointer_cast<const TestResult> ( Sct::IS::IOManagerIS::instance().read(testResultInIs) );
00354 if (!tr.get()) throw Sct::IoException(string("Couldnt retrieve ")+testResultInIs , __FILE__, __LINE__);
00355 ConfigUpdaterManager::instance().update(*tr, api, force);
00356 }catch(Sct::Throwable& e){
00357 e.sendToMrs();
00358 }catch(std::exception& e){
00359 Sct::StdExceptionWrapper(e, __FILE__, __LINE__).sendToMrs();
00360 }
00361 setBusy(false);
00362 }
00363
00364 void CalibrationControllerImpl::setUpdateOption(Sct_CalibrationController::CalibrationController::UpdateOption opt) {
00365 cout << "CalibrationContrllerImpl: resetting update option to " << opt;
00366 switch (opt) {
00367 case Sct_CalibrationController::CalibrationController::update : {
00368 status.updateOption="UPDATE";
00369 SctNames::Mrs() << "CC_UPDATE_CHANGE"
00370 << MRS_TEXT("CalibrationControllerImpl setting updateOption=UPDATE") << MRS_DIAGNOSTIC << ENDM;
00371 break;
00372 }
00373 case Sct_CalibrationController::CalibrationController::noupdate : {
00374 status.updateOption="NOUPDATE";
00375 SctNames::Mrs() << "CC_UPDATE_CHANGE"
00376 << MRS_TEXT("CalibrationControllerImpl setting updateOption=NOUPDATE") << MRS_DIAGNOSTIC << ENDM;
00377 break;
00378 }
00379 case Sct_CalibrationController::CalibrationController::wait : {
00380 status.updateOption="WAIT";
00381 SctNames::Mrs() << "CC_UPDATE_CHANGE"
00382 << MRS_TEXT("CalibrationControllerImpl setting updateOption=WAIT") << MRS_DIAGNOSTIC << ENDM;
00383 break;
00384 }
00385 default : {
00386 IllegalStateError e("CalibrationControllerImpl updateOption UNKNOWN", __FILE__, __LINE__);
00387 e.sendToMrs(MRS_DIAGNOSTIC);
00388 break;
00389 }
00390 }
00391 updateStatus();
00392 }
00393
00394 auto_ptr<Test> CalibrationControllerImpl::executeTest(Sct_CalibrationController::TestRequest_ptr tr, shared_ptr<const Sequence> s) {
00395 BugReport("BUG01", "CCImpl.cpp","Starting executeTest");
00396
00397 BugReport("BUG01", "CCImpl.cpp","In executeTest 1");
00398 TestData data;
00399 BugReport("BUG01", "CCImpl.cpp","In executeTest 2");
00400 BugReport("BUG01", "CCImpl.cpp","In executeTest 3");
00401
00402 if (CORBA::is_nil(tr)) {
00403 BugReport("BUG01", "CCImpl.cpp","Ending executeTest early 0");
00404 throw IllegalStateError("Test request pointer was nill", __FILE__, __LINE__);
00405 };
00406
00407 SctNames::Mrs() << "CC_TEST_START" << MRS_TEXT("Calibration Controller starting test") << MRS_INFORMATION << ENDM;
00408 BugReport("BUG01", "CCImpl.cpp","In executeTest 4");
00409 Sct_SctApi::SctApiIPC_var api = getApi();
00410 BugReport("BUG01", "CCImpl.cpp","In executeTest 5");
00411 APICALL(api, setABCDModules(Sct_SctApi::CALIBRATION_CONFIG), "setABCDModules failed")
00412 BugReport("BUG01", "CCImpl.cpp","In executeTest 6");
00413
00414 data.runNumber = runNumber;
00415 BugReport("BUG01", "CCImpl.cpp","In executeTest 7");
00416 data.startScanNumber = nextScanNumber;
00417 BugReport("BUG01", "CCImpl.cpp","In executeTest 8");
00418
00419 {
00420 Sct_CalibrationController::TestPoints_var testPointsOut;
00421 {
00422 BugReport("BUG01", "CCImpl.cpp","In executeTest 9");
00423
00424 BugReport("BUG01", "CCImpl.cpp","In executeTest 10");
00425 CORBA::String_var testNameOut;
00426 BugReport("BUG01", "CCImpl.cpp","In executeTest 10.1");
00427 CORBA::UShort testVariableOut;
00428 BugReport("BUG01", "CCImpl.cpp","In executeTest 10.2");
00429 CORBA::ULong nScansOut;
00430 BugReport("BUG01", "CCImpl.cpp","In executeTest 10.3");
00431 tr->startTest(api, testNameOut, testVariableOut, nScansOut, testPointsOut);
00432 if (CORBA::is_nil(tr)) {
00433 BugReport("BUG01", "CCImpl.cpp","Ending executeTest early 000 .. tr was accidentally made null!");
00434 throw IllegalStateError("Test request pointer was accidentally made nill at ", __FILE__, __LINE__);
00435 };
00436 BugReport("BUG01", "CCImpl.cpp","In executeTest 10.4");
00437 data.testName = testNameOut;
00438 BugReport("BUG01", "CCImpl.cpp","In executeTest 10.5");
00439 data.testVariable = testVariableOut;
00440 BugReport("BUG01", "CCImpl.cpp","In executeTest 10.6");
00441 data.nScans = nScansOut;
00442 BugReport("BUG01", "CCImpl.cpp","In executeTest 11.7");
00443 };
00444
00445 BugReport("BUG01", "CCImpl.cpp","In executeTest 12");
00446 data.testPoints = new double[testPointsOut->length()];
00447 BugReport("BUG01", "CCImpl.cpp","In executeTest 13");
00448 data.testPoints_size = testPointsOut->length();
00449 BugReport("BUG01", "CCImpl.cpp","In executeTest 14");
00450 for (unsigned int i=0; i<testPointsOut->length(); ++i) {
00451 BugReport("BUG01", "CCImpl.cpp","In executeTest 15");
00452 data.testPoints[i] = testPointsOut[i];
00453 BugReport("BUG01", "CCImpl.cpp","In executeTest 16");
00454 }
00455 };
00456
00457 BugReport("BUG01", "CCImpl.cpp","In executeTest 17");
00458 auto_ptr<Test> test (new Test(data, s->getModuleList()));
00459 BugReport("BUG01", "CCImpl.cpp","In executeTest 18");
00460
00461 status.currentTest = test->getUniqueID();
00462 BugReport("BUG01", "CCImpl.cpp","In executeTest 19");
00463 updateStatus();
00464 BugReport("BUG01", "CCImpl.cpp","In executeTest 20");
00465
00466 try {
00467 BugReport("BUG01", "CCImpl.cpp","In executeTest 21");
00468 unsigned int i=0;
00469 bool errorFlag=false;
00470 for (; i<data.nScans; ++i) {
00471 BugReport("BUG01", "CCImpl.cpp","In executeTest 22");
00472 Sct_CalibrationController::ScanRequest_var scan = tr->getNextScan(i);
00473 BugReport("BUG01", "CCImpl.cpp","In executeTest 22.5");
00474 if (CORBA::is_nil(scan)) {
00475 BugReport("BUG01", "CCImpl.cpp","In executeTest 23");
00476 throw IllegalStateError("getNextScan returned zero!", __FILE__, __LINE__);
00477 };
00478 BugReport("BUG01", "CCImpl.cpp","In executeTest 23.5");
00479 if (CORBA::is_nil(scan->getScanCorba())) {
00480 BugReport("BUG01", "CCImpl.cpp","In executeTest 24");
00481 throw IllegalStateError("ScanRequest.getScan returned zero!", __FILE__, __LINE__);
00482 };
00483 BugReport("BUG01", "CCImpl.cpp","In executeTest 25");
00484 test->addScan(scan->getScanCorba());
00485 BugReport("BUG01", "CCImpl.cpp","In executeTest 26");
00486 if (abortNow) {
00487 BugReport("BUG01", "CCImpl.cpp","In executeTest 27");
00488 abortNow = false;
00489 abortRightNow = false;
00490 break;
00491 }
00492 BugReport("BUG01", "CCImpl.cpp","In executeTest 28");
00493 try{
00494 BugReport("BUG01", "CCImpl.cpp","In executeTest 29");
00495 executeScan(scan, i);
00496 BugReport("BUG01", "CCImpl.cpp","In executeTest 30");
00497 }catch(CORBA::Exception& e){
00498 BugReport("BUG01", "CCImpl.cpp","In executeTest 31");
00499 throw CorbaExceptionWrapper(e,"Exception in executeScan", __FILE__, __LINE__);
00500 }
00501 BugReport("BUG01", "CCImpl.cpp","In executeTest 32");
00502 }
00503 BugReport("BUG01", "CCImpl.cpp","In executeTest 33");
00504 if (i == data.nScans && !errorFlag) {
00505 BugReport("BUG01", "CCImpl.cpp","In executeTest 34");
00506 SctNames::Mrs() << "CC_TEST_END" << MRS_TEXT("Calibration Controller ending test") << MRS_INFORMATION << ENDM;
00507 test->setStatus(TestData::COMPLETED);
00508 BugReport("BUG01", "CCImpl.cpp","In executeTest 35");
00509 } else {
00510 BugReport("BUG01", "CCImpl.cpp","In executeTest 36");
00511 SctNames::Mrs() << "CC_TEST_ABORT" << MRS_TEXT("Calibration Controller aborting test") << MRS_INFORMATION << ENDM;
00512 test->setStatus(TestData::ABORTED);
00513 BugReport("BUG01", "CCImpl.cpp","In executeTest 37");
00514
00515 const TestData& testData = test->getData();
00516 setNextScanNumber(testData.startScanNumber + testData.nScans);
00517 }
00518 BugReport("BUG01", "CCImpl.cpp","In executeTest 38");
00519
00520 } catch (SctApiAccessException& e) {
00521 BugReport("BUG01", "CCImpl.cpp","In executeTest 39");
00522 sctApiError(e);
00523 BugReport("BUG01", "CCImpl.cpp","Ending executeTest early 2");
00524 throw;
00525 } catch (CorbaExceptionWrapper& e) {
00526 SctNames::Mrs() << "CC_TEST_ABORT" << MRS_TEXT("Calibration Controller aborting test") << MRS_INFORMATION << ENDM;
00527 test->setStatus(TestData::ABORTED);
00528 BugReport("BUG01", "CCImpl.cpp","In executeTest 40");
00529 e.sendToMrs(MRS_INFORMATION);
00530
00531
00532 const TestData& testData = test->getData();
00533 BugReport("BUG01", "CCImpl.cpp","In executeTest 41");
00534 setNextScanNumber(testData.startScanNumber + testData.nScans);
00535 }
00536 BugReport("BUG01", "CCImpl.cpp","In executeTest 42");
00537
00538
00539 try {
00540 BugReport("BUG01", "CCImpl.cpp","In executeTest 43");
00541 tr->endTest();
00542 BugReport("BUG01", "CCImpl.cpp","In executeTest 44");
00543 } catch (CorbaExceptionWrapper& e) {
00544 BugReport("BUG01", "CCImpl.cpp","In executeTest 45");
00545 e.sendToMrs(MRS_DIAGNOSTIC);
00546 BugReport("BUG01", "CCImpl.cpp","In executeTest 46");
00547 }
00548 BugReport("BUG01", "CCImpl.cpp","In executeTest 47");
00549
00550
00551 try {
00552 BugReport("BUG01", "CCImpl.cpp","In executeTest 48");
00553 APICALL(api, getABCDModules(Sct_SctApi::CALIBRATION_CONFIG), "getABCDModules failed")
00554 BugReport("BUG01", "CCImpl.cpp","In executeTest 49");
00555 APICALL(api, sendABCDModules(Sct_SctApi::PHYSICS_CONFIG), "sendABCDModules failed")
00556 BugReport("BUG01", "CCImpl.cpp","In executeTest 50");
00557 } catch (SctApiAccessException& e) {
00558 BugReport("BUG01", "CCImpl.cpp","In executeTest 51");
00559 sctApiError(e);
00560 BugReport("BUG01", "CCImpl.cpp","In executeTest 52");
00561 e.sendToMrs();
00562 BugReport("BUG01", "CCImpl.cpp","In executeTest 53");
00563 }
00564 BugReport("BUG01", "CCImpl.cpp","In executeTest 54");
00565
00566 BugReport("BUG01", "CCImpl.cpp","Ending executeTest normally");
00567 return test;
00568 }
00569
00570 void CalibrationControllerImpl::executeScan(Sct_CalibrationController::ScanRequest_ptr scan, unsigned int index) {
00571 Sct_SctApi::SctApiIPC_var api = getApi();
00572 ++nextScanNumber;
00573 SctNames::Mrs() << "CC_SCAN_START" << MRS_TEXT("Calibration Controller starting scan") << MRS_INFORMATION << ENDM;
00574
00575 status.currentScanIndex = index;
00576 updateStatus();
00577
00578 SctNames::Mrs() << "CC_SCAN_PART1" << MRS_TEXT("Calibration Controller determining whether scan is raw or cooked ...") << MRS_INFORMATION << ENDM;
00579 if ( scan->isRawCorba() ){
00580 SctNames::Mrs() << "CC_SCAN_PART2" << MRS_TEXT("Calibration Controller thinks scan is raw. Now doingRawScan ...") << MRS_INFORMATION << ENDM;
00581 APICALL(api, doRawScan(scan->getScanCorba(), scan->delayCorba(), scan->widthCorba(), scan->configureModulesCorba(), scan->clockByTwoCorba() ), "doRawScan failed");
00582 }else{
00583 SctNames::Mrs() << "CC_SCAN_PART2" << MRS_TEXT("Calibration Controller thinks scan is cooked. Now doingCookedScan ...") << MRS_INFORMATION << ENDM;
00584 APICALL(api, doScan(scan->getScanCorba() ), "doScan failed");
00585 }
00586 SctNames::Mrs() << "CC_SCAN_PART3" << MRS_TEXT(" ... finished whatever kind of scan we started.") << MRS_INFORMATION << ENDM;
00587
00588
00589
00590
00591
00592
00593 ISInfoInt i;
00594 i.setValue(-1);
00595 ISInfo::Status isStatus = ISInfo::Success;
00596 ISInfoDictionary& is = SctNames::getISDictionary();
00597 int nInitialSleeps = 0;
00598
00599 while ((i.getValue() == -1 && nInitialSleeps < 20) || (i.getValue() == 1 && isStatus == ISInfo::Success)) {
00600 isStatus = is.findValue("SCTAPIServer.scanning", i);
00601 usleep(100);
00602 ++nInitialSleeps;
00603 if (abortRightNow) {
00604 abortRightNow = false;
00605 abortNow = false;
00606 IoException erm("Abort called and SctApi not responding, doScan failed", __FILE__, __LINE__);
00607 throw erm;
00608 }
00609 }
00610
00611 SctNames::Mrs() << "CC_SCAN_END" << MRS_TEXT("Calibration Controller ending scan") << MRS_INFORMATION << ENDM;
00612 }
00613
00614 CalibrationControllerImpl & CalibrationControllerImpl::initialize(RunControl& rc) {
00615 inst = new CalibrationControllerImpl(rc);
00616 return *inst;
00617 }
00618
00619 Sct_CalibrationController::CalibrationController_ptr CalibrationControllerImpl::instance() {
00620 if (!inst)
00621 throw InvariantViolatedError("Need to call CalibrationControllerImpl::initialize first!", __FILE__, __LINE__);
00622 return inst->_this();
00623 }
00624
00625 Sct_CalibrationController::ScanLibrary_ptr CalibrationControllerImpl::getScanLibrary() {
00626 return ScanLibraryImpl::instance();
00627 }
00628
00629 Sct_CalibrationController::TestLibrary_ptr CalibrationControllerImpl::getTestLibrary() {
00630 return TestLibraryImpl::instance();
00631 }
00632
00633 Sct_CalibrationController::SequenceLibrary_ptr CalibrationControllerImpl::getSequenceLibrary() {
00634 cout << "Get Sequence Library" << endl;
00635 return SequenceLibraryImpl::instance();
00636 }
00637
00638 void CalibrationControllerImpl::doScan(Sct_CalibrationController::ScanRequest_ptr scan) {
00639 doTest(DefaultTest::instance(scan));
00640 }
00641
00642 void CalibrationControllerImpl::doTest (Sct_CalibrationController::TestRequest_ptr t) {
00643 doSequence(DefaultSequence::instance(t));
00644 }
00645
00646 void CalibrationControllerImpl::doSequence (Sct_CalibrationController::SequenceRequest_ptr r) {
00647 if (!isInControl() || isBusy()) {
00648 cerr << "Can't execute SequenceRequest - bad status: " << status.status << endl;
00649 return;
00650 }
00651
00652 cout << "do Sequence" << endl;
00653
00654 status.status = status.BUSY;
00655 updateStatus();
00656
00657
00658 m_sequence_request_thread_group.create_thread(SequenceRequestWorker(*this, r));
00659 Sct::BugReport("WARN01","CC","the second argument to this func should probably inherit from the self-destructing portable adapter mixin class ...");
00660 #warning the second argument to this func should probably inherit from the self-destructing portable adapter mixin class ...
00661 }
00662
00663 Sct_SctApi::Scan_ptr CalibrationControllerImpl::getScan(unsigned long runNumber, unsigned long scanNumber) {
00664 cerr << "CalibrationControllerImpl::getScan - Not implemented" << endl;
00665 return Sct_SctApi::Scan::_nil();
00666 }
00667
00668 void CalibrationControllerImpl::updateStatus() {
00669 Sct::BugReport("BUG01","CCImpl.cpp","In updateStatus 1/4");
00670 string name = SctNames::getControlDataName();
00671 Sct::BugReport("BUG01","CCImpl.cpp","In updateStatus 2/4");
00672 name += ".Status";
00673 Sct::BugReport("BUG01","CCImpl.cpp","In updateStatus 3/4");
00674 ISUtilities::addOrUpdateOrMessage(name, status, __FILE__, __LINE__, MRS_DIAGNOSTIC);
00675 Sct::BugReport("BUG01","CCImpl.cpp","In updateStatus 4/4");
00676 }
00677
00678 CalibrationControllerImpl * CalibrationControllerImpl::inst = 0;
00679
00680 }