JDAQDemoClient.cc

Go to the documentation of this file.

#include <string>
#include <iostream>
#include <fstream>
#include <iomanip>

#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
#include "Jeep/JArgs.hh"

#include "JRuncontrol/JDAQClient.hh"


using namespace KM3NETDAQ;


/**
 * \file
 * Run control demo client class.
 *
 * The various action methods could be implemented in this class.
 * Note that process with extension /- will deliberately crash during the configure transition
 * and process with extension /+ will sleep forever during the exit transition.
 * \author mdejong
 */
class JDAQDemoClient :
  public JDAQClient
{
public:
  /**
   * Constructor.
   *
   * \param  name         name of client
   * \param  tag          tag
   */
  JDAQDemoClient(const std::string& name, const std::string& tag = "") :
    JDAQClient(name)
  {
    addParameter('U', extension, std::string(""));

    if (tag != "") {
      replaceEvent(RC_CMD, tag, ev_init);
      replaceEvent(RC_CMD, tag, ev_configure);
      replaceEvent(RC_CMD, tag, ev_start);
      replaceEvent(RC_CMD, tag, ev_pause);
      replaceEvent(RC_CMD, tag, ev_stop);
      replaceEvent(RC_CMD, tag, ev_reset);
      replaceEvent(RC_CMD, tag, ev_quit);
      replaceEvent(RC_CMD, tag, ev_off);
    }
  }

  virtual void actionEnter()
  { 
    JDebugStream(this->logger) << "Extension <" << extension << ">";
  }

  virtual void actionExit()
  { 
    logger.debug("actionExit()");

    if (getName() == "JDAQDemoClient/+") {

      // sleep forever

      sleep(std::numeric_limits<unsigned int>::max());
    }
  }

  virtual void actionInit(int length, const char* buffer) 
  { 
    JDebugStream(logger) << std::string(buffer,length);
  }

  virtual void actionConfigure(int length, const char* buffer)
  { 
    if (getName() == "JDAQDemoClient/-") {

      // terminate process

      logger.error("Termination of process.");
      ::exit(-1); 

    } else
      JDebugStream(logger) << std::string(buffer,length);
  }

  virtual void actionStart(int length, const char* buffer)
  { 
    JNoticeStream(logger) << "Start run " << getRunNumber();
  }

  virtual void actionPause(int length, const char* buffer)
  { 
    JDebugStream(logger) << std::string(buffer,length);
  }

  virtual void actionContinue(int length, const char* buffer)
  { 
    JDebugStream(logger) << std::string(buffer,length); 
  }

  virtual void actionStop(int length, const char* buffer) 
  { 
    JDebugStream(logger) << std::string(buffer,length);
  }

  virtual void actionReset(int length, const char* buffer)
  { 
    JDebugStream (logger) << std::string(buffer,length);
  }
  
  virtual void actionQuit(int length, const char* buffer)
  { 
    JDebugStream (logger) << std::string(buffer,length);
  }
  
  //virtual void actionInput(int length, const char* buffer) 
  //{}

  std::string extension;
};


/**
 * Run control demo client.
 */
int main(int argc, char* argv[])
{
  using namespace std;

  string  server;
  string  logger;
  string  file_name;
  string  client_name;
  string  tag;
  int     port;
  int     debug;

  try {

    JParser<> zap("Run control demo client.");

    zap['H'] = make_field(server)          = "";
    zap['M'] = make_field(server)          = "";
    zap['f'] = make_field(file_name)       = "";
    zap['u'] = make_field(client_name)     = "%";
    zap['t'] = make_field(tag)             = "";
    zap['P'] = make_field(port)            = -1;
    zap['d'] = make_field(debug)           = 2;

    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }


  using namespace KM3NETDAQ;

  JDAQDemoClient demo(getProcessName(client_name, argv[0]), tag);

  if (debug >= JEEP::debug_t) {
    demo.debug(CHSM::machine::D_all);
  }

  if (port == -1) {

    demo.enter(JEEP::JArgs(argc, argv));

    if (file_name == "")
      
      demo.run();
    
    else {
      
      ifstream in(file_name.c_str());
      
      demo.run(in);
      
      in.close();
    }

  } else {

    demo.run(port);
  }
}