ngcbCON.hpp

Go to the documentation of this file.

#ifndef ngcbCON_H
#define ngcbCON_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
/* 
 * System Headers 
 */
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <signal.h>
 
/*
 * Local Headers 
 */
#include <ngc/core/ngcbSIO.hpp>
 

class ngcbCON
{
public:
  char server[128];

  explicit ngcbCON(const char *name, int vb, 
           void (*signalHandler)(int) = NULL) {
    Initialized(0);
    verboseLevel_ = vb;
    erms_[0] = '\0';
    reply_[0] = '\0';
    str2str(server, name, sizeof(server) - 1);
    Initialized(1);
 
    if (signalHandler != NULL)
      {
      /*
       * Install signal handler
       */
      signal(SIGINT, signalHandler);  // interrupt char (ctrl-c)
      signal(SIGTERM, signalHandler); // kill
      signal(SIGHUP, signalHandler);  // hangup
      signal(SIGUSR1, signalHandler); // USR1 (break)
      signal(SIGUSR2, signalHandler); // USR2 (kill command)
      }
  }

  virtual ~ngcbCON() {}

  int Initialized() {return (initialized_);}

  virtual void Log(const char *msg) {USE(msg);}

  virtual int Open() {return (0);}

  virtual void Close() {}

  virtual int SendRequest(const char *request) {USE(request); return (0);}

  virtual const char *Reply() {return (reply_);}

  char *ErrMsg() {return (erms_);}
 
protected: 
  void Initialized(int flag) {initialized_ = flag;}

  virtual void Verbose(const char *format, ...) {
    if (verboseLevel_ > 0)
      {
      va_list ap;
      va_start(ap, format);
      fprintf(stdout, "# "); vfprintf(stdout, format, ap);
      va_end(ap);
      }
  }
 
private:
  int initialized_;

  int verboseLevel_;

  char erms_[256];

  char reply_[256];
};

class ngcbCON_FACTORY
{
public:
  ngcbCON_FACTORY() {}

  virtual ~ngcbCON_FACTORY() {}

  virtual ngcbCON *Create(const char *server, int vb = 0, 
              void (*signalHandler)(int) = NULL) {
    return (new ngcbCON(server, vb, signalHandler));
  }
 
protected:
 
private:
};

#define NGC_REGISTER_CON_MOD(type, name) extern "C" { type name; \
  int _ngcb_con_ ## name = 1 ; }
 

class ngcbSCON: public ngcbCON
{
public:
  explicit ngcbSCON(const char *name, int vb, 
            void (*signalHandler)(int) = NULL)
    : ngcbCON(name, vb, signalHandler) {}

  virtual ~ngcbSCON() {
    if (sio_.Connected()) sio_.Disconnect();
  }

  int Open() {
    /*
     * Connect to NGC control server
     */
    Verbose("connecting to %s\n", server);
    if (sio_.Connect(server) != ngcbSUCCESS)
      {
      ngcbFmt(ErrMsg(), 256, "service (%s) not available - %s", server,
          sio_.ErrMsg());
      return (ngcbFAILURE);
      }
 
    /*
     * Verify the availability of the built-in reply buffer
     */
    if (sio_.Reply() == NULL)
      {
      strcpy(ErrMsg(), "no reply buffer");
      sio_.Disconnect();
      return (ngcbFAILURE);
      }
 
    return (ngcbSUCCESS);
  }

  void Close() {
    if (sio_.Connected())
      {
      /*
       * Disconnect from NGC control server
       */
      Verbose("disconnecting\n");
      sio_.Disconnect();
      }
  }

  int SendRequest(const char *request) {
    if (sio_.RequestReply(request) != ngcbSUCCESS)
      {
      strcpy(ErrMsg(), sio_.ErrMsg());
      return (ngcbFAILURE);
      }
    else
      {
      return (ngcbSUCCESS);
      }
  }

  const char *Reply() {return (sio_.Reply());}
 
protected: 
private:
  ngcbSIO sio_;
};

class ngcbSCON_FACTORY: public ngcbCON_FACTORY
{
public:
  ngcbSCON_FACTORY() {}

  virtual ~ngcbSCON_FACTORY() {}

  virtual ngcbCON *Create(const char *server, int vb = 0, 
              void (*signalHandler)(int) = NULL) {
    return (new ngcbSCON(server, vb, signalHandler));
  }
 
protected:
private:
};
 
#endif