lemAutoRun.cpp

Go to the documentation of this file.

/********************************************************************************************

  lemAutoRun.cpp

*********************************************************************************************

    begin                : Andreas Suter, 2006/03/14
    modfied:             :
    copyright            : (C) 2006 by
    email                : andreas.suter@psi.ch

********************************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <iostream>
using namespace std;

#include <stdlib.h>
#include <string.h>

#include <QCoreApplication>
#include <QObject>
#include <QString>

#include <QFile>
#include <QTimer>

#include "PAutoRunParser.h"
#include "PErrorHandler.h"
#include "PLemAutoRun.h"

#include "msystem.h"

//---------------------------------------------------------------------------------------
int lar_wrong_syntax(int argc, char *argv[], QString &host, QString &exp, bool &daemon)
{
  int wrong = 0;

  host = "";
  exp  = "";
  daemon = false;

  if ((argc < 1) || (argc > 6)) // number of arguments out of range
    return 1;

  switch (argc) {
    case 1: // only calling argument
      break;
    case 2: // only '-D' possible
      if (strstr(argv[1], "-D")) {
        daemon = true;
        wrong = 0;
      } else {
        wrong = 1;
      }
      break;
    case 3: // -h Hostname or -e Experiment possible
      if (strstr(argv[1], "-h")) {
        host = argv[2];
        wrong = 0;
      } else if (strstr(argv[1], "-e")) {
        exp = argv[2];
        wrong = 0;
      } else {
        wrong = 1;
      }
      break;
    case 4: // (-h Hostname or -e Experiment possible) and '-D'
      if (strstr(argv[3], "-D")) {
        daemon = true;
        if (strstr(argv[1], "-h")) {
          host = argv[2];
          wrong = 0;
        } else if (strstr(argv[1], "-e")) {
          exp = argv[2];
          wrong = 0;
        } else {
          wrong = 1;
        }
      } else {
        wrong = 1;
      }
      break;
    case 5: // -h Hostname -e Experiment or -e Experiment -h Hostname
      if (strstr(argv[1], "-h")) {
        host = argv[2];
        if (strstr(argv[3], "-e")) {
          wrong = 0;
          exp = argv[4];
        } else {
          wrong = 1;
        }
      } else if (strstr(argv[1], "-e")) {
        exp = argv[2];
        if (strstr(argv[3], "-h")) {
          wrong = 0;
          host = argv[4];
        } else {
          wrong = 1;
        }
      } else {
        wrong = 1;
      }
      break;
    case 6: // (-h Hostname -e Experiment or -e Experiment -h Hostname) and '-D'
      if (strstr(argv[5], "-D")) {
        daemon = true;
        if (strstr(argv[1], "-h")) {
          host = argv[2];
          if (strstr(argv[3], "-e")) {
            wrong = 0;
            exp = argv[4];
          } else {
            wrong = 1;
          }
        } else if (strstr(argv[1], "-e")) {
          exp = argv[2];
          if (strstr(argv[3], "-h")) {
            wrong = 0;
            host = argv[4];
          } else {
            wrong = 1;
          }
        } else {
          wrong = 1;
        }
      } else {
        wrong = 1;
      }
      break;
    default:
      wrong = 1;
      break;
  }

  return wrong;
}

//---------------------------------------------------------------------------------------
void lar_syntax()
{
  cout << endl << "usage: lemAutoRun [-h Hostname] [-e Experiment] [-D start as daemon]";
  cout << endl << endl;
}

//---------------------------------------------------------------------------------------
int main(int argc, char *argv[])
{
  // create main Qt application entry point, the last entry forces it to be a console application
  QCoreApplication app(argc, argv, false);

  QString host = "";
  QString exp  = "";
  bool    daemon;

  PLemAutoRun       *autoRun;
  PAutoRunParser    *autoRunParser;
  PErrorHandler     *errorHandler;
  PAutoRunCmdVector *autoRunCmdVector;
  POdbTagVector     *odbTagVector;

  // check arguments
  if (lar_wrong_syntax(argc, argv, host, exp, daemon)) {
    lar_syntax();
    return 0;
  }

  // should start as a daemon
  if (daemon){
    printf("Becoming a daemon...\n");
    ss_daemon_init(FALSE);
  }

  // create auto run object and error handler
  autoRun      = new PLemAutoRun(host, exp);
  errorHandler = new PErrorHandler();

  // connect autoRun with errorHandler
  QObject::connect(autoRun, SIGNAL(ErrorMsg(int,int,int,int,QString)),
                   errorHandler, SLOT(HandleErrors(int,int,int,int,QString)));
  // connect errorHandler with autoRun
  QObject::connect(errorHandler, SIGNAL(Terminate()),
                   autoRun, SLOT(DisconnectAndQuit()));

  // try to read startup XML file
  autoRun->ReadStartupXML();

  // try to connect to MIDAS
  autoRun->ConnectToExp();
  if (!autoRun->IsConnected()) {
    delete errorHandler;
    delete autoRun;
    return 1;
  }

  // try to read the sample cryo parameter XML file
  autoRun->ReadSampleCryoXML();

  // create auto run sequnce parser and object
  autoRunCmdVector = new PAutoRunCmdVector();
  odbTagVector = new POdbTagVector();
  autoRunParser = new PAutoRunParser(autoRun->GetUserAutoRunSeqFln(),
                                     *autoRun->GetXMLSchemaFln(),
                                     *autoRun->GetXMLAutoRunFln(),
                                     autoRunCmdVector,
                                     odbTagVector);

  // connect autoRunParser with errorHandler of PLemAutoRun
  QObject::connect(autoRunParser, SIGNAL(ParseError(int,int,int,int,QString)),
                   autoRun, SLOT(HandleParseError(int,int,int,int,QString)));
  
  // connect autoRunParser with errorHandler of PErrorHandler
  QObject::connect(autoRunParser, SIGNAL(ParseError(int,int,int,int,QString)),
                   errorHandler, SLOT(HandleErrors(int,int,int,int,QString)));

  if (autoRun->IsIdle()) {
    // write autoRun into the LiveData record
    autoRun->FeedLiveDataAutoRun();

    // convert user auto run sequence to the XML auto run sequence
    autoRunParser->ConvertToXML();

    // parse the XML auto run sequence
    autoRunParser->Parse();

    // get auto run sequence from parser
    autoRun->SetAutoRunSeq(autoRunCmdVector);

    // get ODB tag vector from parser
    autoRun->SetOdbTagVec(odbTagVector);

    // start auto run sequence
    autoRun->ExecAutoRun();
  } else {
    cm_msg(MERROR, "lemAutoRun", "lemAutoRun is NOT idle?! Something is wrong, please check.");
  }

  // disconnect form MIDAS
  autoRun->DisconnectFromExp();
  
  // clean up objects
  if (autoRunParser)
    delete autoRunParser;
  if (autoRunCmdVector)
    delete autoRunCmdVector;
  if (odbTagVector)
    delete odbTagVector;
  if (errorHandler)
    delete errorHandler;
  if (autoRun)
    delete autoRun;

  return 0;
}

//---------------------------------------------------------------------------------------
// end
//---------------------------------------------------------------------------------------