Application.cpp

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <errno.h>

// Include files
#include "Options.h"
#include "DLLMgr.h"
#include "Hierarchy.h"
#include "Element.h"
#include "Computer.h"
#include "Processus.h"
#include "ProcDataBase.h"
#include "System.h"
#include "Server.h"

// local
#include "Application.h"

//-----------------------------------------------------------------------------
// Implementation file for class : Application
//
// 2006-10-23 :
//-----------------------------------------------------------------------------

//=============================================================================
// Standard constructor, initializes variables
//=============================================================================
Application::Application(  ) :
  m_options  (0),
  m_dllMgr   (0),
  m_procDb   (0),
  m_computer (0),
  m_processus(0),
  m_state    (0),
  m_config   (0),
  m_server   (0)
{
  setApplication(this);
  m_options     = new Options  ();
  m_accountName = System::accountName();
  m_hostName    = System::hostName();
  m_osName      = System::osName();
  m_osVersion   = System::osVersion();
  m_dllMgr      = new DLLMgr   ();
  m_procDb      = new ProcDataBase ();
  m_computer    = new Computer ();
  m_state       = new State();
  m_config      = new Config();
  setCurrent ( (Hierarchy*) (m_computer) );
}

//=============================================================================
// Destructor
//=============================================================================
Application::~Application() {
  if (  0!=m_server ) {
    delete m_server;
    m_server = 0;
  }
  delete m_state;
  delete m_config;
  delete m_options;
  delete m_dllMgr;
  delete m_procDb;
  //  delete m_computer;
}

//=========================================================================
//
//=========================================================================
StatusCode Application::initialize ( ) {
  setType("SOFTWARE");
  add(Attrib::SOFTWARE);

  setName ( hostname() );

  m_network=false;
  m_server=0;

  m_ctrl=std::string("");

  m_state  = new State();
  m_config = new Config();

  /*
    setRunSvc ( *svcRunning );
    setPlotSvc (*svcPlot );
  */

  setState ( "READY" );
  setConfig( );

  banner  ();
  loadHistoryFile();

  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
void Application::banner ( ) {
#ifdef _WIN32
  //  system("cls");
#else
  //  system("clear");
#endif
  msgSvc(0,"","");
  msgSvc(0,"                          ***********************************************","");
  msgSvc(0,"                          *               C      A      T               *","");
  msgSvc(0,"                          *                                             *","");
  msgSvc(0,"                          *          |\\-''-/|.___..--''\"`-._            *","");
  msgSvc(0,"                          *          `6_ 6  )   `-.  (     ).`-.__.`)   *","");
  msgSvc(0,"                          *          (_Y_.)'  ._   )  `._ `. ``-..-'    *","");
  msgSvc(0,"                          *         _..`--'_..-  _/ /--'_.' ,'          *","");
  msgSvc(0,"                          *     (il),-''  (li),' ((!.-'                 *","");
  msgSvc(0,"                          ***********************************************","");
  msgSvc(0,"","");
  msgSvc(0,"Application running on "+
     m_accountName+"@"+
     m_hostName+" ("+
     m_osName+" - "+
     m_osVersion+")","");
}

//=========================================================================
//
//=========================================================================
StatusCode Application::run ( std::string procName,
                              Element* element,
                              int nEvent ) {
  if ( prepare(procName, element, nEvent).isFailure() ) return StatusCode::FAILURE;
  StatusCode status = svcRunning();
  if (terminate().isFailure()) return StatusCode::FAILURE;
  return status;
}

//=========================================================================
//
//=========================================================================
StatusCode Application::finalize ( ) {
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode Application::loadHistoryFile(){
  // Load last session parameters
  std::string filename = System::getEnv("CATPATH");
  filename.append("/.cathist");
  std::ifstream last;
  last.open( filename.c_str() );
  if ( !last.fail() ) {
    int nrun;
    last >> nrun;
    info("Recovering last run number : "+itos(nrun)+". Will start from "+itos(nrun+1)+".","Application:loadHistoryFile");
    application()->options()->setRunNumber( nrun+1 );
  }
  else {
    info("No history file found.","Application:loadHistoryFile");
    return StatusCode::FAILURE;
  }
  last.close();
  return StatusCode::SUCCESS;
}

//=========================================================================
StatusCode Application::bookkeeping ( ) {
  std::string filename = System::getEnv("CATPATH");
  filename.append("/.cathist");
  std::ofstream last;
  last.open( filename.c_str() );
  if ( last.fail() ) {
    warning("Cannot do the bookkeeping","Application::bookkeeping");
    return StatusCode::FAILURE;
  }
  else {
    last << application()->options()->runNumber();
  }
  last.close();
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode Application::makeDir ( std::string directory ){
  if (mkdir(directory.c_str(), 0777) == -1) { // Create the directory
    warning("Could not create directory "+directory+". Error "+strerror(errno),"Application:makeDir");
    return(StatusCode::FAILURE);
  }
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
State* Application::state ( ) {
  /*
    info("nRun    "+itos(m_state->nRun),"Application::state");
    info("nEvtMax "+itos(m_state->nEventMax),"Application::state");
    info("nEvt    "+itos(m_state->nEvent),"Application::state");
    info("nErrors "+itos(m_state->nErrors),"Application::state");
    info("status  "+std::string(m_state->status) ,"Application::state");
  */
  return m_state;
}

//=========================================================================
//
//=========================================================================
Config* Application::config ( ) {
  return m_config;
}

//=========================================================================
//
//=========================================================================
void Application::setState (std::string status) {
  if ( 0 != m_server ) {
    m_state->nRun      = m_options->runNumber();
    m_state->nEventMax = m_options->nEvtMax();
    m_state->nEvent    = m_options->nEvt();
    m_state->nErrors   = m_options->nErrors();
    if (status.compare("")!=0) strcpy(m_state->status,status.c_str());
    // and ... update !
    m_server->updateState();
  }
}

//=========================================================================
//
//=========================================================================
void Application::setConfig () {
  if ( 0 != m_server ) {
    // current element
    Element* element=dynamic_cast<Element*>(m_current);
    if (0==element)
      {
    warning("Cannot find the Element at the current position of the Hierarchy",
        "Application::setConfig");
      }
    std::string current=m_current->name();
    current.append("[");
    current.append(m_current->type());
    current.append("] ");
    //    strcpy(m_config->currentElement,current.c_str());

    // reachable processus list
    std::list<Processus*> listproc = procDb()->procList ( element );
    std::list<Processus*>::iterator proc;
    for (proc=listproc.begin(); proc!=listproc.end(); ++proc) {
      if ( proc!=listproc.begin() ) { current.append(":"); }
      current.append((*proc)->name());
    }
    current.append(" ");
    //    strcpy(m_config->procList,process.c_str());

    // list of children
    std::vector<Hierarchy*> list = m_current->children ();
    std::vector<Hierarchy*>::iterator iter;
    for (iter=list.begin(); iter!=list.end(); ++iter) {
      if ( iter!=list.begin() ) { current.append(":"); }
      current.append((*iter)->name());
      current.append("[");
      current.append((*iter)->type());
      current.append("]");
    }

    // finally ...update !
    strcpy(m_config->config,current.c_str());
    m_server->updateConfig();
  }
}


//=========================================================================
//
//=========================================================================
void Application::network ( std::string name = std::string("")) {
  if ( name.compare("")==0 ) {
    application()->setName ( name );
  }
  if (!m_network) {
    m_network = true;
    m_server = new Server ( this );
    m_server->start();
    if ( m_network ) {
      info("Update server information.","Application::network");
      setConfig ();
      setState  ("READY");
    }
  }
  else {
    info("Stop network connection.","Application::network");
    m_network = false;
    delete m_server;
    m_server = 0;
  }
}


//=========================================================================
//
//=========================================================================
void Application::server (  ) {
  if ( 0 != m_server ) {
    info("Delete CAT server.","Application::server");
    delete m_server;
    m_server = 0;
  }
  else {
    m_server = new Server ( this );
    m_server->start();
    info("Update server information.","Application::server");
    setConfig ();
    setState  ();
  }
}

//=========================================================================
//
//=========================================================================
StatusCode Application::create( std::string name, std::string type)
{
  Element *obj = m_dllMgr->createElement(type);
  if ( !obj ) {
    warning("Type '" + type + "'  not understood");
    return StatusCode::FAILURE;
  }
  obj->setName( name );
  obj->setParent(m_current);
  m_current->addChild( obj );
  setCurrent( obj );
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode Application::svcRunning ( ) {
  while ( m_options->nEvt() < m_options->nEvtMax() ) {
    if ( loop().isFailure() )
      {
    return StatusCode::FAILURE;
    break;
      }
    std::string control = ctrl();
    if ( 0 == control.compare("pause") ) {
      setState ( "PAUSE" );
      warning("Pause.","Application::svcRunning");
      bool pause = true;
      while ( pause ) {
    std::string newctrl = ctrl();
    int delay = 1000; // delay in loop in ms
    usleep( 1000 * delay );
    if ( 0==newctrl.compare ("stop") ) {
      pause = false;
    }
    if ( 0==newctrl.compare ("resume") ) {
      setState ( "RUNNING" );
      pause = false;
    }
    newctrl.clear();
      }
      control.clear();
    }
    if ( 0 == control.compare("stop") ) {
      info("User interruption.","Application::svcRunning");
      control.clear();
      return StatusCode::SUCCESS;
      break;
    }
  }
  return StatusCode::SUCCESS;
}


//=========================================================================
//
//=========================================================================
StatusCode Application::svcPlot ( ) {
  warning("No implementation in cmd mode yet.","Application::svcPlot");
  return StatusCode::FAILURE;
}


//=========================================================================
//
//=========================================================================
StatusCode Application::prepare ( std::string procName,
                                  Element* element,
                                  int nEvent ) {

  verbose("Prepare for a new run.","Application::prepare");

  if (0==element) element = dynamic_cast<Element*>(m_current);

  std::list<Processus*> listproc = procDb()->procList ( element );
  std::list<Processus*>::iterator proc;

  Processus *process = 0;

  for (proc=listproc.begin(); proc!=listproc.end(); ++proc) {
    if ( procName.compare( (*proc)->name() ) == 0 ) {
      process = (*proc)->clone();
      //--------------------
      // Did not chose to make copies : use original processus !
      //      info("orig="+itos((int)(*proc)));
      //      process = (*proc)->clone();
      //      info("orig="+itos((int)(process)));
      break;
    }
  }
  if ( 0==process) {
    warning("Processus " + procName + " not found.","Application::prepare");
    setState ( "READY" );
    return StatusCode::FAILURE;
  }
  if (0!=m_processus) {
    m_processus->clean();
    //--------------------
    // did not chose to make copies
    //    delete m_processus;
  }
  m_processus = process;
  m_options->setNErrors ( 0 );
  m_options->setNEvt ( 0 );
  //  unsigned long currentNEvtMax  = m_options->nEvtMax();
  m_options->setNEvtMax ( nEvent );
  if (nEvent<0) {
    m_options->setTimeMax(int(((double)(CLOCKS_PER_SEC))/1.e11*(clock()-nEvent)));
    //    info("Time max is ", itos(m_options->timeMax()));
  }
  bookkeeping();
  if (m_options->dataStorage() || m_options->logStorage()) {
    if (makeDir(m_options->storageFullPath()).isFailure()) {
      warning("Could not create storage directory "+m_options->storageFullPath(),"Application::prepare");
      return StatusCode::FAILURE;
    }
  }
  if (m_options->dataStorage() || m_options->logStorage()) {
    m_options->setStorageFile ( m_processus->storage() );
    if (m_options->logStorage()) {m_options->setStream(m_options->storageFile()); }
  }
  m_processus->setElement( element );
  if ( (m_processus->startProcessing()).isFailure() ) {
    warning("Program initialization interrupted.","Application::prepare");
    return StatusCode::FAILURE;
  }
  setState ( "RUNNING" );
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode Application::loop ( ) {
  m_options->incNEvt();
  unsigned long currentNEvt = m_options->nEvt();
  state()->nEvent++;
  if( m_options->printFreq()>0) {
    if ( 0 == currentNEvt % m_options->printFreq() ) {
      info("[Processing evt "+itos(currentNEvt)+"]","Application::loop");
    }
  }
  if ( (m_processus->execute()).isFailure() ) {
    warning("An Error occured ["+itos(m_options->nErrors())+"].","Application::loop");
    m_options->incNErrors();
    if (m_options->stopOnError()) {
      warning("Program automatically Stopped after " +
          itos ( currentNEvt ) + " event(s).","Application::loop");
      //      m_options->setNEvt(m_options->nEvtMax());
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

//=========================================================================
//
//=========================================================================
StatusCode Application::terminate ( ) {
  m_processus->endProcessing();
  info("Processus " + m_processus->name() +" '" +
       std::string(m_processus->title().c_str()) +
       "' completed [" +
       itos( m_options->nEvt() ) + " events]",
       "Application::svcRunning");
  if ( m_options->logStorage()) {
    m_options->setStream();
  }
  //  graphSvc();
  //  m_options->setNEvtMax ( currentNEvtMax );
  if (m_options->runNumberManagement() ) m_options->incRunNumber ( );
  m_options->setNEvt ( 0 );
  setState ( "READY" );
#ifdef _NETWORK_
  m_processus->updateServices();
#endif
  return StatusCode::SUCCESS;
}


//=============================================================================