SessionObject.cc

Go to the documentation of this file.

// still to do:
//   exec


/*----------------------------------------------------------------------------*
 *  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, 17-Feb-2005, Jefferson Lab                                     *
 *                                                                            *
 *    Authors: Elliott Wolin                                                  *
 *             wolin@jlab.org                    Jefferson Lab, MS-6B         *
 *             Phone: (757) 269-7365             12000 Jefferson Ave.         *
 *             Fax:   (757) 269-5519             Newport News, VA 23606       *
 *                                                                            *
 *----------------------------------------------------------------------------*/



#include <SessionObject.hxx>

#include <unistd.h>
#include <time.h>
#include <math.h>


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



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


SessionObject::SessionObject(const string& udl, const string& Name, const string& Descr, const string &cClass,
        const cMsgSubscriptionConfig *scfg)  throw(CodaException)
        : CodaObject(udl,Name,Descr,cClass,scfg), session("none"),
          sessionControlCBD(new cMsgDispatcher<SessionObject>(this,&SessionObject::sessionControlCallback)),
          scSubId(NULL), reportingInterval(2.0), reportingThreadId(0), reportingThreadDispatcher(NULL),
          sessionFileContent("") {


    if(debug!=0)cout << "Entering SessionObject constructor..." << endl;

    // set object type
    objectType="SessionObject";


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

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


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


SessionObject::~SessionObject(void) throw() {

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

    handleStopReporting(NULL);

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

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


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


void SessionObject::sessionControlCallback(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 << " sessionControlCallback received message, type is " << s << endl;


    if(s=="session/control/setsession") {
        handleSetSession(msg);

    } else if(s=="session/control/getsession") {
        sendResponse(msg,name,"rc/response/getSession",session,0);

    } else if(s=="session/control/configure") {
        handleSessionConfigure(msg);

    } else if(s=="session/control/exit") {
        handleExit(msg);

    } else if(s=="session/control/reset") {
            handleSessionReset(msg);

    } else if(s=="session/control/startreporting") {
        handleStartReporting(msg);

    } else if(s=="session/control/stopreporting") {
        handleStopReporting(msg);

    } else if(s=="session/control/setinterval") {
        reportingInterval=atof(msg->getText().c_str());
        reportingInterval=MAX(reportingInterval,MIN_REPORTING_INTERVAL);
        reportingInterval=MIN(reportingInterval,MAX_REPORTING_INTERVAL);
        if(debug!=0)cout << "sessionObject new reporting interval is " << reportingInterval << endl;

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

    delete(msg);
}


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

void SessionObject::handleSessionReset(const cMsgMessage *msg) throw(CodaException) {
    // calls session reset
    this->sessionReset(msg->getText());

}


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


void SessionObject::handleSetSession(const string &newSession) throw(CodaException) {

  if(debug!=0)cout << "in SessionObject::handleSetSession" << endl;

  // do nothing if session not changed
  if(newSession==session) {
    string info = "SessionObject::handleSetSession...new session " + session + " same as old";
    cout << info << endl;
    daLogMsg(info,DALOG_INFO);
    return;
  }


  // unsubscribe from old session
  try {
    if(scSubId!=NULL) {
      rcConn->unsubscribe(scSubId);
      scSubId=NULL;
    }
  } catch (cMsgException e) {
    string err = "?SessionObject::handleSetSession...unable to unsubscribe";
    cerr << err << endl;
    daLogMsg(err,DALOG_ERROR);
    throw(CodaException(err));
  } catch (...) {
    string err = "?SessionObject::handleSetSession...unknown exception, unable to unsubscribe";
    cerr << err << endl;
    daLogMsg(err,DALOG_ERROR);
    throw(CodaException(err));
  }


  // switch sessions
  if(!setSession(newSession)) {
    string err = "?SessionObject::handleSetSession...setSession failed to set new session " + newSession;
    cerr << err << endl;
    daLogMsg(err,DALOG_ERROR);
    return;
  }
  session=newSession;


  // subscribe to new session-specific subject
  try {
    scSubId=rcConn->subscribe(session,"session/control/*", sessionControlCBD, NULL, myscfg);
  } catch (cMsgException e) {
    string err = "?SessionObject::handleSetSession...unable to subscribe";
    cerr << err << endl;
    daLogMsg(err,DALOG_ERROR);
    throw(CodaException(e.toString()));
  } catch (...) {
    string err = "?SessionObject::handleSetSession...unknown exception, unable to subscribe";
    cerr << err << endl;
    daLogMsg(err,DALOG_ERROR);
    throw(CodaException(err));
  }


  // session now set
  string info = "SessionObject...switched to new session " + session;
  cout << info << endl;
  daLogMsg(info,DALOG_INFO);
  return;
}


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


void SessionObject::handleSetSession(const cMsgMessage *msg) throw(CodaException) {
  handleSetSession(msg->getText());
}


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


void SessionObject::handleSessionConfigure(const cMsgMessage *msg) throw(CodaException) {
    if(debug==0) cout << "handleSessionConfigure called" << endl;
    try {
        // read fileName
        string fileName = msg->getString("fileName");


        // returns if fileName has not changed and if not forced
        if(config==fileName  &&  msg->getInt32("fileChanged")==0) {
            return;
        }

        // changes config
        config = fileName;
        cout << "?SessionObject::handleSessionConfigure:  new config " << config << endl;

        // stores values
        sessionFileContent = msg->getString("fileContent");

        // calls sessionConfigure
        sessionConfigure(config, sessionFileContent);

    } catch (cMsgException e) {
        cout << "?SessionObject::handleSessionConfigure: invalid payload items" << endl;
    }

}


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


void SessionObject::handleExit(const cMsgMessage *msg) throw(CodaException) {
    this->exit(msg->getText());
}


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


void SessionObject::handleStartReporting(const cMsgMessage *msg) throw(CodaException) {

    if(debug!=0)cout << "sessionObject handleStartReporting" << endl;

    if(reportingThreadDispatcher==NULL) {

        reportingThreadDispatcher = new pthreadDispatcher<SessionObject,void*,void*>(this,&SessionObject::reportingThread,NULL);

        if(pthread_create(&reportingThreadId,NULL,pthreadDispatcher<SessionObject,void*,void*>::dispatchIt,
                (void*)reportingThreadDispatcher)==0) {
            pthread_detach(reportingThreadId);
        } else {
            reportingThreadId=0;
            delete(reportingThreadDispatcher);
            reportingThreadDispatcher=NULL;
            string err = "?SessionObject::handleStartReporting...unable to start reporting thread";
            cerr << err << endl;
            daLogMsg(err,DALOG_ERROR);
        }

    } else {
        string warn = "?SessionObject::handleStartReporting:  attempt to start a second reporting thread ignored";
        cerr << warn << endl;
        daLogMsg(warn,DALOG_WARN);
    }
}


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


void SessionObject::handleStopReporting(const cMsgMessage *msg) throw() {

    if(debug!=0)cout << "sessionObject handleStopReporting" << endl;

    // cancel thread and wait for it to complete
    if(reportingThreadId!=0) {
        pthread_cancel(reportingThreadId);
        pthread_join(reportingThreadId,NULL);
        reportingThreadId=0;
    }

    // delete dispatcher
    if(reportingThreadDispatcher!=NULL) {
        delete(reportingThreadDispatcher);
        reportingThreadDispatcher=NULL;
    }

}


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


void *SessionObject::reportingThread(void*) {

  if(debug!=0)cout << "Entering sessionObject reportingThread" << endl;


  timespec t;
  double d;
  int msec;


  // loop forever
  while(true) {

    // bug...message must be gone before pthread_testcancel
    {
      msec=int(modf(reportingInterval,&d)*1000.0);
      t.tv_nsec=msec*1000000;
      t.tv_sec=int(d);
      nanosleep(&t,NULL);


      // get message and fill fields
      cMsgMessage *msg = new cMsgMessage();
      msg->setSubject(name);
      msg->setType("rc/report/status");
      msg->setText(getStatus());
      fillReport(msg);

      try {
        rcConn->send(msg);
        rcConn->flush();
      } catch (cMsgException &e) {
        string err = e.toString();
        cerr << err << endl;
        daLogMsg(err,DALOG_ERROR);
      } catch (...) {
        string err = "SessionObject::reportingThread...unknown exception";
        cerr << err << endl;
        daLogMsg(err,DALOG_ERROR);
      }

      delete(msg);
    }

    // message gone, now can check for cancel
    pthread_testcancel();
  }


  return(NULL);
}


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

void SessionObject::fillReport(cMsgMessage *m) throw() {
  m->add("codaClass",getCodaClass());
  m->add("state", getState());
  m->add("objectType",getObjectType());

}
//-----------------------------------------------------------------------------


void SessionObject::daLogMsgFill(cMsgMessage &m) const throw(CodaException) {
  CodaObject::daLogMsgFill(m);
  m.add("session",getSession());
}


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


string SessionObject::getSession(void) const throw() {
  return(session);
}


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


bool SessionObject::setSession(const string& newSession) throw(CodaException) {
    if(debug!=0)cout << "SessionObject::setSession called for " << newSession <<  endl;
    return(true);
}


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


bool SessionObject::sessionConfigure(const string& fileName,const string& fileContent) throw(CodaException) {
    cout << "SessionObject...dummy configure called" << endl;
    return(true);
}


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


void SessionObject::exit(const string& s) throw(CodaException) {
    cout << endl << " *** SessionObject...default exit called ***" << endl << endl;
    std::exit(EXIT_SUCCESS);
}


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

void SessionObject::sessionReset(const string& s) throw(CodaException) {
    cout << endl << " *** SessionObject...default reset called ***" << endl << endl;
}


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

---