AugerOfflineMain.cc

Go to the documentation of this file.

#ifdef _GNU_SOURCE
#  include <fenv.h>
#endif

#include <fwk/RunController.h>
#include <fwk/CentralConfig.h>
#include <fwk/CommandLineOptions.h>
#include <fwk/GITGlobalRevision.h>
#include <utl/ErrorLogger.h>
#include <utl/AugerException.h>
#include <utl/TabularStream.h>
#include <utl/Deprecator.h>
#include <config.h>
#ifndef AUGER_SQLITE_ENABLED
#  include <det/VSQLManager_MySQL.h>
#endif

#include <boost/filesystem/operations.hpp>
#include <boost/program_options.hpp>

#include <sstream>
#include <algorithm>

using namespace fwk;
using namespace std;
using namespace utl;
namespace fs = boost::filesystem;
namespace po = boost::program_options;


void AugerOfflineUser();


namespace fwk {

  class Trailer {
  public:
    Trailer(const string& text) : fText(text) { }
    ~Trailer() { cerr << fText << endl; }
  private:
    string fText;
  };


  string
  Red(const string& str)
  {
    if (ErrorLogger::GetInstance().HasColor())
      return "\033[1;31m" + str + "\033[0m";
    else
      return str;
  }

}


int
main(int argc, char* argv[])
{
  fs::initial_path();  // required for saving startup value

  string bootstrapFile("bootstrap.xml");
  string logFile;
  int verbosity = 0;
  int fpException = 0;
  int logDbQueries = 0;
  po::options_description desc("Usage:");
  desc.add_options()
    ("help,h",
     "write this message")
    ("bootstrap,b",
     po::value<string>(&bootstrapFile),
     "Bootstrap file name. Defaults to './bootstrap.xml' if this option is not used.")
    ("log,l",
     po::value<string>(&logFile),
     "Write out a log file.")
    ("fingerprintFatal,f",
     "If option is used, throw exceptions in case of mismatch of config file md5 fingerprints.")
    ("verbosity,v",
     po::value<int>(&verbosity)->default_value(Verbosity::eDefault),
     "Verbosity: -1=default, 0=silent... 3=annoying")
    ("color,c",
     "Colorize output")
    ("fpexception,x",
     po::value<int>(&fpException),
     "Unmask specific floating-point exceptions for debugging: 1=invalid-sqrt(-1), 4=div-by-0, 8=overflow.")
    ("log-db-queries",
     po::value<int>(&logDbQueries)->default_value(logDbQueries),
     "switch on logging of all SQL queries")
    ("show-available-modules",
     "show available Offline modules")
    ;

  po::variables_map vm;
  try {
    po::store(po::parse_command_line(argc, argv, desc), vm);
    po::notify(vm);
  } catch (po::error& er) {
    cerr << "Command line error : " << er.what() << '\n'
         << desc << endl;
    return EXIT_FAILURE;
  }

  if (vm.count("help")) {
    cerr << desc << endl;
    return EXIT_SUCCESS;
  }

  auto& errorLogger = ErrorLogger::GetInstance();
  if (vm.count("color"))
    errorLogger.SetColorOutput(true);

  errorLogger.SetVerbosity(Verbosity::eDefault);
  if (vm.count("verbosity")) {
    const auto v = vm["verbosity"].as<int>();
    errorLogger.SetVerbosity(static_cast<Verbosity::EVerbosity>(
      min(int(Verbosity::eDefault), max(int(Verbosity::eDefault), v))
    ));
  }

  if (vm.count("show-available-modules")) {
    cout << "# list of registered Offline modules:\n";
    for (auto it = VModuleFactory::Begin(); it != VModuleFactory::End(); ++it)
      cout << it->first << '\n';
    cout << endl;
    return EXIT_SUCCESS;
  }

#ifdef _GNU_SOURCE
  if (vm.count("fpexception"))
    feenableexcept(fpException);
#else
  if (vm.count("fpexception"))
    cerr << "floating-point exceptions will not be enabled on this architecture..." << endl;
#endif

#ifndef AUGER_SQLITE_ENABLED
  if (vm.count("log-db-queries"))
    det::VSQLManager::SetGlobalLogQueries(vm["log-db-queries"].as<int>());
#endif

  // Header
  {
    ostringstream os;

    os << '\n'
       << Red(
          "          ___________________\n"
          "          __       _      _     /   ,\n"
          "        /    )   /  `   /  `   /        __    _\n"
          "       /    /  _/__   _/__    /   /   /   ) /___)\n"
          "      /    /   /      /      /   /   /   / (___\n"
          "     (____/   /      /      __________________\n"
          )
       << "\n"
          " " << OFFLINE_PACKAGE_STRING << "\n"
          " Reference: Nucl. Instrum. Meth. A 580 (2007) 1485." << "\n"
          " GIT revision number : " << GITGlobalRevision::GetInstance().GetId() << "\n"
          " Bug reports to : " << OFFLINE_PACKAGE_BUGREPORT << "\n"
          " ____________________________________________________\n";

    INFO(os);
  }

  // Trailer
  TabularStream tab("l");
  tab << endr << HLine('=')
      << "End of run: " << OFFLINE_PACKAGE_STRING << endr
      << "GIT revision number: " << GITGlobalRevision::GetInstance().GetId() << endr
      << HLine('=');
  static Trailer trailer(tab.Str());

  // Create the CentralConfig and parse the bootstrap file
  if (vm.count("fingerprintFatal"))
    CentralConfig::GetInstance(bootstrapFile, true);
  else
    CentralConfig::GetInstance(bootstrapFile, false);

  // end parsing options, send to CentralConfig
  fwk::CommandLineOptions::GetInstance().SetVariablesMap(vm);

  // Pass control to user for possible custom sequencing
  AugerOfflineUser();

  // Run the chain
  auto& myController = RunController::GetInstance();

  try {
    myController.Init();
  } catch (ModuleSequenceException& ex) {
    ERROR("ModuleSequenceException thrown. Abnormal termination in RunController Init().");
    return EXIT_FAILURE;
  }

  try {
    myController.Run();
  } catch (ModuleSequenceException& ex) {
    ERROR("ModuleSequenceException thrown. Abnormal termination in RunController Run().");
    return EXIT_FAILURE;
  }

  try {
    myController.Finish();
  } catch (ModuleSequenceException& ex) {
    ERROR("ModuleSequenceException thrown. Abnormal termination in RunController Finish()");
    return EXIT_FAILURE;
  }

  if (vm.count("log"))
    CentralConfig::GetInstance()->WriteConfig(logFile);

  const auto& d = Deprecator::GetInstance();
  if (!d.IsEmpty()) {
    WARNING("*** The following deprecated methods were used:\n\n" +
            d.GetReport() +
            "Please update your code.");
  }

  return EXIT_SUCCESS;
}


/*
  Old logo saved for posterity.

               _/_/        _/_/    _/_/  _/  _/
            _/    _/    _/      _/      _/      _/_/_/      _/_/
           _/    _/  _/_/_/_/_/_/_/_/  _/  _/  _/    _/  _/_/_/_/
          _/    _/    _/      _/      _/  _/  _/    _/  _/
           _/_/      _/      _/      _/  _/  _/    _/    _/_/_/

*/