RunController.cpp

#ifdef linux
#undef linux
#endif

#include "SctApiCall.h"
#include "RunController.h"
#include "SctApiAccessException.h"
#include "CalibrationControllerImpl.h"
#include "ipc/CalibrationController.h"
#include "Sct/SctNames.h"
#include "Sct/StringStreamer.h"
#include "Sct/Exception.h"
#include "Sct/LogicErrors.h"
#include "Sct/MultiMessageDebugStream.h"
#include <rc/RunParams.h>
#include <rc/Controller.h>
#include <ipc/partition.h>
#include <is/info.h>
#include <is/infodictionary.h>
#include <is/infoiterator.h>
#include <is/inforeceiver.h>
#include <is/infoT.h> // for ISInfoInt
#include <pmg/pmg_initSync.h>
#include <iostream>
#include <fstream>
//inserted
#include <signal.h>
#include "cmdl/cmdargs.h"
#include "dal/implementation.h"
#include "config/Configuration.h"
#include "sctConfIPC/configipc.h"
#include "dal/util.h"
#include "Sct/ApplicationStartupDebugTools.h"
#include "Sct/MultiMessageDebugStream.h"

using namespace std;
using namespace Sct;



inline std::string str(const char * word)
{
  return word ? word : "";
} 

extern "C" void signalHandler(int)
{
  CS::ClipsServer * that = CS::ClipsServer::instance();
  if ( that ) that->stop();
}

int main(int argc, char** argv) {

    // USAGE COMMENT: 
    // In tdaq-01-02-00 this program is usually called as follows:
    // AppStartupDbgTools: [ApplicationStartupDebugTools::announceStartOfMain called by [/home/sctroddq/sctsw/SctRodDaq/installed/i686-slc3-gcc323-opt/bin/CalibrationController -n CalibrationController --oks -P SCTRootSegmentController -s SCTSegment -n CalibrationController] in File[/home/sctroddq/sctsw/SctRodDaq/CalibrationController/src/RunController.cpp] at Line[59] with additional Message[].]
    // and the parameters after the --oks (which is probably a throwback to old times) are "invented" by the DSA supervisor.

    using namespace SctCalibrationController;

    cout << "Starting Calibration controller" << endl;
    setExceptionHandlers(argv[0]);
       
    IPCCore::init(argc,argv);
    Sct::ApplicationStartupDebugTools::announceStartOfMain(argc, argv, __FILE__, __LINE__);
    SctNames::Mrs() << "CCRC" << MRS_TEXT("CCRC::main done IPCCore::init") << MRS_DIAGNOSTIC << ENDM;    


   CmdArgStr    partition  ('p',"partition","partition",  "Name of the IPC partition (default $TDAQ_PARTITION)");
   CmdArgStr    parentName ('P',"parentname", "parentname", "Name of the parent");
   CmdArgStr    segName    ('s',"segmentname", "segmentname", "Name of the segment");
   CmdArgStr    name       ('n',"name",     "controller", "Name of the controller",CmdArg::isREQ);
   CmdArgStr    data       ('d',"data",     "db-name",    "Configuration DB name");
   CmdArgStr    rules      ('R',"rules",    "rules",      "CLIPS rulesbase (default Controller:TransitionTable)");
   CmdArgStr    server     ('z',"server",   "is-server",  "Name of the IS server (default RunCtrl)");
   CmdArgInt    verbosity  ('v',"verbosity","level",      "Output level (default 0 )");
   CmdArgBool   oks        ('O',"oks"                     ,"Load Configuration from OKS");
   CmdArgBool   rdb        ('Q',"rdb"                     ,"Load Configuration from RDB");
   CmdArgBool   none       ('N',"none"                    ,"Do not load Configuration");
   
   partition=std::getenv("TDAQ_PARTITION");
   server="RunCtrl";
   verbosity=0;

   CmdLine  cmd(*argv,&partition,&parentName,&segName,&name,&data,&rules,&server,&verbosity,&oks,&rdb,&none,NULL);
   cmd.description("An empty run controller that has just empty user routines.");
   
   CmdArgvIter  argvIter(--argc,++argv);
   if (cmd.parse(argvIter)) 
   {
      std::cerr << "ERROR [rc_empty_controller] Error parsing command line." << std::endl ;
      return EXIT_FAILURE;
   }

   signal(SIGINT,  signalHandler);
   signal(SIGTERM, signalHandler);

   IPCPartition p(partition);

   std::auto_ptr<ConfigurationImpl> configImpl
   (
      none ? 0 : daq::core::create_config_implementation
         (   
            oks ? daq::core::OksDB_Implementation :
            rdb ? daq::core::RdbDB_Implementation :
                  daq::core::DefaultDB_Implementation
         )
   );
    
   std::auto_ptr<Configuration> config(none ? 0 : new Configuration(str(data), configImpl.get()));
   if (config.get()) 
   {
     const daq::core::Partition * part = daq::core::get_partition(*(config.get()), str(partition));
     if(part)
       config->register_converter(new daq::core::SubstituteVariables(*(config.get()), *part));
   } 
      

    RunControl& user = RunControl::instance();
    cout << "Instance created" << endl;

    RC::Controller   controller(p,user,str(name),str(parentName),str(segName),str(rules),config.get(),str(server),
                verbosity);

    {
      Sct::MultiMessageDebugStream m(true,false,true);
      m << "Calibration controller about to sent pmg_initSync()";
    };      
    pmg_initSync();
    controller.run();
    cout << "All over" << endl;

    return controller.exitStatus();
}

namespace SctCalibrationController {

RunControl::RunControl() : cc(CalibrationControllerImpl::initialize(*this)) {
}
    
RunControl& RunControl::instance() {
    static RunControl rc;
    return rc;
}

int RunControl::getRunNumber() {
  if (m_isInfoDictionary.get()) {
    
    RunParams runParams; 
    runParams.run_number = defaultRunNumber;
    SctNames::Mrs() << "RC_DEBUG" << MRS_TEXT(Sct::StringStreamer<< "Before I make any attempt to see the run number my runParams.run_number holds defaultRunNumber="<< runParams.run_number)<< MRS_INFORMATION << ENDM;
    const ISInfo::Status isStatus = m_isInfoDictionary->getValue("RunParams.RunParams",runParams);
    if (isStatus!=ISInfo::Success){
      SctNames::Mrs() << "RC_DEBUG" << MRS_TEXT("The attempt to get the run params was unsuccessful.  Could not determine run number.  Using default one (probably wrong!)")<< MRS_ERROR << ENDM;
      return defaultRunNumber;
    }
    SctNames::Mrs() << "RC_DEBUG" << MRS_TEXT(Sct::StringStreamer<<"After I make any attempt to see the run number my runParams.run_number holds "<< runParams.run_number)<< MRS_INFORMATION << ENDM;
    return runParams.run_number;
  } else {
    SctNames::Mrs() << "RC_getRunNumber" << MRS_TEXT("The CalibrationController's RunController failed to find the Information Service so a default run-number is being returned in place of the correct one!") << MRS_INFORMATION << ENDM;
    return defaultRunNumber;
  };
};
  
bool RunControl::loadAction () {
  // first reload the module configuration
  try{
    SctConfiguration::ConfigIPC config;
    config.loadConfiguration("");
  }catch(Throwable&e){
    e.sendToMrs(MRS_WARNING);
  }catch(CORBA::Exception& e){
    SctNames::Mrs() << "RC_INIT" << MRS_TEXT("Could not connect to config-server") << MRS_ERROR << ENDM;
    return false;  // if the config-server isnt going that's bad
  }

    api = SctNames::getPartition().lookup<Sct_SctApi::SctApiIPC>(Sct_SctApi::SctApiIPC::instanceName);
    if (CORBA::is_nil(api)) {
    SctNames::Mrs() << "RC_INIT" << MRS_TEXT("RunController failed to find SctApi") << MRS_ERROR << ENDM;
    return false;
    }
    cc.setApi(api);

    SctNames::Mrs() << "RC_loadAction" << MRS_TEXT("Trying to get isInfoDictionary ...")<< MRS_INFORMATION << ENDM;
    m_isInfoDictionary = boost::shared_ptr<ISInfoDictionary>(new ISInfoDictionary(SctNames::getPartition()));
    if (!m_isInfoDictionary.get()) {
      SctNames::Mrs() << "RC_INIT" << MRS_TEXT(Sct::StringStreamer<< "RunController failed to find Information Server in partition "<< SctNames::getPartition().name()<<".  This means numbers like the run number will be set to default (probably incorrect) values!") << MRS_ERROR << ENDM;
    } else {
      SctNames::Mrs() << "RC_INIT" << MRS_TEXT(Sct::StringStreamer<< "RunController succeeded in finding Information Server in partition "<< SctNames::getPartition().name()<< ".  This means numbers like the run number should be correct.") << MRS_INFORMATION << ENDM;
    };
    
    try { 
      if (CORBA::is_nil(api)) { throw InvalidArgumentError("Null pointer to SctApi", __FILE__, __LINE__); } 
      try {
    const int rn=getRunNumber();        
    SctNames::Mrs() << "RC_INIT" << MRS_TEXT(Sct::StringStreamer<< "RunController found runNumber="<<rn) 
            << MRS_INFORMATION << ENDM;

    (api)->initialiseAll(rn);
    // wait for the initialisation to complete!
    do {
      usleep(500000);
    } while(!api->isInitialised());

    Sct_SctApi::BankList l;
    l.length(2);
    l[0]=Sct_SctApi::PHYSICS_CONFIG;
    l[1]=Sct_SctApi::CALIBRATION_CONFIG;
    (api)->setABCDModules(l);
      } catch (const CORBA::Exception & exe) { 
    throw raiseSctApiException(exe, "SctApi failed to initialiseAll", __FILE__, __LINE__);
      }
    } catch(SctApiAccessException& e) {
      e.sendToMrs(MRS_ERROR);
      return false;
    }
    SctNames::Mrs() << "RC_INIT" << MRS_TEXT("CC RunController initialised SctApi") << MRS_DIAGNOSTIC << ENDM;
    
    return true;
}

  std::string RunControl::getRunType() const {
    
    RunParams runParams;
    ISInfoDictionary& is = SctNames::getISDictionary();
    ISInfo::Status isStatus;
    
    isStatus = is.findValue("RunParams.RunParams", runParams);
    
    if (isStatus!=ISInfo::Success){
      Sct::MultiMessageDebugStream m(true,true,true);
      m.severity(MRS_ERROR);
      m << "CalibrationController failed to find RunParameters at line " << __LINE__ << " in " << __FILE__ << " so can't tell which RunType should be entered (eg Physics/Calibration)";
      m.flush();
      return "";
    }
    
    const std::string run_type = runParams.run_type; // Will be a string like "Physics" or "Calibration" or perhaps even "Cosmics" ?
    
    return run_type;
  };

  bool RunControl::sendRunTypeToSctApi() const {
    const bool success=true;
    const bool failure=!success;

    std::string run_type = this->getRunType();
    Sct::MultiMessageDebugStream m(true,false,true);
    if (run_type == "Physics") {
      m << "Configuring according to Physics run mode";
      m.flush();
      APICALL(api, changeRunMode(Sct_SctApi::PHYSICS_RUN_TYPE), "SctApi failed to changeRunMode to PHYSICS_RUN_TYPE for Physics mode");
      // Bruce says this line should not be here: APICALL(api, timWriteRegister(0, 0, 0, 0x3f00), "SctApi failed to set the tim up to use external triggers for Physics mode");   
      return success;
    } else if (run_type == "Calibration") {
      m << "Configuring according to Calibration run mode";
      m.flush();
      APICALL(api, changeRunMode(Sct_SctApi::CALIBRATION_RUN_TYPE), "SctApi failed to changeRunMode to CALIBRATION_RUN_RTPE for Calibration mode");
      return success;
    } else {
      m.severity(MRS_WARNING);
      m << "The run-type '" << run_type << "' is not recognised by the CalibrationController at line " << __LINE__ << " of " << __FILE__ << ".  If this mode needs any special configuration settings, they will not have been taken into account!";
      m.flush();
      return failure;
    };
    // should not be able to get here
    return failure;
  };

bool RunControl::configureAction() {
    cout << "CC configureAction" << endl;
    try {

      // send PHYSICS to all
      APICALL(api, configureAllModules(), "SctApi failed to configureAllModules");
      
    } catch(SctApiAccessException& e) {
        e.sendToMrs(MRS_ERROR);
        return false;
    }

    
    SctNames::Mrs() << "RC_CONFIG" << MRS_TEXT("CC RunController configured SctApi") << MRS_DIAGNOSTIC << ENDM;
    return true;
}

bool RunControl::prepareAction() {
    cout << "CC prepare action" << endl;
    if (CORBA::is_nil(api)) {
    cout << "Can't enter PREPARE as we don't have the api" << endl;
    return false;
    }

    RunParams runParams;
    ISInfoDictionary& is = SctNames::getISDictionary();
    ISInfo::Status isStatus;

    isStatus = is.findValue("RunParams.RunParams", runParams);

    if (isStatus!=ISInfo::Success){
      SctNames::Mrs() << "RC_PREPARE" << MRS_TEXT("CalibrationController failed to find RunParameters") << MRS_ERROR << ENDM;
      return false;
    }

    try {
        APICALL(api, setRunNumber(runParams.run_number), "Failed to set run number")
        APICALL(api, setScanNumber(0), "Failed to set scan number")
        cout << "New Run, setting run number and scan number: " << runParams.run_number << "  " << 0 << endl;
    // set run mode based on RunParams.run_type
    this->sendRunTypeToSctApi();
        cc.takeControl(runParams.run_number);
    } catch (SctApiAccessException& e) {
        e.sendToMrs(MRS_ERROR);
        return false;
    }
    return true;
}

bool RunControl::stopEFAction() {
    cout << "CC exit stopFE action" << endl;
    cc.giveupControl();
    return true;
}

bool RunControl::unloadAction () {
    cout << "CC unloadaction" << endl;

    try {
        APICALL(api, shutdownAll(), "Could not shutdown all")
    } catch (SctApiAccessException& e) {
        e.sendToMrs(MRS_ERROR);
        return false;
    }
    cc.reset();

    return true;
}

bool RunControl::resetAction () {
    cout << "CC resetAction" << endl;
    cc.reset();
    return true;
}

void RunControl::sctApiError(const string& reason) {
  SctNames::Mrs() << "CC_API_ERROR" << MRS_PARAM<const char*>("reason",reason.c_str()) 
          << MRS_TEXT("Calibration Controller found error with SctApi") << MRS_WARNING << ENDM;
    this->raiseError("API_ERROR");
    cc.giveupControl();
}

}

---