CodaObject.cc

Go to the documentation of this file.

//  CodaObject.cc

// figure out daLog severity codes



/*----------------------------------------------------------------------------*
 *  Copyright (c) 2005        Southeastern Universities Research Association, *
 *                            Thomas Jefferson National Accelerator Facility  *
 *                                                                            *
 *    This software was developed under a United States Government license    *
 *    described in the NOTICE file included as part of this distribution.     *
 *                                                                            *
 *    E.Wolin, 25-Feb-2005, Jefferson Lab                                     *
 *                                                                            *
 *    Authors: Elliott Wolin                                                  *
 *             wolin@jlab.org                    Jefferson Lab, MS-12H        *
 *             Phone: (757) 269-7365             12000 Jefferson Ave.         *
 *             Fax:   (757) 269-5519             Newport News, VA 23606       *
 *
 *----------------------------------------------------------------------------*/



#include <CodaObject.hxx>


#ifdef VXWORKS
#include <vxWorks.h>
#include <taskLib.h>
#include <sysLib.h>
#include <hostLib.h>
#endif


using namespace std;
using namespace cmsg;
using namespace codaObject;


// allocate storage for static class variables
int CodaObject::debug=0;



//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------


CodaObject::CodaObject(const string& udl, const string& Name, const string& Descr, const string &cClass, 
                       const cMsgSubscriptionConfig *scfg, int connTimeout) throw(CodaException)
  : UDL(udl), name(Name), descr(Descr), state("unknown"), myscfg(scfg), rcConn(NULL),
    codaCBD(new cMsgDispatcher<CodaObject>(this,&CodaObject::codaObjectCallback)), connTimeout(connTimeout),
    CodaObjectDaLogSubject("daLogSubject"), status("unknown"), config("unknown") {



  if(debug!=0)cout << "Entering CodaObject constructor with udl " << udl << " ..." << endl;


  // set object type
  objectType = "CodaObject";


  // check and set codaClass
  codaClass = checkCodaClass(cClass);


  // set host name
  char c[256];
  if(gethostname(c,sizeof(c))==0) {
    hostName=string(c);
  } else {
    hostName="unknown";
  }


  // set user name
  char *u=getenv("USER");
  if(u!=NULL) {
    userName=string(u);
  } else {
    userName="unknown";
  }


  // connect to run control, try every 2 seconds for connTimeout seconds
  if(debug!=0)cout << "...CodaObject constructor connecting..." << endl;
  bool conn=false;
  rcConn = new cMsg(UDL, name, descr);
  if(debug!=0)cout << "UDL,name,descr " << UDL << " " << name << " "<< descr << endl;
  for(int i=0; i<connTimeout; i+=2) {
    try {
      if(debug!=0)cout << "about to try." << endl;
      rcConn->connect();
      if(debug!=0)cout << "tried." << endl;
      conn=true;
      break;
    } catch (cMsgException &e) {
      if((e.returnCode==CMSG_NETWORK_ERROR)||(e.returnCode==CMSG_TIMEOUT)) {
        string info = "CodaObject constructor...attempting to establish run control connection";;
        cout << info << endl;
        daLogMsg(info,DALOG_INFO);
#ifdef VXWORKS
        taskDelay(2*sysClkRateGet());
#else        
        sleep(2);
#endif
      } else {
        string err = "?CodaObject constructor...error connecting to run control, UDL is: " + UDL;
        cerr << err << endl;
        daLogMsg(err,DALOG_ERROR);
        throw(CodaException(e.what()));
      }
    } catch (...) {
      string err = "?CodaObject constructor...unknown exception while connecting to run control, UDL is: " + UDL;
      cerr << err << endl;
      daLogMsg(err,DALOG_ERROR);
      throw(CodaException(err));
    }
  }
  if(!conn) {
    string err = "?CodaObject constructor...failed to connect to run control, UDL is: " + UDL;
    cerr << err << endl;
    daLogMsg(err,DALOG_ERROR);
    throw(CodaException(err));
  }


  // default subscriptions
  if(debug!=0)cout << "...CodaObject constructor subscribing..." << endl;
  try {
    rcConn->subscribe(name,         "coda/info/*", codaCBD, NULL, myscfg);
    rcConn->subscribe("CodaObject", "coda/info/*", codaCBD, NULL, myscfg);
  } catch (cMsgException &e) {
    string err = "?CodaObject constructor...unable to subscribe";
    cerr << err << endl;
    daLogMsg(err,DALOG_ERROR);
    throw(CodaException(err));
  } catch (...) {
    string err = "?CodaObject constructor...unknown exception, unable to subscribe";
    cerr << err << endl;
    daLogMsg(err,DALOG_ERROR);
    throw(CodaException(err));
  }

  if(debug!=0)cout << "...leaving CodaObject constructor" << endl;
}


//-----------------------------------------------------------------------------


CodaObject::~CodaObject(void) throw() {

  if(debug!=0)cout << "Entering CodaObject destructor..." << endl;

  if(codaCBD!=NULL) {
    delete(codaCBD);
    codaCBD=NULL;
  }

  if(rcConn!=NULL) {
    rcConn->disconnect();
    rcConn=NULL;
  }

  if(debug!=0)cout << "...leaving CodaObject destructor" << endl;
}


//-----------------------------------------------------------------------------


string CodaObject::checkCodaClass(const string &cClass) const throw() {

  string s = cClass;
  std::transform(s.begin(), s.end(), s.begin(), (int(*)(int)) tolower);  // magic

  if((s=="roc")||(s=="eb")||(s=="er")||(s=="ts")||(s=="et")||(s=="ana"))return(cClass);
  return("USER");
}


//-----------------------------------------------------------------------------


void CodaObject::startProcessing(void) throw(CodaException) {

  if(debug!=0)cout << "Entering CodaObject startProcessing..." << endl;

  // send status message
  sendResponse(NULL,name,"rc/report/status",status,0);

  // enable message receipt
  rcConn->start();

  if(debug!=0)cout << "...leaving CodaObject startProcessing" << endl;
}


//-----------------------------------------------------------------------------


void CodaObject::changeStatus(const string& newStatus) throw(CodaException) {
  if(debug!=0)cout << "CodaObject changeStatus, new status is " << newStatus << endl;
  status=newStatus;
  sendResponse(NULL,name,"rc/response/getStatus",status,0);
}


//-----------------------------------------------------------------------------



void CodaObject::stopProcessing(void) throw(CodaException) {

  if(debug!=0)cout << "Entering CodaObject stopProcessing..." << endl;

  // disable message receipt
  rcConn->stop();

  if(debug!=0)cout << "...leaving CodaObject stopProcessing" << endl;
}


//-----------------------------------------------------------------------------


void CodaObject::codaObjectCallback(cMsgMessage *msg, void *userArg) throw(CodaException) {

  string s = msg->getType();
  std::transform(s.begin(), s.end(), s.begin(), (int(*)(int)) tolower);  // magic

  if(debug!=0)cout << "codaObjectCallback received message, type is " << s << "..." << endl;


  if(s=="coda/info/getobjecttype") {
    sendResponse(msg,name,"rc/response/getObjectType",objectType,0);

  } else if(s=="coda/info/getstate") {
    sendResponse(msg,name,"rc/response/getState",state,0);

  } else if(s=="coda/info/getcodaclass") {
    sendResponse(msg,name,"rc/response/getCodaClass",codaClass,0);

  } else if(s=="coda/info/getstatus") {
    sendResponse(msg,name,"rc/response/getStatus",status,0);

  } else if(s=="coda/info/getconfig") {
    sendResponse(msg,name,"rc/response/getConfig",config,0);

  } else {
    // unknown type, pass to user message handler, user deletes message
    userMsgHandler(msg,userArg);
    return;
  }

  delete(msg);
}


//-----------------------------------------------------------------------------


void CodaObject::changeState(const string& newState) throw(CodaException) {
    if(state!=newState) {
        cout << "CodaObject changeState, new state is " << newState << endl;
        state=newState;
        sendResponse(NULL,name,"rc/response/getState",state,0);
    }
}


//-----------------------------------------------------------------------------


int CodaObject::daLogMsg(const string& text, int sevid, const string& daLogSubject) const throw(CodaException) {

  stringstream ss;

  if(rcConn==NULL) {
    throw(CodaException("?CodaObject::daLogMsg...connection not established yet"));
    return 1;
  }


  // create message
  cMsgMessage m;

  // set subject if specified
  if(!daLogSubject.empty()) {
    m.setSubject(daLogSubject);
  } else if(!CodaObjectDaLogSubject.empty()) {
    m.setSubject(CodaObjectDaLogSubject);
  } else {
    m.setSubject("");
  }

  // special type
  ss << "rc/report/dalog/" << sevid << ends;
  m.setType(ss.str());


  // user int is sevid
  m.setUserInt(sevid);


  // text
  m.setText(text);


  ss.str("");
  if((sevid>=1)&&(sevid<=4)) {
    ss << "INFO";
  } else if((sevid>=5)&&(sevid<=8)) {
    ss << "WARN";
  } else if((sevid>=9)&&(sevid<=12)) {
    ss << "ERROR";
  } else if((sevid>=13)&&(sevid<=16)) {
    ss << "SEVERE";
  } else {
    ss << "unknown";
  }
  ss << "." << (sevid-1)%4+1 << ends;
  m.add("severityText",ss.str());


  // fill message with additional information
  daLogMsgFill(m);


  // send message
  try {
    rcConn->send(m);
    rcConn->flush();
  } catch (cMsgException e) {
    string err = "?CodaObject::daLogMsg unable to send message\n" + e.toString();
    cerr << err << endl;
    throw(CodaException(err));
    return 2;
  } catch (...) {
    string err = "?CodaObject::daLogMsg...unknown exception, unable to send message\n";
    cerr << err << endl;
    throw(CodaException(err));
    return 3;
  }
  return 0;
}  


//-----------------------------------------------------------------------------


void CodaObject::daLogMsgFill(cMsgMessage &m) const throw(CodaException) {

  m.add("codaName",name);

  time_t now = time(NULL);
  m.add("tod",string(ctime(&now)));
  m.add("hostName",getHostName());
  m.add("userName",getUserName());
}


//-----------------------------------------------------------------------------


void CodaObject::sendResponse(const cMsgMessage *msg, const string& subject, const string& type,
        const string& text, int userInt) const
throw(CodaException) {


    cMsgMessage m;
    m.setSubject(subject);
    m.setType(type);
    m.setText(text);
    m.setUserInt(userInt);

    // send synchronous response if requested
    if((msg!=NULL)&&(msg->isGetRequest())) m.makeResponse(msg);


    try {
        rcConn->send(m);
        rcConn->flush();
    } catch (cMsgException e) {
        string err = "?CodaObject::sendResponse unable to send response\n" +  e.toString();
        cerr << err << endl;
        daLogMsg(err,DALOG_ERROR);
        throw(CodaException(err));
    } catch (...) {
        string err = "?CodaObject::sendResponse, unknown exception, unable to send response\n";
        cerr << err << endl;
        daLogMsg(err,DALOG_ERROR);
        throw(CodaException(err));
    }
}


//-----------------------------------------------------------------------------


string CodaObject::getStatus(void) const throw() {
    return(status);
}


//-----------------------------------------------------------------------------

string CodaObject::getObjectType(void) const throw() {
    return(objectType);
}


//-----------------------------------------------------------------------------


string CodaObject::getCodaClass(void) const throw() {
    return(codaClass);
}


//-----------------------------------------------------------------------------


string CodaObject::getHostName(void) const throw() {
    return(hostName);
}


//-----------------------------------------------------------------------------


string CodaObject::getUserName(void) const throw() {
    return(userName);
}


//-----------------------------------------------------------------------------


string CodaObject::getState(void) const throw() {
    return(state);
}


//-----------------------------------------------------------------------------


string CodaObject::getConfig(void) const throw() {
    return(config);
}


//-----------------------------------------------------------------------------


void CodaObject::userMsgHandler(cMsgMessage *msg, void *userArg) throw(CodaException) {
    string warn = "?CodaObject::userMsgHandler...default vsn ignoring unknown message type: " + msg->getType();
    cerr << warn << endl;
    daLogMsg(warn,DALOG_WARN);
}


//-----------------------------------------------------------------------------


string CodaObject::userStatus(void) const throw() {
    return("");
}


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

---