RotoClient.cxx

Go to the documentation of this file.

// $Id: RotoClient.cxx,v 1.7 2007/07/09 00:50:06 rhatcher Exp $
//
// A JobControl  for sending raw blocks to the Roto-Rooter
//
// rhatcher@fnal.gov

#include "Rotorooter/RotoClient.h"

#include "MessageService/MsgService.h"

#include "TSocket.h"
#include "TSystem.h"

// for function: char* Form(const char *fmt, ...)
#include "TString.h"

const UInt_t dbg_ReportCmd    = 0x0001;
const UInt_t dbg_ReportReply  = 0x0002;
const UInt_t dbg_ReportHex    = 0x0004;
const UInt_t dbg_ReportConn   = 0x0008;

#define ALLOW_ROTOTALK
#ifdef  ALLOW_ROTOTALK
#include "OnlineUtil/rototalk.h"
#endif

UInt_t RotoClient::fgDebugFlags = 0;
//   dbg_ReportCmd | dbg_ReportReply | dbg_ReportConn ; //| dbg_ReportHex;

static string reportOpt = 
  (RotoClient::GetDebugFlags() & dbg_ReportHex) ? "b" : " ";

ClassImp(RotoClient)
CVSID("$Id: RotoClient.cxx,v 1.7 2007/07/09 00:50:06 rhatcher Exp $");

//_____________________________________________________________________________
RotoClient::RotoClient(const Char_t* ipaddress, Int_t port, 
                       MinosRooterEntity whom, Bool_t useRototalk) 
   : fRcWhoAmI(whom), fSocket(0), fIPAddress(ipaddress), fLastCommandAck(), 
     fLastCommandState(RUN_STATE_UNKNOWN), fUseRototalk(useRototalk)
{

   Bool_t ok = SetupConnection(ipaddress,port);

   MSG("Roto", Msg::kVerbose) << "RotoClient::ctor okay = " << (int)ok << endl;
}

//_____________________________________________________________________________
RotoClient::~RotoClient() 
{

   Bool_t ok = CloseConnection();

   MSG("Roto", Msg::kVerbose) << "RotoClient::dtor okay = " << (int)ok << endl;

}

//_____________________________________________________________________________
Bool_t RotoClient::Connected()
{

#ifdef ALLOW_ROTOTALK
  if (fUseRototalk) return true;
#endif
   if (!fSocket) return false;
   return fSocket->IsValid();


}


//_____________________________________________________________________________
Bool_t RotoClient::OpenDAQFile(Int_t detector, Int_t run, Int_t subrun)
{

#ifdef ALLOW_ROTOTALK
   if (fUseRototalk) return roto_open_daqfile(detector,run,subrun);
#endif
   Int_t minibuff[4];
   minibuff[0] = MINOS_ROOTER_DCP;
   minibuff[1] = detector;
   minibuff[2] = run;
   minibuff[3] = subrun;
   RotoRcCmd cmd(fRcWhoAmI,
                 MINOS_ROOTER_ROOTER,
                 MINOS_ROOTER_COMMAND,
                 MINOS_ROOTER_OPENFILE,
                 true);
   return SendCommand(cmd,4*sizeof(Int_t),minibuff);

}

//_____________________________________________________________________________
Bool_t RotoClient::OpenDCSFile(Int_t detector, Int_t sec, Int_t nanosec)
{

#ifdef ALLOW_ROTOTALK
  if (fUseRototalk) return roto_open_dcsfile(detector,sec,nanosec);
#endif
   Int_t minibuff[4];
   minibuff[0] = MINOS_ROOTER_DCS;
   minibuff[1] = detector;
   minibuff[2] = sec;
   minibuff[3] = nanosec;
   RotoRcCmd cmd(fRcWhoAmI,
                 MINOS_ROOTER_ROOTER,
                 MINOS_ROOTER_COMMAND,
                 MINOS_ROOTER_OPENFILE,
                 true);
   return SendCommand(cmd,4*sizeof(Int_t),minibuff);

}

//_____________________________________________________________________________
Bool_t RotoClient::OpenBeamMonFile(Int_t detector, Int_t sec, Int_t nanosec)
{

#ifdef ALLOW_ROTOTALK
  if (fUseRototalk) return roto_open_beammonfile(sec,nanosec);
#endif
   Int_t minibuff[4];
   minibuff[0] = MINOS_ROOTER_BEAMMON;
   minibuff[1] = detector;
   minibuff[2] = sec;
   minibuff[3] = nanosec;
   RotoRcCmd cmd(fRcWhoAmI,
                 MINOS_ROOTER_ROOTER,
                 MINOS_ROOTER_COMMAND,
                 MINOS_ROOTER_OPENFILE,
                 true);
   return SendCommand(cmd,4*sizeof(Int_t),minibuff);

}

//_____________________________________________________________________________
Bool_t RotoClient::CloseDAQFile(Int_t detector, Int_t run, Int_t subrun)
{

#ifdef ALLOW_ROTOTALK
  if (fUseRototalk) return roto_close_daqfile(detector,run,subrun);
#endif
   Int_t minibuff[4];
   minibuff[0] = MINOS_ROOTER_DCP;
   minibuff[1] = detector;
   minibuff[2] = run;
   minibuff[3] = subrun;
   RotoRcCmd cmd(fRcWhoAmI,
                 MINOS_ROOTER_ROOTER,
                 MINOS_ROOTER_COMMAND,
                 MINOS_ROOTER_CLOSEFILE,
                 true);
   return SendCommand(cmd,4*sizeof(Int_t),minibuff);

}

//_____________________________________________________________________________
Bool_t RotoClient::CloseDCSFile(Int_t detector, Int_t sec, Int_t nanosec)
{
#ifdef ALLOW_ROTOTALK
  if (fUseRototalk) return roto_close_dcsfile();
#endif
   Int_t minibuff[4];
   minibuff[0] = MINOS_ROOTER_DCS;
   minibuff[1] = detector;
   minibuff[2] = sec;
   minibuff[3] = nanosec;
   RotoRcCmd cmd(fRcWhoAmI,
                 MINOS_ROOTER_ROOTER,
                 MINOS_ROOTER_COMMAND,
                 MINOS_ROOTER_CLOSEFILE,
                 true);
   return SendCommand(cmd,4*sizeof(Int_t),minibuff);

}

//_____________________________________________________________________________
Bool_t RotoClient::CloseBeamMonFile(Int_t detector, Int_t sec, Int_t nanosec)
{

#ifdef ALLOW_ROTOTALK
  if (fUseRototalk) return roto_close_beammonfile();
#endif
   Int_t minibuff[4];
   minibuff[0] = MINOS_ROOTER_BEAMMON;
   minibuff[1] = detector;
   minibuff[2] = sec;
   minibuff[3] = nanosec;
   RotoRcCmd cmd(fRcWhoAmI,
                 MINOS_ROOTER_ROOTER,
                 MINOS_ROOTER_COMMAND,
                 MINOS_ROOTER_CLOSEFILE,
                 true);
   return SendCommand(cmd,4*sizeof(Int_t),minibuff);

}

//_____________________________________________________________________________
Bool_t RotoClient::OpenFile(const string& fname)
{

#ifdef ALLOW_ROTOTALK
  if (fUseRototalk) return roto_open_named_file(fname.c_str());
#endif
   RotoRcCmd cmd(fRcWhoAmI,
                 MINOS_ROOTER_ROOTER,
                 MINOS_ROOTER_COMMAND,
                 MINOS_ROOTER_OPENFILE,
                 true);
   int nbytes = fname.length()+1; // don't forget the trailing \0
   return SendCommand(cmd,nbytes,fname.c_str());

}

//_____________________________________________________________________________
Bool_t RotoClient::CloseFile(const string& fname)
{

#ifdef ALLOW_ROTOTALK
  if (fUseRototalk) return roto_close_named_file(fname.c_str());
#endif
   RotoRcCmd cmd(fRcWhoAmI,
                 MINOS_ROOTER_ROOTER,
                 MINOS_ROOTER_COMMAND,
                 MINOS_ROOTER_CLOSEFILE,
                 true);
   int nbytes = fname.length()+1; // don't forget the trailing \0
   return SendCommand(cmd,nbytes,fname.c_str());

}

//_____________________________________________________________________________
Bool_t RotoClient::GetRotoStatus(Char_t* statusBuffer, Int_t maxBytes)
{

#ifdef ALLOW_ROTOTALK
  if (fUseRototalk) {
    MSG("Roto",Msg::kWarning) 
      << " ********** GetRotoStatus() called, no rototalk equiv. " << endl;
    return 1;
  }
#endif
   RotoRcCmd cmd(fRcWhoAmI,
                 MINOS_ROOTER_ROOTER,
                 MINOS_ROOTER_REQUEST,
                 MINOS_ROOTER_REQ_CURRENT_STATE,
                 false);
   Bool_t status = SendCommand(cmd,0,0);

   fStatusReport.copy(statusBuffer,maxBytes-1);
   statusBuffer[maxBytes] = 0;

   return status;

}

//_____________________________________________________________________________
Bool_t RotoClient::SendRecordBuffer(const void* buffer, Int_t nbytes)
{

#ifdef ALLOW_ROTOTALK
  if (fUseRototalk) return roto_send_record(buffer,nbytes);
#endif
   RotoRcCmd cmd(fRcWhoAmI,
                 MINOS_ROOTER_ROOTER,
                 MINOS_ROOTER_COMMAND,
                 MINOS_ROOTER_RECBUFFER,
                 true);
   Bool_t status = SendCommand(cmd,nbytes,buffer);

   return status;

}

//_____________________________________________________________________________
Bool_t RotoClient::SendShutdownMessage()
{

#ifdef ALLOW_ROTOTALK
  if (fUseRototalk) return roto_request_shutdown(1);
#endif
   RotoRcCmd cmd(fRcWhoAmI,
                 MINOS_ROOTER_ROOTER,
                 MINOS_ROOTER_COMMAND,
                 MINOS_ROOTER_SHUTDOWN,
                 false);
   return SendCommand(cmd,0,0);

}

//_____________________________________________________________________________
Bool_t RotoClient::SetupConnection(const Char_t* ipaddress, Int_t port)
{

#ifdef ALLOW_ROTOTALK
  if (fUseRototalk) return roto_open_connection(ipaddress,port,fRcWhoAmI);
#endif
   if ( !ipaddress || port<=0 ) return false;

   fSocket = new TSocket(ipaddress,port);

   if (fgDebugFlags & dbg_ReportConn) 
      MSG("Roto",Msg::kInfo) 
         << Form("Open TSocket connection at %s:%d -- %svalid\n",
                 ipaddress,port,((fSocket->IsValid()) ? "" : "in"))
         << endl;

   if (!fSocket->IsValid()) { delete fSocket; fSocket=0; return false; }
   // fSocket->SetOption(kKeepAlive,1);
   fSocket->SetOption(kRecvBuffer,1024); // small packets back

   RotoRcCmd cmd(fRcWhoAmI,
                 MINOS_ROOTER_ROOTER,
                 MINOS_ROOTER_COMMAND,
                 MINOS_ROOTER_OPENSOCKET,
                 false);
   return SendCommand(cmd,0,0);

}

//_____________________________________________________________________________
Bool_t RotoClient::CloseConnection()
{

#ifdef ALLOW_ROTOTALK
  if (fUseRototalk) return roto_close_connection();
#endif
   if (fgDebugFlags & dbg_ReportConn) 
      MSG("Roto", Msg::kInfo) 
         << "RotoClient::CloseConnection" 
         << " Connected = " << (int)Connected() << endl;

   if (!Connected()) return false;

   RotoRcCmd cmd(fRcWhoAmI,
                 MINOS_ROOTER_ROOTER,
                 MINOS_ROOTER_COMMAND,
                 MINOS_ROOTER_CLOSESOCKET,
                 false);
   Bool_t status = SendCommand(cmd,0,0);

   CloseAndDeleteSocket(fSocket);

   return status;

}

//_____________________________________________________________________________
void RotoClient::CloseAndDeleteSocket(TSocket*& socket)
{
   if (socket) {
      if (socket->IsValid()) socket->Close();
      delete socket;
      socket = 0;
   }
}

//_____________________________________________________________________________
Bool_t RotoClient::SendCommand(RotoRcCmd& cmd,
                               Int_t  nSendBytes,
                               const void*  sendBuffer)
{
   // send a command to the Rotorooter, along with possible
   // additional information
   // receive ACK/NACK and results from any request

   if (!Connected()) {
      fLastCommandAck  = MINOS_ROOTER_UNABLE_TO;
      fLastCommandState = MINOS_ROOTER_STATE_UNCONNECTED;
      return false;
   }

   static Int_t nmsg = 0;
   nmsg++;

#ifdef VERBOSE_MSG
//rwh: very verbose
   MSG("Roto",Msg::kInfo) << " Send "
                          << cmd.AsStlString() << endl;
#endif

   if ( (nSendBytes && sendBuffer) != cmd.HasDataToFollow() ) {
      MSG("Roto",Msg::kInfo)
         << "RotoClient::SendCommand HasDataToFollow mismatch "
         << nSendBytes << " bytes vs. flag "
         << (int)cmd.HasDataToFollow()
         << endl;
      cmd.SetDataToFollow(nSendBytes);
   }

   //
   // send the command and optional extra data
   //
   fSocket->SendRaw(&cmd.fEncoded,sizeof(Int_t));
   if (nSendBytes && sendBuffer) {
      // byte count includes its own 4 bytes
      Int_t nbytes = nSendBytes + 4;
      fSocket->SendRaw(&nbytes,sizeof(Int_t));
      fSocket->SendRaw(sendBuffer,nSendBytes);
   }

   if (fgDebugFlags & dbg_ReportCmd) {
      string extra(" ");
      if (nSendBytes) 
         extra += Form("\n with %d (0x%x) extra bytes",nSendBytes,nSendBytes);
      MSG("Roto", Msg::kInfo) 
         << "RotoClient::SendCommand msg#" 
         << nmsg 
         << " " << cmd.AsStlString(reportOpt)
         << extra 
         << endl;
   }

   // should do something here in
   // case Roto doesn't respond ... ie. correctly handle
   // timeout situation --- currently just blocks forever

   switch (cmd.GetType()) {
   case MINOS_ROOTER_COMMAND:
      return ReceiveCommandReply(cmd,nmsg);
      break;
   case MINOS_ROOTER_REQUEST:
      return ReceiveRequestReply(cmd,nmsg);
      break;
   default:
      return false;
   }

}

//_____________________________________________________________________________
Bool_t RotoClient::ReceiveCommandReply(RotoRcCmd& cmd, Int_t nmsg)
{
   // 
   // commands require an acknowledgement and state_report
   // allow for extended information in case of NACK
   //

   RotoRcCmd expect_ack = cmd;
   expect_ack.SwapToFrom();
   expect_ack.SetType(MINOS_ROOTER_ACKNOWLEDGE);
   expect_ack.SetDataToFollow(false);
   // RWH 2007-06-29  All the time is spend in next line!
   fSocket->RecvRaw(&fLastCommandAck.fEncoded,sizeof(Int_t));

   Int_t   nNackBytes = 0;
   Char_t* nackBuffer = 0;
   if (fLastCommandAck.HasDataToFollow()) {
      // get the followup data
      fSocket->RecvRaw(&nNackBytes,sizeof(Int_t));
      // byte count includes its own 4 bytes
      nNackBytes -= 4;
      if (nNackBytes>0) {
         nackBuffer = new Char_t[nNackBytes+1];
         nackBuffer[nNackBytes] = 0;
         fSocket->RecvRaw(nackBuffer,nNackBytes);
         fNackReport = nackBuffer;
         delete [] nackBuffer;
      }
   }

   //
   // protocol says COMMAND also gets a STATE_REPORT reply
   //
   fSocket->RecvRaw(&fLastCommandState.fEncoded,sizeof(Int_t));
 
  if (fgDebugFlags & dbg_ReportReply) {
      string match;
      string nackmsg = "";
      if (fLastCommandAck == expect_ack) {
         match = " ok ";
      } else {
         match = "\n          should be ";
         match += expect_ack.AsStlString(reportOpt);
         if (fNackReport != "") {
            nackmsg = "\n       NACK message: \"";
            nackmsg += fNackReport;
            nackmsg += "\"";
         }
      }
      MSG("Roto", Msg::kInfo)
         << "RotoClient::SendCommand reply#" 
         << nmsg 
         << " " << fLastCommandAck.AsStlString(reportOpt)
         << match
         << nackmsg
         << " state report " << fLastCommandState.AsStlString(reportOpt)
         << endl;
   }

  return fLastCommandAck.TestAckAsBool();
}

//_____________________________________________________________________________
Bool_t RotoClient::ReceiveRequestReply(RotoRcCmd& cmd, Int_t nmsg)
{
   //
   // if sent message was a REQUEST the handle the reply
   //

   RotoRcCmd report;
   RotoRcCmd expect_report = cmd;
   expect_report.SwapToFrom();
   expect_report.SetType(MINOS_ROOTER_REPORT);
   bool expectfollowup = false;
   if (cmd.GetInstr() == MINOS_ROOTER_REQ_STATUS_REPORT) expectfollowup = true;
   expect_report.SetDataToFollow(expectfollowup);
   
   fSocket->RecvRaw(&report.fEncoded,sizeof(Int_t));

   if (fgDebugFlags & dbg_ReportReply) {
      string match;
      if (report == expect_report) {
         match = " as expected ";
      } else {
         match = "\n          should be ";
         match += expect_report.AsStlString(reportOpt);
      }
      MSG("Roto", Msg::kInfo)
         << "RotoClient::SendCommand reply#" 
         << nmsg 
         << " " << report.AsStlString(reportOpt)
         << match
         << endl;
   }

   Int_t   nStatusBytes = 0;
   Char_t* statusBuffer = 0;

   switch (cmd.GetInstr()) {
   case MINOS_ROOTER_REQ_CURRENT_STATE:
      // if instruction was CURRENT_STATE then one expects 
      // REPORT CURRENT_STATE and this is like a COMMAND reply
      fLastCommandState = report;
      break;
   case MINOS_ROOTER_REQ_STATUS_REPORT:
      if (report.HasDataToFollow()) {
         // get the followup data
         fSocket->RecvRaw(&nStatusBytes,sizeof(Int_t));
         // byte count includes its own 4 bytes
         nStatusBytes -= 4;
         if (nStatusBytes>0) {
            statusBuffer = new Char_t[nStatusBytes+1];
            statusBuffer[nStatusBytes] = 0;
            fSocket->RecvRaw(statusBuffer,nStatusBytes);
            fStatusReport = statusBuffer;
            delete [] statusBuffer;
        }
      }
      break;
   default:
      return false;
   }

   return true;
}

//_____________________________________________________________________________

---