RotoSocket.cxx

Go to the documentation of this file.

// $Id: RotoSocket.cxx,v 1.8 2006/06/21 05:02:32 rhatcher Exp $
//
// An object for emulating a Tsocket using a binary file.
//
// Nick West

#include "Rotorooter/RotoSocket.h"

#include "MessageService/MsgService.h"

#include <cassert>

ClassImp(RotoSocket)
CVSID("$Id: RotoSocket.cxx,v 1.8 2006/06/21 05:02:32 rhatcher Exp $");

//_____________________________________________________________________________

//
//  Purpose:  Create a RotoServer
//            Open binary file fpr input ready to serve it.
//
//  Argument: fileName   Name of binary file.
//
//  Return:   (none)
//
//  Contact:  N. West

RotoSocket::RotoSocket(const char* fileName) :
fCommand(INITIALISE),
fAction(PREPARE_NEXT_COMMAND),
fTransCmd(0),
fTransLen(0),
fTransAlloc(MAXBUFFER),
fTransData(new long[MAXBUFFER / sizeof(long)]),
fFileName(fileName),
fFile(0)
{

  MsgService::Instance()->GetStream("Roto")->SetLogLevel(Msg::kInfo);
  
  MSG("Roto",Msg::kInfo) << "Opening: " << fileName << endl;

  fFile=fopen(fileName,"rb");
  if (fFile==NULL) {
    printf("Failed to open input file: '%s'\n",fileName);
    fCommand = SEND_SHUTDOWN;
  }

}
//_____________________________________________________________________________

RotoSocket::~RotoSocket()  {

  delete [] fTransData;
  if ( fFile ) fclose(fFile);
  fFile = 0;

}

//_____________________________________________________________________________

void RotoSocket::NotImp(const char* method) const {

  MSG("Roto",Msg::kError) << "RotoSocket: Attempting to use un implimented"
                          << "  method: " << method << endl;
}
//_____________________________________________________________________________

Int_t RotoSocket::RecvRaw(void *buffer, Int_t length,
                          ESendRecvOptions /* opt */) {
//
//  Purpose:  Construct and pass raw command.
//
//  Argument:  buffer        address of receivin
//             length        size of buffer
//             opt           ignored.
//
//  Return:    number of bytes transferred to buffer.
//
//  Contact:  N. West

  if ( fAction == PREPARE_NEXT_COMMAND ) PrepareCommand();
  return Transmit(buffer,length);

}
//_____________________________________________________________________________

void RotoSocket::PrepareCommand()  {
//
//  Purpose:  
//
//  Argument: buffer        address of receiving buffer
//            length        size of buffer
//            
//
//  Return:    
//
//  Contact:  N. West

  static int  nRecords =0;
  const int bitDataToFollow = (1 << 15);
  Int_t   instr = 0;

  
// Select next command.

  switch ( fCommand ) {
  case INITIALISE:   fCommand = OPEN_SOCKET; break;
  case OPEN_SOCKET:  fCommand = OPEN_FILE;   break;
  case OPEN_FILE:    fCommand = SEND_DATA;   break;
  case SEND_DATA:    break;  // do nothing
  default:
     cout << " fCommand was " << (int)fCommand << endl;
     assert(0);
  }
  
// Prepare next command

  switch ( fCommand ) {

  case OPEN_SOCKET:
    instr     = MINOS_ROOTER_OPENSOCKET;
    fTransLen = 0;
    break;

  case OPEN_FILE:
    instr     = MINOS_ROOTER_OPENFILE;
    {
      int*  iptr = (int*) fTransData;
      char* cptr = (char*) fTransData + sizeof(int);
      
// Signal that we are sending file name.
      *iptr      = MINOS_DCS | bitDataToFollow;
// Remove directory path from file name and store
      const char* lastslash = strrchr(fFileName.c_str(),'/');
      if (lastslash) lastslash++;  // move past slash to next char
      else lastslash = fFileName.c_str();  // no slash, use whole thing
      sprintf(cptr,"%s",lastslash);
      int fnlen = strlen(cptr);
      cptr[fnlen] = 0;   
      fTransLen = sizeof(int) + fnlen + 1;
      
    }
    break;

  case SEND_DATA:
    instr     = MINOS_ROOTER_SHUTDOWN;  //The default if we cannot read record!
    fTransLen = 0;
    if ( feof(fFile) )  {
      printf("Seen EOF after record %d Quiting ...\n",nRecords);
      break;
    }
    if ( fread(&fTransLen,sizeof(long),1,fFile) !=1 ) {
      if ( feof(fFile) )  {
        printf("Seen EOF after record %d Quiting ...\n",nRecords);
      }
      else {
      printf("Read error on record %d Quiting ...\n",nRecords);
      }
      break;
    }
    nRecords++;
    fTransLen -= sizeof(long);  // byte count is inclusive 
    if ( fTransLen > fTransAlloc ) {
      if ( ! ReallocateBuffer(fTransLen) ) {
        printf("Record %d Size %ld bytes too large for buffer (%ld) Quiting ...\n",
               nRecords,fTransLen,fTransAlloc);
        fTransLen = 0;
      }
      else {
        printf("Record %d Size %ld bytes, buffer reallocated to %ld.\n",
               nRecords,fTransLen,fTransAlloc);
      }
    }
    if ( fread(fTransData,fTransLen,1,fFile) != 1 ) {
      printf("Read error on record %d Quiting ...\n",nRecords);
      fTransLen = 0;
      break;
    }
    instr     = MINOS_ROOTER_RECBUFFER;
    break;

  case SEND_SHUTDOWN:
    instr     = MINOS_ROOTER_SHUTDOWN;
    fTransLen = 0;
    break;

  default:
     assert(0);

  }


  fTransCmd = RotoRcCmd(MINOS_DCP,
                        MINOS_ROOTER,
                        MINOS_ROOTER_COMMAND,
                        instr, 
                        fTransLen > 0);
  

  fAction = TRANSMIT_COMMAND;

}

//_____________________________________________________________________________

Int_t RotoSocket::Transmit(void* buffer,Int_t length) {
//
//  Purpose:  
//
//  Argument: buffer        address of receiving buffer
//             length        size of buffer
//            
//
//  Return:    
//
//  Contact:  N. West

 switch ( fAction ) {
 int nbytes;

 case  TRANSMIT_COMMAND: 
   memcpy(buffer,&fTransCmd.fEncoded,sizeof(long));
   fAction = ( fTransLen > 0 ) ? TRANSMIT_LENGTH : PREPARE_NEXT_COMMAND;
   return sizeof(long);

 case  TRANSMIT_LENGTH: 
   nbytes = fTransLen + sizeof(int);// Compute total length with byte count
   memcpy(buffer,&nbytes,sizeof(long));
   fAction = TRANSMIT_DATA;
   return sizeof(long);

 case  TRANSMIT_DATA: 
   nbytes = ( fTransLen < length ) ? fTransLen : length;
   memcpy(buffer,fTransData,nbytes);
   fAction = PREPARE_NEXT_COMMAND;
   return nbytes;

 default:
    assert(0);
 }

 return -1;
}

//_____________________________________________________________________________

Bool_t RotoSocket::ReallocateBuffer(long minBytes) {
//
//  Purpose:  Reallocate the fTransData buffer so it is at least minBytes
//            in length.
//
//  Argument: minBytes       minimum size of buffer
//
//  Return:   true if successful
//
//  Contact:  R. Hatcher

  long oldsize  = fTransAlloc;
  long mrequest = minBytes;
  int  failures = 0;

  // release existing buffer
  if (fTransData) {
    delete [] fTransData;
    fTransData = 0;
  }

  // set absolute mimimum size
  if ( mrequest < MAXBUFFER ) mrequest = MAXBUFFER;

  // round up to even 1M bytes
  mrequest = ((mrequest >> 20) + 1 ) << 20;

  while ( ! fTransData ) {
    fTransData = new long[mrequest / sizeof(long)];
    if ( fTransData ) break; // success
    failures++;
    mrequest -= 1024*sizeof(char);  // failed, try smaller size
  }
  fTransAlloc = mrequest;

  if ( fTransAlloc >= minBytes ) return true;
  
  printf("RotoSocket::ReallocateBuffer was unable to allocate requested "
         "%ld bytes \n  from initial size %ld, only got final size %ld.",
         minBytes,oldsize,fTransAlloc);
  return false;
}

/*

//_____________________________________________________________________________

RotoSocket:: {
//
//  Purpose:  
//
//  Argument: 
//            
//
//  Return:    
//
//  Contact:  N. West
{


}

*/

---