DataQueue.cc File Reference

#include <iostream>
#include <string>
#include <cassert>
#include <JRuncontrol/JDAQClient.hh>
#include <JLogger/JControlHostLogger.hh>
#include <JLogger/JMessageLogger.hh>
#include <JDAQ/JDAQTags.hh>
#include <CLBInterface/data_input_interface.hh>
#include <FrameFactory/frame_farm.hh>
#include <DFInterface/DFInterface.hh>
#include "debug_abrt.hh"
#include "log.hh"
#include <boost/program_options.hpp>
#include <boost/foreach.hpp>
#include <boost/scoped_ptr.hpp>
#include "configure.hh"
#include "version.hpp"

Go to the source code of this file.

Classes
class	KM3NETDAQ::DataQueue

Namespaces
	KM3NETDAQ
	KM3NeT DAQ data structures and auxiliaries.

Functions
void	initLogger (JLOGGER::JMessageLoggerThreadSafe const &second)
void	setLogLevel (int level)
static void	monitor ()
int	main (int argc, char *argv[])

Function Documentation

initLogger()

void initLogger

(

JLOGGER::JMessageLoggerThreadSafe const &

second

)

Author

cpellegrino

setLogLevel()

void setLogLevel

(

int

level

)

Definition at line 43 of file jlog.cc.

{
  // This shall be protected from race conditions with a mutex to avoid UB.
  // But this very UB won't really produce any problem, hopefully.
  MLSing::get().logger().setLevel(level);
}

monitor()

static void monitor ( )

static

Definition at line 32 of file DataQueue.cc.

{
  LOG_NOTICE << "# pframes: "   << PuzzledFrame::n_obj
             << " - # dgrams: " << CLBDataGram::n_obj << " - "
             << Log::Counter::get();
}

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 309 of file DataQueue.cc.

{
  __debug_abort_on_wrong_size_<CLBCommonHeader>(40);
  __debug_abort_on_wrong_size_<DAQCommonHeader>(56);
  __debug_abort_on_wrong_size_<UTCTime>(8);
 
  std::string server("localhost");
  std::string logger("localhost");
  std::string client_name("DataQueue");
  int debug = 0;
 
  po::options_description desc("Options");
  desc.add_options()
      ("help,h", "Print this help and exit.")
      ("version,v", "Print the version and exit.")
      ("optical,o", "Set the optical mode.")
      ("acoustic,a", "Set the acoustic mode.")
      (",H",
          po::value<std::string>(&server)->default_value(server),
          "Set the address of the SM server.")
      (",M",
          po::value<std::string>(&logger)->default_value(logger),
          "Set the address of the logger server.")
      (",u",
          po::value<std::string>(&client_name)->default_value(client_name),
          "Set the address of the client name.")
      (",d",
          po::value<int>(&debug)->default_value(debug),
          "Set the debug level.");
 
  bool acou = false, opto = false;
 
  try
  {
    po::variables_map vm;
    po::store(
        po::command_line_parser(argc, argv).options(desc).run(),
        vm);
 
    if (vm.count("help"))
    {
      std::cout << desc << std::endl;
      return EXIT_SUCCESS;
    }
 
    if (vm.count("version"))
    {
      std::cout << dataqueue::version::v() << std::endl;
      return EXIT_SUCCESS;
    }
 
    po::notify(vm);
 
    opto = vm.count("optical");
 
    acou = vm.count("acoustic");
 
    if (! (acou || opto))
    {
      throw std::runtime_error("FATAL: no mode specified. Use -o, -a or both. See the help.");
    }
  }
  catch (const po::error& e)
  {
    std::cerr << "DataQueue: Error: " << e.what() << '\n'
              << desc << std::endl;
    return EXIT_FAILURE;
  }
  catch (const std::runtime_error& e)
  {
    std::cerr << "DataQueue: Error: " << e.what() << '\n'
              << desc << std::endl;
    return EXIT_FAILURE;
  }
 
  // Call to singleton in a thread-safe environment
 
  InBufferCollector::getCollector();
 
  // Don't delete this object. It will be handled by the DataQueue class.
  JLOGGER::JMessageLoggerThreadSafe* log
    = new JLOGGER::JMessageLoggerThreadSafe(
        new JLOGGER::JControlHostLogger(logger), 
        client_name,
        debug);
 
  // Thread-safe logger for the threads different from main
  initLogger(*log);
 
  KM3NETDAQ::DataQueue dqueue(client_name, server, log, debug, acou, opto);
 
  dqueue.setClockInterval(30*1000*1000);
 
  dqueue.enter();
  dqueue.run();
}