RotoServer Class Reference

#include <RotoServer.h>

List of all members.

Public Member Functions

 RotoServer (Int_t port, Int_t nwords, Bool_t allow_overwrite=kFALSE, Int_t tcp_nodelay_flag=0)
 RotoServer (const char *fileName, Int_t nwords, Bool_t allow_overwrite=kFALSE)
 ~RotoServer ()
void Run ()
Int_t SetAutoSaveConfig (const string &stream, UInt_t nrec, UInt_t nsec)
Int_t SetCompressConfig (const string &stream, Int_t level)
Int_t SetBasketSizeConfig (const string &stream, UInt_t basketsize)
Int_t SetSymlink (const char *symlink_name=0)
Int_t SetFlatBinaryOutputFile (const string &filename)

Static Public Member Functions

static UInt_t GetDebugFlags ()
static void SetDebugFlags (UInt_t dbgflgs)

Private Types

enum  EFileType { kDaqFile, kDcsFile, kBeamMonFile, kBogusFile }

Private Member Functions

void Init (Int_t nwords, Bool_t allow_overwrite)
void ResizeBuffer (TArray &buffer, Int_t size, const Char_t *name)
Int_t RecvCommand (TSocket *socket, RotoRcCmd &command)
Int_t CheckTo (RotoRcCmd &command)
Int_t ProcessCommand (TSocket *socket, RotoRcCmd command)
void ReplyToCommand (TSocket *socket, RotoRcCmd command, Int_t status)
Int_t OpenFile ()
Int_t CloseFile ()
string FileExtName (EFileType ftype)
string BogusFileName ()
Int_t OpenDaqFile (Int_t detector, Int_t run, Int_t subrun)
Int_t CloseDaqFile (Int_t detector, Int_t run, Int_t subrun)
string BuildDaqBaseName (Int_t detector, Int_t run, Int_t subrun)
Int_t OpenFile (const Char_t *name, EFileType ftype)
Int_t CloseFile (const Char_t *name, EFileType ftype)
Int_t OpenDcsFile (Int_t detector, Int_t sec, Int_t nanosec)
Int_t CloseDcsFile (Int_t detector, Int_t sec, Int_t nanosec)
string BuildDcsBaseName (Int_t detector, Int_t sec, Int_t nanosec)
Int_t OpenBeamMonFile (Int_t detector, Int_t sec, Int_t nanosec)
Int_t CloseBeamMonFile (Int_t detector, Int_t sec, Int_t nanosec)
string BuildBeamMonBaseName (Int_t detector, Int_t sec, Int_t nanosec)
Int_t ProcessBuffer ()
Int_t WriteRawRecord (const RawRecord *rawrec)
string ChooseStreamName (const RawRecord *rawrec)
Int_t ProcessConfig ()
void BuildStateReport ()
void CloseAndDeleteSocket (TSocket *&socket)

Private Attributes

Int_t fPort
Int_t fTCP_NODELAY_flag
TServerSocket * fServerSocket
TSocket * fSocket
MinosRooterState fCurrentState
TArrayC fRecvBuffer
Int_t fRecvBufferUsed
TArrayC fReplyBuffer
string fNackMessage
string fStateReport
Per::EAccessMode fAccessMode
PerOutputStreamManagerfOutputStreamManager
string fFakeDAQFileName
string fFlatBinaryName
FILE * fFlatBinaryOutputFile
std::map< Per::EStreamType,
UInt_t > 
fAutoSaveIntMap
std::map< Per::EStreamType,
UInt_t > 
fAutoSaveTimeMap
std::map< Per::EStreamType, Int_t > fCompressionMap
std::map< Per::EStreamType,
UInt_t > 
fBasketSizeMap
VldTimeStamp fStartTime
string fSymlink

Static Private Attributes

static UInt_t fgDebugFlags = 0

Detailed Description

Definition at line 31 of file RotoServer.h.


Member Enumeration Documentation

enum RotoServer::EFileType [private]
Enumerator:
kDaqFile 
kDcsFile 
kBeamMonFile 
kBogusFile 

Definition at line 52 of file RotoServer.h.

00052                   {
00053       kDaqFile,
00054       kDcsFile,
00055       kBeamMonFile,
00056       kBogusFile
00057    };


Constructor & Destructor Documentation

RotoServer::RotoServer ( Int_t  port,
Int_t  nwords,
Bool_t  allow_overwrite = kFALSE,
Int_t  tcp_nodelay_flag = 0 
)

Definition at line 79 of file RotoServer.cxx.

References fServerSocket, fTCP_NODELAY_flag, and Init().

00081   : fPort(port), fTCP_NODELAY_flag(tcp_nodelay_flag),
00082     fFlatBinaryName(""), fFlatBinaryOutputFile(0), fSymlink("")
00083 {
00084 //
00085 //  Purpose:  Create a RotoServer
00086 //            Open the server socket looking for connections on the port
00087 //            Allocate buffer to receive data
00088 //
00089 //  Argument: port     TCP/IP port #
00090 //            nwords   number of words for initial data recv buffer
00091 //            allow_overwrite   all server to overwrite output files
00092 //            tcp_nodelay_flag  set socket to use TCP_NODELAY
00093 //
00094 //  Return:   (none)
00095 //
00096 //  Contact:  R. Hatcher
00097 //
00098 
00099    Init(nwords, allow_overwrite);
00100 
00101    fServerSocket = new TServerSocket(port, kTRUE);
00102    fServerSocket->SetOption(kNoDelay,fTCP_NODELAY_flag);
00103 }

RotoServer::RotoServer ( const char *  fileName,
Int_t  nwords,
Bool_t  allow_overwrite = kFALSE 
)

Definition at line 106 of file RotoServer.cxx.

References fSocket, and Init().

00108    : fFlatBinaryName(""), fFlatBinaryOutputFile(0), fSymlink("")
00109 {
00110 //
00111 //  Purpose:  Create a RotoServer
00112 //            Open the RotoSocket (file emulation of a TSocket)
00113 //            Allocate buffer to receive data
00114 //
00115 //  Argument: fileName File name for RotoSocket.
00116 //            nwords   number of words for initial data recv buffer
00117 //            allow_overwrite kTRUE if allowed to overwite output file.
00118 //
00119 //  Return:   (none)
00120 //
00121 //  Contact:  R. Hatcher
00122 //
00123 
00124    Init(nwords, allow_overwrite);
00125 
00126    fSocket = new RotoSocket(fileName);
00127 
00128 }

RotoServer::~RotoServer (  ) 

Definition at line 130 of file RotoServer.cxx.

References CloseAndDeleteSocket(), PerStreamManager::CloseStream(), fCurrentState, fOutputStreamManager, fServerSocket, fSocket, logNotice(), MINOS_ROOTER_STATE_STOPPING, MINOS_ROOTER_STATE_UNKNOWN, SetFlatBinaryOutputFile(), and PerOutputStreamManager::Write().

00131 {
00132 //
00133 //  Purpose:  Destroy a RotoServer
00134 //            Close the server socket looking for connections on the port
00135 //            Close any open sockets
00136 //            Deallocate buffer to receive data
00137 //
00138 //  Argument: (none)
00139 //
00140 //  Return:   (none)
00141 //
00142 //  Contact:  R. Hatcher
00143 //
00144 
00145    fCurrentState = MINOS_ROOTER_STATE_STOPPING;
00146 
00147    if (fServerSocket) {
00148       fServerSocket->Close();
00149       delete fServerSocket;
00150       fServerSocket = 0;
00151    }
00152 
00153    CloseAndDeleteSocket(fSocket);
00154 
00155    if (fOutputStreamManager) {
00156       // make sure *everything* has been flushed
00157       fOutputStreamManager->Write();
00158       fOutputStreamManager->CloseStream();
00159       //CloseStream() makes this redundant: fOutputStreamManager->CloseFile();
00160      
00161       delete fOutputStreamManager;
00162       fOutputStreamManager = 0;
00163    }   
00164 
00165    SetFlatBinaryOutputFile("");
00166 
00167    fCurrentState = MINOS_ROOTER_STATE_UNKNOWN;
00168 
00169    logNotice("~RotoServer");
00170 }


Member Function Documentation

string RotoServer::BogusFileName (  )  [private]

Definition at line 1067 of file RotoServer.cxx.

References fname, Form(), fPort, fStartTime, VldTimeStamp::GetDate(), VldTimeStamp::GetTime(), and gSystem().

Referenced by WriteRawRecord().

01068 {
01069 //
01070 //  Purpose:  return bogus file name
01071 //
01072 //  Argument: (none)
01073 //
01074 //  Return:   string of a file name in which to put records
01075 //            who's real destination couldn't be determined
01076 //            tag it with the machine, port, and current date/time
01077 //
01078 //  Contact:  R. Hatcher
01079 //   
01080    Int_t date = fStartTime.GetDate();
01081    if (date>19700000) date %= 1000000;
01082    Int_t time = fStartTime.GetTime();
01083    string fname = Form("BOGUS_%s_p%d_%6.6d_%6.6d",
01084                        gSystem->HostName(),fPort,date,time);
01085    // squeeze out any blanks with "_"
01086    string::size_type where;
01087    while (string::npos != (where = fname.find(" "))) {
01088       fname.replace(where,1,"_");
01089    }
01090    return fname;
01091 }

string RotoServer::BuildBeamMonBaseName ( Int_t  detector,
Int_t  sec,
Int_t  nanosec 
) [private]

Definition at line 1491 of file RotoServer.cxx.

References fname, Form(), VldTimeStamp::GetDate(), and VldTimeStamp::GetTime().

Referenced by CloseBeamMonFile(), and OpenBeamMonFile().

01493 {
01494 //
01495 //  Purpose:  Construct a standardized BEAMMON file/stream name
01496 //
01497 //  Argument: detector   detector type (near,far,caldet)
01498 //            sec        seconds of timestamp
01499 //            nanosec    nanoseconds
01500 //
01501 //  Return:   the base file/stream name
01502 //
01503 //  Contact:  R. Hatcher
01504 //   
01505 
01506    // Detector::Detector_t det = (Detector::Detector_t)(detector);
01507    // Char_t detchar = Detector::AsString(det)[0];
01508    VldTimeStamp starttime(sec,nanosec);
01509    Int_t date = starttime.GetDate();
01510    if (date>19700000) date %= 1000000;
01511    Int_t time = starttime.GetTime();
01512 
01513    string fname = Form("B%6.6d_%6.6d",date,time);
01514    return fname;
01515 }

string RotoServer::BuildDaqBaseName ( Int_t  detector,
Int_t  run,
Int_t  subrun 
) [private]

Definition at line 1443 of file RotoServer.cxx.

References bfld::AsString(), det, fname, and Form().

Referenced by ChooseStreamName(), CloseDaqFile(), and OpenDaqFile().

01444 {
01445 //
01446 //  Purpose:  Construct a standardized DAQ file/stream name base
01447 //
01448 //  Argument: detector   detector type (near,far,caldet)
01449 //            run        run # 
01450 //            subrun     subrun #
01451 //
01452 //  Return:   the base file/stream name
01453 //
01454 //  Contact:  R. Hatcher
01455 //   
01456 
01457    Detector::Detector_t det = (Detector::Detector_t)(detector);
01458    Char_t detchar = Detector::AsString(det)[0];
01459 
01460    string fname = Form("%c%8.8d_%4.4d",detchar,run,subrun);
01461    return fname;
01462 }

string RotoServer::BuildDcsBaseName ( Int_t  detector,
Int_t  sec,
Int_t  nanosec 
) [private]

Definition at line 1465 of file RotoServer.cxx.

References bfld::AsString(), det, fname, Form(), VldTimeStamp::GetDate(), and VldTimeStamp::GetTime().

Referenced by CloseDcsFile(), and OpenDcsFile().

01466 {
01467 //
01468 //  Purpose:  Construct a standardized DCS file/stream name
01469 //
01470 //  Argument: detector   detector type (near,far,caldet)
01471 //            sec        seconds of timestamp
01472 //            nanosec    nanoseconds
01473 //
01474 //  Return:   the base file/stream name
01475 //
01476 //  Contact:  R. Hatcher
01477 //   
01478 
01479    Detector::Detector_t det = (Detector::Detector_t)(detector);
01480    Char_t detchar = Detector::AsString(det)[0];
01481    VldTimeStamp starttime(sec,nanosec);
01482    Int_t date = starttime.GetDate();
01483    if (date>19700000) date %= 1000000;
01484    Int_t time = starttime.GetTime();
01485 
01486    string fname = Form("%c%6.6d_%6.6d",detchar,date,time);
01487    return fname;
01488 }

void RotoServer::BuildStateReport (  )  [private]

Definition at line 1856 of file RotoServer.cxx.

References RotoRcCmd::ElementAsStlString(), fCurrentState, fStateReport, RotoRcCmd::InstrAsStlString(), MINOS_ROOTER_ROOTER, and MINOS_ROOTER_STATE_REPORT.

Referenced by ProcessCommand().

01857 {
01858 //
01859 //  Purpose:  Update state report string
01860 //
01861 //  Argument: (none)
01862 //
01863 //  Return:   (none) [fStateReport is modified]
01864 //
01865 //  Contact:  R. Hatcher
01866 //   
01867    fStateReport  = RotoRcCmd::ElementAsStlString(MINOS_ROOTER_ROOTER);
01868    fStateReport += "; ";
01869    fStateReport += 
01870       RotoRcCmd::InstrAsStlString(MINOS_ROOTER_STATE_REPORT,fCurrentState);
01871    fStateReport += "; ";
01872 }

Int_t RotoServer::CheckTo ( RotoRcCmd command  )  [private]

Definition at line 615 of file RotoServer.cxx.

References RotoRcCmd::fEncoded, RotoRcCmd::GetTo(), kFailNotToMe, kSuccess, logError(), and MINOS_ROOTER_ROOTER.

Referenced by Run().

00616 {
00617 //
00618 //  Purpose:  Check if this command was directed to the right place
00619 //
00620 //  Argument: command   Run Control command
00621 //
00622 //  Return:   kSuccess      if okay
00623 //            kFailNotToMe  if not intended for RotoRooter
00624 //
00625 //  Contact:  R. Hatcher
00626 //
00627 
00628    int to = command.GetTo();
00629    if (to == MINOS_ROOTER_ROOTER) return kSuccess;
00630 
00631    logError("I am 0x%2.2x, got message for 0x%2.2x (cmd 0x%8.8x)",
00632             MINOS_ROOTER_ROOTER,to,command.fEncoded);
00633 
00634    // if (fgDebugFlags & dbg_ReportNotTo) 
00635    //   MSG("Roto", Msg::kInfo) 
00636    //      << "RotoServer::Run received message meant for 0x" 
00637    //      << hex << to << dec
00638    //      << ",  I am 0x" 
00639    //      << hex << MINOS_ROOTER_ROOTER << dec 
00640    //      << endl;
00641 
00642    return kFailNotToMe;
00643 }

string RotoServer::ChooseStreamName ( const RawRecord rawrec  )  [private]

Definition at line 1656 of file RotoServer.cxx.

References bfld::AsString(), BuildDaqBaseName(), fFakeDAQFileName, VldContext::GetDetector(), RawRecord::GetRawHeader(), RawDaqHeader::GetRun(), RawDaqHeader::GetSubRun(), RecMinosHdr::GetVldContext(), Per::kBeamMon, Per::kDaqMonitor, Per::kDaqSnarl, Per::kDcsAlarm, Per::kDcsMonitor, Per::kLightInjection, logWarn(), and run().

Referenced by WriteRawRecord().

01657 {
01658 //
01659 //  Purpose:  Pick which stream to put this record into
01660 //
01661 //  Argument: (none)
01662 //
01663 //  Return:   name of stream
01664 //
01665 //  Contact:  R. Hatcher
01666 //   
01667    string rotoStrmName;
01668 
01669    VldContext vldc = rawrec->GetRawHeader()->GetVldContext(); // always okay
01670    
01671    const RawDaqHeader *rawdaqhead = 
01672       dynamic_cast<const RawDaqHeader *>(rawrec->GetRawHeader());
01673    
01674    const RawBeamMonHeader *rawbeammonhead =
01675       dynamic_cast<const RawBeamMonHeader *>(rawrec->GetRawHeader());
01676 
01677    if (rawdaqhead) {
01678       // this came from the DAQ
01679       Int_t run    = rawdaqhead->GetRun();
01680       Int_t subrun = rawdaqhead->GetSubRun();
01681       
01682       Per::EStreamType stype = Per::kDaqMonitor;
01683       
01684       TIter blkiter =
01685          (const_cast<RawRecord*>(rawrec))->GetRawBlockIter();
01686       TObject*            tobj = 0;
01687       const RawDataBlock* rb   = 0;
01688 
01689       Bool_t sawLISummary = false;
01690       Bool_t sawSnarlHeader = false;
01691       Bool_t sawDigitBlock = false;
01692 
01693       while ( (tobj = blkiter()) ) {
01694          rb = dynamic_cast<RawDataBlock*>(tobj);
01695 
01696          if ((dynamic_cast<const RawLIAdcSummaryBlock*>(rb))) 
01697             sawLISummary = true;
01698 
01699          if ((dynamic_cast<const RawLITimingSummaryBlock*>(rb)))
01700             sawLISummary = true;
01701 
01702          if ((dynamic_cast<const RawSnarlHeaderBlock*>(rb)))
01703             sawSnarlHeader = true;
01704 
01705          if ((dynamic_cast<const RawDigitDataBlock*>(rb)))
01706             sawDigitBlock = true;
01707       }
01708       // decide on which stream
01709       // if has LI blocks then --> LightInjection
01710       // else if had Snarl then --> DaqSnarl
01711       // otherwise --> DaqMonitor
01712       
01713       if (sawLISummary) {
01714          stype = Per::kLightInjection;
01715       }
01716       else if (sawSnarlHeader || sawDigitBlock ) {
01717          stype = Per::kDaqSnarl;
01718          if (!sawSnarlHeader || !sawDigitBlock ) {
01719             logWarn("XOR RawSnarlHeaderBlock %d RawDgitiDataBlock %d",
01720                    sawSnarlHeader,sawDigitBlock);
01721             
01722             //MSG("Roto", Msg::kWarning) 
01723             //   << "RotoServer::ProcessBuffer " 
01724             //   << "  RawSnarlHeaderBlock " << snarl_hdr 
01725             //   << "  RawDigitDataBlock " << digits
01726             //   << endl;
01727          }
01728       }
01729       
01730       // if we're in "one file" mode then the stream naming
01731       // doesn't depend on run/subrun
01732       if (fFakeDAQFileName != "") {
01733          rotoStrmName = fFakeDAQFileName;
01734       } else {
01735          rotoStrmName = BuildDaqBaseName(vldc.GetDetector(),run,subrun);
01736       }
01737       string streamType = Per::AsString(stype);
01738       rotoStrmName +=  "." + streamType;
01739 
01740    }
01741    else if (rawbeammonhead) {
01742       // this came from the BEAMMON
01743      Per::EStreamType stype = Per::kBeamMon;
01744 
01745      string streamType = Per::AsString(stype);
01746      rotoStrmName = "beam." + streamType;
01747 
01748    }
01749    else {
01750      // assume it came from the DCS
01751      Per::EStreamType stype = Per::kDcsMonitor;
01752      
01753      TIter blkiter =
01754        (const_cast<RawRecord*>(rawrec))->GetRawBlockIter();
01755      TObject*            tobj = 0;
01756      const RawDataBlock* rb   = 0;
01757      
01758      Bool_t sawAlarm = false;
01759      
01760      while ( (tobj = blkiter()) ) {
01761        rb = dynamic_cast<RawDataBlock*>(tobj);
01762        
01763        if ((dynamic_cast<const RawDcsAlarmBlock*>(rb))) 
01764          sawAlarm = true;
01765        
01766      }
01767      if (sawAlarm) stype = Per::kDcsAlarm;
01768      
01769      string streamType = Per::AsString(stype);
01770      rotoStrmName = "dcs." + streamType;
01771 
01772    }
01773 
01774    return rotoStrmName;
01775 }

void RotoServer::CloseAndDeleteSocket ( TSocket *&  socket  )  [private]

Definition at line 173 of file RotoServer.cxx.

Referenced by Run(), and ~RotoServer().

00174 {
00175 //
00176 //  Purpose:  Close and delete socket; zero pointer
00177 //
00178 //  Argument: socket   reference to pointer to socket      
00179 //
00180 //  Return:   (none)
00181 //
00182 //  Contact:  R. Hatcher
00183 //
00184    if (socket) {
00185       if (socket->IsValid()) socket->Close();
00186       delete socket;
00187       socket = 0;
00188    }
00189 }

Int_t RotoServer::CloseBeamMonFile ( Int_t  detector,
Int_t  sec,
Int_t  nanosec 
) [private]

Definition at line 1349 of file RotoServer.cxx.

References BuildBeamMonBaseName(), CloseFile(), and kBeamMonFile.

Referenced by CloseFile().

01350 {
01351 //
01352 //  Purpose:  Close the BEAMMON file
01353 //
01354 //  Argument: detector   detector type (near,far,caldet)
01355 //            sec        seconds when file was started
01356 //            nanosec    nano when file was started
01357 //
01358 //  Return:   if 0 then file closure as okay
01359 //
01360 //  Contact:  R. Hatcher
01361 //   
01362 
01363    string filebase = BuildBeamMonBaseName(detector,sec,nanosec);
01364    return CloseFile(filebase.c_str(),kBeamMonFile);
01365 }

Int_t RotoServer::CloseDaqFile ( Int_t  detector,
Int_t  run,
Int_t  subrun 
) [private]

Definition at line 1311 of file RotoServer.cxx.

References BuildDaqBaseName(), CloseFile(), and kDaqFile.

Referenced by CloseFile().

01312 {
01313 //
01314 //  Purpose:  Close a DAQ file
01315 //
01316 //  Argument: detector   detector type (near,far,caldet)
01317 //            run        run # 
01318 //            subrun     subrun #
01319 //
01320 //  Return:   if >0 then file closure was okay
01321 //
01322 //  Contact:  R. Hatcher
01323 //   
01324 
01325    string filebase = BuildDaqBaseName(detector,run,subrun);
01326    return CloseFile(filebase.c_str(),kDaqFile);
01327 }

Int_t RotoServer::CloseDcsFile ( Int_t  detector,
Int_t  sec,
Int_t  nanosec 
) [private]

Definition at line 1330 of file RotoServer.cxx.

References BuildDcsBaseName(), CloseFile(), and kDcsFile.

Referenced by CloseFile().

01331 {
01332 //
01333 //  Purpose:  Close the DCS file
01334 //
01335 //  Argument: detector   detector type (near,far,caldet)
01336 //            sec        seconds when file was started
01337 //            nanosec    nano when file was started
01338 //
01339 //  Return:   if 0 then file closure as okay
01340 //
01341 //  Contact:  R. Hatcher
01342 //   
01343 
01344    string filebase = BuildDcsBaseName(detector,sec,nanosec);
01345    return CloseFile(filebase.c_str(),kDcsFile);
01346 }

Int_t RotoServer::CloseFile ( const Char_t *  name,
EFileType  ftype 
) [private]

Definition at line 1368 of file RotoServer.cxx.

References bfld::AsString(), PerStreamManager::CloseStream(), FileExtName(), fOutputStreamManager, gSystem(), Per::kBeamMon, kBeamMonFile, kBogusFile, kDaqFile, Per::kDaqSnarl, Per::kDcsAlarm, kDcsFile, Per::kDcsMonitor, kFailWhoops, Per::kLightInjection, kSuccess, logInfo(), and PerOutputStreamManager::Write().

01369 {
01370 //
01371 //  Purpose:  Close a DAQ/DCS/BEAMMON file
01372 //
01373 //  Argument: fnamebase  file name without extension
01374 //            ftype     kDaqFile, kDcsFile, kBeamMonFile or kBogusFile
01375 //
01376 //  Return:   if >0 then file closure was okay
01377 //
01378 //  Contact:  R. Hatcher
01379 //   
01380    const char* pbasedir = gSystem->Getenv("DAQ_DATA_DIR");
01381    if (kDcsFile == ftype) {
01382      // if DCS file and DCS_DATA_DIR is defined use that
01383      const char* pdcsdir = gSystem->Getenv("DCS_DATA_DIR");
01384      if (pdcsdir) pbasedir = pdcsdir;
01385    }
01386    // if no base dir use current working directory
01387    if (!pbasedir) pbasedir = ".";
01388    string filename = string(pbasedir)  + "/" + 
01389                      string(fnamebase) + "." + 
01390                      FileExtName(ftype);
01391    logInfo("CloseFile '%s'",filename.c_str());
01392 
01393    bool closeok = true;
01394 
01395    // close possible streams
01396    // !!!!!! needs more protection against failures
01397 
01398    int ibeg = Per::kDaqSnarl;
01399    int iend = Per::kDcsMonitor;
01400    if (kDaqFile == ftype) {
01401       ibeg = Per::kDaqSnarl;
01402       iend = Per::kLightInjection;
01403    }
01404    else
01405    if (kDcsFile == ftype) {
01406       ibeg = Per::kDcsAlarm;
01407       iend = Per::kDcsMonitor;
01408    }
01409    else
01410    if (kBeamMonFile == ftype) {
01411       ibeg = Per::kBeamMon;
01412       iend = Per::kBeamMon;
01413    }
01414 
01415    string fbase = fnamebase;
01416    // if the file is a dcs or bogus one, then the stream names
01417    // only have "dcs" or "bogus" and not the full file name
01418    // as there can be only one of each
01419    switch (ftype) {
01420    case kDcsFile:     fbase = "dcs";   break;
01421    case kBeamMonFile: fbase = "beam";  break;
01422    case kBogusFile:   fbase = "bogus"; break;
01423    default:
01424      // do nothing
01425      break;
01426    }
01427 
01428    for (int i = ibeg; i<=iend; i++ ) {
01429       Per::EStreamType stype = (Per::EStreamType) i;
01430       string treeName = Per::AsString(stype);
01431       string rotoStrmName = fbase + "." + treeName;
01432 
01433       fOutputStreamManager->Write(rotoStrmName);
01434       fOutputStreamManager->CloseStream(rotoStrmName);
01435    }
01436    // CloseStream does this for us (besides this method takes a stream name)
01437    // fOutputStreamManager->CloseFile(filename);
01438                                                   
01439    return (closeok) ? kSuccess : kFailWhoops;
01440 }

Int_t RotoServer::CloseFile ( void   )  [private]

Definition at line 964 of file RotoServer.cxx.

References CloseBeamMonFile(), CloseDaqFile(), CloseDcsFile(), RotoRcCmd::ElementAsStlString(), err(), fFakeDAQFileName, fNackMessage, fname, fRecvBuffer, fRecvBufferUsed, kDaqFile, kFailCmdBadFrom, kFailOpenFile, logError(), MINOS_ROOTER_BEAMMON, MINOS_ROOTER_DCP, and MINOS_ROOTER_DCS.

Referenced by CloseBeamMonFile(), CloseDaqFile(), CloseDcsFile(), and ProcessCommand().

00965 {
00966 //
00967 //  Purpose:  Close a file, use buffer to determine parameters
00968 //
00969 //  Argument: (none)
00970 //
00971 //  Return:   if 0 then file closure was okay
00972 //
00973 //  Contact:  R. Hatcher
00974 //   
00975    int    nwords = fRecvBufferUsed/sizeof(Int_t);
00976    if (nwords<1) {
00977       logError("CloseFile() too few words (%d)",nwords);
00978       return kFailOpenFile;
00979    }
00980    Int_t* ibuffer = (Int_t*) fRecvBuffer.GetArray();
00981    Int_t from = ibuffer[0];
00982 
00983    switch (from) {
00984    case MINOS_ROOTER_DCP:
00985       if (fFakeDAQFileName != "") {
00986          fNackMessage += "CloseFile not possible, in FakeDaqFile mode ";
00987          fNackMessage += ";";
00988          return kFailCmdBadFrom;
00989       }
00990       if (nwords<4) {
00991          logError("CloseFile() from DCP too few words (%d)",nwords);
00992          return kFailOpenFile;
00993       }
00994       return CloseDaqFile(ibuffer[1],ibuffer[2],ibuffer[3]);
00995       break;
00996    case MINOS_ROOTER_DCS:
00997       if (fFakeDAQFileName != "") {
00998          fNackMessage += "CloseFile not possible, in FakeDaqFile mode ";
00999          fNackMessage += ";";
01000          return kFailCmdBadFrom;
01001       }
01002       if (nwords<4) {
01003          logError("CloseFile() from DCS too few words (%d)",nwords);
01004          return kFailOpenFile;
01005       }
01006       return CloseDcsFile(ibuffer[1],ibuffer[2],ibuffer[3]);
01007       break;
01008    case MINOS_ROOTER_BEAMMON:
01009       if (fFakeDAQFileName != "") {
01010          fNackMessage += "CloseFile not possible, in FakeDaqFile mode ";
01011          fNackMessage += ";";
01012          return kFailCmdBadFrom;
01013       }
01014       if (nwords<4) {
01015          logError("CloseFile() from BEAMMON too few words (%d)",nwords);
01016          return kFailOpenFile;
01017       }
01018       return CloseBeamMonFile(ibuffer[1],ibuffer[2],ibuffer[3]);
01019       break;
01020    default: {
01021       // a fake "from" in the buffer is a hack to support
01022       // binary files without proper header blocks
01023       // buffer should be 4bytes of "fake from" + the name
01024       EFileType ftype = kDaqFile;
01025       const char* fname = fRecvBuffer.GetArray()+sizeof(Int_t);
01026       Int_t err = CloseFile(fname,ftype);
01027       if (!err) fFakeDAQFileName = "";
01028       return err;
01029       break;
01030       }
01031    }
01032    fNackMessage += "CloseFile not possible from ";
01033    fNackMessage += RotoRcCmd::ElementAsStlString(from);
01034    fNackMessage += ";";
01035    return kFailCmdBadFrom;
01036 }

string RotoServer::FileExtName ( EFileType  ftype  )  [private]

Definition at line 1039 of file RotoServer.cxx.

References kBeamMonFile, kBogusFile, kDaqFile, kDcsFile, and logError().

Referenced by CloseFile(), and OpenFile().

01040 {
01041 //
01042 //  Purpose:  return standardized file extension names
01043 //
01044 //  Argument: ftype      enum of file types
01045 //
01046 //  Return:   string version of standard name
01047 //
01048 //  Contact:  R. Hatcher
01049 //   
01050    switch (ftype) {
01051    case kDaqFile:        return string("mdaq.root");    break;
01052    case kDcsFile:        return string("mdcs.root");    break;
01053    case kBeamMonFile:    return string("mbeam.root");   break;
01054    case kBogusFile:      return string("mall.root");    break;
01055    default:
01056       logError("bad FileExtName request %d",(int)ftype);
01057       //MSG("Roto", Msg::kInfo) 
01058       //   << "RotoServer::StreamName illegal enum value: " 
01059       //   << (int)stype << endl;      
01060       return string("generic.root");
01061       break;
01062    }
01063 
01064 }

static UInt_t RotoServer::GetDebugFlags (  )  [inline, static]

Definition at line 47 of file RotoServer.h.

References fgDebugFlags.

00047 { return fgDebugFlags; }

void RotoServer::Init ( Int_t  nwords,
Bool_t  allow_overwrite 
) [private]

Definition at line 192 of file RotoServer.cxx.

References fAccessMode, fCurrentState, fFakeDAQFileName, fNackMessage, fOutputStreamManager, fRecvBuffer, fReplyBuffer, fServerSocket, fSocket, fStateReport, Per::kNew, Per::kRecreate, logInfo(), MINOS_ROOTER_STATE_UNCONNECTED, MINOS_ROOTER_STATE_UNKNOWN, ResizeBuffer(), SetAutoSaveConfig(), SetBasketSizeConfig(), SetCompressConfig(), and RotoObjectifier::SysLogRawBlockRegistry().

Referenced by RotoServer().

00193 {
00194 //
00195 //  Purpose:  Common initialisation of a RotoServer
00196 //            Allocate buffer to receive data
00197 //
00198 //  Argument: nwords          - number of words for initial data recv buffer
00199 //            allow_overwrite - allow any existing file to be overwritten
00200 //
00201 //  Return:   (none)
00202 //
00203 //  Contact:  R. Hatcher
00204 //
00205 
00206    fServerSocket         = 0;
00207    fSocket               = 0;
00208    fCurrentState         = MINOS_ROOTER_STATE_UNKNOWN;
00209    fNackMessage          = ""; 
00210    fStateReport          = "";
00211    fAccessMode           = allow_overwrite ? Per::kRecreate : Per::kNew;
00212    fOutputStreamManager  = 0;
00213    fFakeDAQFileName      = "";
00214 
00215    ResizeBuffer(fRecvBuffer,nwords*sizeof(Int_t)/sizeof(Char_t),"Recv");
00216    ResizeBuffer(fReplyBuffer,4096*sizeof(Char_t),"Reply");
00217 
00218    fOutputStreamManager = new PerOutputStreamManager();
00219 
00220    fCurrentState = MINOS_ROOTER_STATE_UNCONNECTED;
00221    RotoObjectifier::SysLogRawBlockRegistry();
00222 
00223    logInfo("Default RotoServer configuration");
00224 
00225    // Set default AutoSave parameters
00226    // all streams: 1000 records or 10 seconds
00227    SetAutoSaveConfig("*",1000,10);
00228    // Set default Compression to use file defaults
00229    SetCompressConfig("*",-1);
00230    // Set default BasketSize to a uniform 64000
00231    SetBasketSizeConfig("*",64000);
00232 
00233 }

Int_t RotoServer::OpenBeamMonFile ( Int_t  detector,
Int_t  sec,
Int_t  nanosec 
) [private]

Definition at line 1132 of file RotoServer.cxx.

References BuildBeamMonBaseName(), kBeamMonFile, and OpenFile().

Referenced by OpenFile().

01133 {
01134 //
01135 //  Purpose:  Open the BEAMMON file
01136 //
01137 //  Argument: detector   detector type (near,far,caldet)
01138 //            sec        seconds when file was started
01139 //            nanosec    nano when file was started
01140 //
01141 //  Return:   if 0 then file creation was okay
01142 //
01143 //  Contact:  R. Hatcher
01144 //   
01145 
01146    string filebase = BuildBeamMonBaseName(detector,sec,nanosec);
01147    return OpenFile(filebase.c_str(),kBeamMonFile);
01148 }

Int_t RotoServer::OpenDaqFile ( Int_t  detector,
Int_t  run,
Int_t  subrun 
) [private]

Definition at line 1094 of file RotoServer.cxx.

References BuildDaqBaseName(), kDaqFile, and OpenFile().

Referenced by OpenFile().

01095 {
01096 //
01097 //  Purpose:  Open a DAQ file
01098 //
01099 //  Argument: detector   detector type (near,far,caldet)
01100 //            run        run # 
01101 //            subrun     subrun #
01102 //
01103 //  Return:   if 0 then file creation was okay
01104 //
01105 //  Contact:  R. Hatcher
01106 //   
01107 
01108    string filebase = BuildDaqBaseName(detector,run,subrun);
01109    return OpenFile(filebase.c_str(),kDaqFile);
01110 }

Int_t RotoServer::OpenDcsFile ( Int_t  detector,
Int_t  sec,
Int_t  nanosec 
) [private]

Definition at line 1113 of file RotoServer.cxx.

References BuildDcsBaseName(), kDcsFile, and OpenFile().

Referenced by OpenFile().

01114 {
01115 //
01116 //  Purpose:  Open the DCS file
01117 //
01118 //  Argument: detector   detector type (near,far,caldet)
01119 //            sec        seconds when file was started
01120 //            nanosec    nano when file was started
01121 //
01122 //  Return:   if 0 then file creation was okay
01123 //
01124 //  Contact:  R. Hatcher
01125 //   
01126 
01127    string filebase = BuildDcsBaseName(detector,sec,nanosec);
01128    return OpenFile(filebase.c_str(),kDcsFile);
01129 }

Int_t RotoServer::OpenFile ( const Char_t *  name,
EFileType  ftype 
) [private]

Definition at line 1151 of file RotoServer.cxx.

References bfld::AsString(), Per::AsString(), fAccessMode, fAutoSaveIntMap, fAutoSaveTimeMap, fBasketSizeMap, fCompressionMap, FileExtName(), Form(), fOutputStreamManager, fSocket, fSymlink, PerStream::GetErrorCode(), gSystem(), Per::kBeamMon, kBeamMonFile, kBogusFile, kDaqFile, Per::kDaqSnarl, Per::kDcsAlarm, kDcsFile, Per::kDcsMonitor, Per::kErrFileExists, Per::kErrSuccess, kFailWhoops, Msg::kInfo, Per::kLightInjection, Per::kRecSplit, kSuccess, logInfo(), logWarn(), MSG, PerOutputStreamManager::OpenStream(), PerOutputStream::SetAutoSave(), and PerStreamManager::SetFile().

01152 {
01153 //
01154 //  Purpose:  Open a DAQ/DCS/BEAMMON file
01155 //
01156 //  Argument: fnamebase  file name without extension
01157 //            ftype      kDaqFile, kDcsFile, kBeamMonFile or kBogusFile
01158 //
01159 //  Return:   if 0 then file creation was okay
01160 //
01161 //  Contact:  R. Hatcher
01162 // 
01163 
01164    const char* pbasedir = gSystem->Getenv("DAQ_DATA_DIR");
01165    if (kDcsFile == ftype) {
01166      // if DCS file and DCS_DATA_DIR is defined use that
01167      const char* pdcsdir = gSystem->Getenv("DCS_DATA_DIR");
01168      if (pdcsdir) pbasedir = pdcsdir;
01169    }
01170    if (kBeamMonFile == ftype) {
01171      // if Beam Monitor file and BEAM_DATA_DIR is defined use that
01172      const char* dir = gSystem->Getenv("BEAM_DATA_DIR");
01173      if (dir) pbasedir = dir;
01174    }
01175    // if no base dir use current working directory
01176    if (!pbasedir) pbasedir = ".";
01177    string filename = string(pbasedir)  + "/" + 
01178                      string(fnamebase) + "." + 
01179                      FileExtName(ftype);
01180    logInfo("OpenFile '%s'",filename.c_str());
01181 
01182    bool openok = true;
01183 
01184    // create possible streams, attach each to the file
01185    // !!!!!! needs more protection against failures
01186 
01187    int ibeg = Per::kDaqSnarl;
01188    int iend = Per::kDcsMonitor;
01189    if (kDaqFile == ftype) {
01190       ibeg = Per::kDaqSnarl;
01191       iend = Per::kLightInjection;
01192    }
01193    else
01194    if (kDcsFile == ftype) {
01195       ibeg = Per::kDcsAlarm;
01196       iend = Per::kDcsMonitor;
01197    }
01198    else
01199    if (kBeamMonFile == ftype) {
01200       ibeg = Per::kBeamMon;
01201       iend = Per::kBeamMon;
01202    }
01203 
01204    string fbase = fnamebase;
01205    // if the file is a dcs, beammon or bogus one, then the stream names
01206    // only have "dcs" or "bogus" and not the full file name
01207    // as there can be only one of each
01208    switch (ftype) {
01209    case kDcsFile:     fbase = "dcs";   break;
01210    case kBeamMonFile: fbase = "beam";  break;
01211    case kBogusFile:   fbase = "bogus"; break;
01212    default:
01213      // do nothing
01214      break;
01215    }
01216    int fversion = 0;
01217 
01218    // if running from RotoSocket (ie. connected directly to input
01219    // binary file) then don't bother with AutoSave   
01220    bool fromFile = fSocket->InheritsFrom("RotoSocket");
01221    if (fromFile) MSG("Roto",Msg::kInfo)
01222          << "Reading from RotoSocket - turn off autosave"
01223          << endl;
01224 
01225    for (int i = ibeg; i<=iend; i++ ) {
01226       Per::EStreamType stype = (Per::EStreamType) i;
01227       string treeName = Per::AsString(stype);
01228       string rotoStrmName = fbase + "." + treeName;
01229 
01230       Int_t  compressLevel = fCompressionMap[stype];
01231       UInt_t basketSize    = fBasketSizeMap[stype];
01232 
01233       PerOutputStream* astream =
01234          fOutputStreamManager->OpenStream(rotoStrmName,treeName,
01235                                           "RawRecord","","",Per::kRecSplit,
01236                                           basketSize,compressLevel);
01237       if (astream) {
01238          // possible tweaks
01239          //   autosave (interval: 0, setbasket = true)
01240          //   basketsaveint (interval: 0)
01241          if (fromFile) astream->SetAutoSave(0,0);
01242          else {
01243             UInt_t autoSaveInt  = fAutoSaveIntMap[stype];
01244             UInt_t autoSaveTime = fAutoSaveTimeMap[stype];
01245             astream->SetAutoSave(autoSaveInt,autoSaveTime);
01246          }
01247          bool openok_astream = 
01248             fOutputStreamManager->SetFile(rotoStrmName,filename,fAccessMode);
01249 
01250          // handle potential case where file already exists
01251          // and the rotorooter is in kNew not kRecreate mode
01252          Per::EErrorCode ecode = astream->GetErrorCode();
01253          if (Per::kErrFileExists == ecode) {
01254             string basefilename = filename;
01255             string::size_type where = filename.rfind(".m");
01256             if (string::npos == where) where = filename.rfind(".root");
01257             if (string::npos == where) where = filename.length();
01258             bool keep_trying = true;
01259             // start adding version numbers
01260             do {
01261                ++fversion;
01262                filename = basefilename;  // without any attempt at versioning
01263                filename.insert(where,Form(".%d",fversion));
01264                openok_astream = 
01265                   fOutputStreamManager->SetFile(rotoStrmName,filename,fAccessMode);
01266                if (Per::kErrSuccess != ecode) {
01267                   logWarn("open versioned file saw Per error: (%d) %s",
01268                           (int)ecode,Per::AsString(ecode));
01269                }
01270 
01271                ecode = astream->GetErrorCode();
01272                keep_trying = (fversion<100) &&
01273                   (Per::kErrFileExists == ecode);
01274             } while (keep_trying);
01275             // report if there was success
01276             if (Per::kErrSuccess == ecode) 
01277                logInfo("open stream using file %s",filename.c_str());
01278 
01279          } // file exists error
01280 
01281          if (Per::kErrSuccess != ecode) {
01282             logWarn("open stream saw Per error: (%d) %s",
01283                     (int)ecode,Per::AsString(ecode));
01284          }
01285 
01286          openok = openok && openok_astream;
01287          
01288          if (openok_astream) 
01289             logInfo("open stream %s as %s",
01290                     treeName.c_str(),rotoStrmName.c_str());
01291 
01292          //MSG("Roto", Msg::kDebug) 
01293          //   << "RotoServer::OpenDaqFile stream " << strmName
01294          //   << " opened " << ( (openok_astream) ? "ok" : "failed" )
01295          //   << endl;
01296       }
01297       else {
01298          openok = false;
01299       }
01300    }
01301 
01302    if (openok && fSymlink.size()) {
01303        gSystem->Unlink(fSymlink.c_str());
01304        gSystem->Symlink(filename.c_str(),fSymlink.c_str());
01305    }
01306 
01307    return (openok) ? kSuccess : kFailWhoops;
01308 }

Int_t RotoServer::OpenFile (  )  [private]

Definition at line 896 of file RotoServer.cxx.

References RotoRcCmd::ElementAsStlString(), err(), fFakeDAQFileName, fNackMessage, fname, fRecvBuffer, fRecvBufferUsed, kDaqFile, kFailCmdBadFrom, kFailOpenFile, logError(), logNotice(), MINOS_ROOTER_BEAMMON, MINOS_ROOTER_DCP, MINOS_ROOTER_DCS, OpenBeamMonFile(), OpenDaqFile(), and OpenDcsFile().

Referenced by OpenBeamMonFile(), OpenDaqFile(), OpenDcsFile(), ProcessCommand(), and WriteRawRecord().

00897 {
00898 //
00899 //  Purpose:  Open a file, use buffer to determine parameters
00900 //
00901 //  Argument: (none)
00902 //
00903 //  Return:   if 0 then file creation was okay
00904 //
00905 //  Contact:  R. Hatcher
00906 //   
00907    int    nwords = fRecvBufferUsed/sizeof(Int_t);
00908    if (nwords<1) {
00909       logError("OpenFile() too few words (%d)",nwords);
00910       return kFailOpenFile;
00911    }
00912    Int_t* ibuffer = (Int_t*) fRecvBuffer.GetArray();
00913    Int_t from = ibuffer[0];
00914 
00915    if (fFakeDAQFileName != "") {
00916       fNackMessage += "OpenFile not possible, already in FakeDaqFile mode ";
00917       fNackMessage += ";";
00918       logNotice("OpenFile() already in fake mode");
00919       return kFailCmdBadFrom;
00920    }
00921 
00922    switch (from) {
00923    case MINOS_ROOTER_DCP:
00924       if (nwords<4) {
00925          logError("OpenFile() from DCP too few words (%d)",nwords);
00926          return kFailOpenFile;
00927       }
00928       return OpenDaqFile(ibuffer[1],ibuffer[2],ibuffer[3]);
00929       break;
00930    case MINOS_ROOTER_DCS:
00931       if (nwords<4) {
00932          logError("OpenFile() from DCS too few words (%d)",nwords);
00933          return kFailOpenFile;
00934       }
00935       return OpenDcsFile(ibuffer[1],ibuffer[2],ibuffer[3]);
00936       break;
00937    case MINOS_ROOTER_BEAMMON:
00938       if (nwords<4) {
00939          logError("OpenFile() from BEAMMON too few words (%d)",nwords);
00940          return kFailOpenFile;
00941       }
00942       return OpenBeamMonFile(ibuffer[1],ibuffer[2],ibuffer[3]);
00943       break;
00944    default: {
00945       // a fake "from" in the buffer is a hack to support
00946       // binary files without proper header blocks
00947       // buffer should be 4bytes of "fake from" + the name
00948       EFileType ftype = kDaqFile;
00949       const char* fname = fRecvBuffer.GetArray()+sizeof(Int_t);
00950       Int_t err = OpenFile(fname,ftype);
00951       if (!err) fFakeDAQFileName = fname;
00952       return err;
00953       break;
00954       }
00955    }
00956    fNackMessage += "OpenFile not possible from ";
00957    fNackMessage += RotoRcCmd::ElementAsStlString(from);
00958    fNackMessage += ";";
00959    return kFailCmdBadFrom;
00960 }

Int_t RotoServer::ProcessBuffer (  )  [private]

Definition at line 1518 of file RotoServer.cxx.

References RotoObjectifier::BufferInflate(), fFlatBinaryOutputFile, fNackMessage, MomNavigator::FragmentIter(), fRecvBuffer, fRecvBufferUsed, kFailInflateBuff, kFailPartialRec, kSuccess, logDebug(), logError(), and WriteRawRecord().

Referenced by ProcessCommand().

01519 {
01520 //
01521 //  Purpose:  Process the RawRecord that is in the buffer
01522 //            Build it into objects, write it out
01523 //
01524 //  Argument: (none)
01525 //
01526 //  Return:   if 0 then conversion and write were successful
01527 //
01528 //  Contact:  R. Hatcher
01529 //   
01530    static Int_t nrec = 0;
01531 
01532    logDebug(5,"process buffer %d",nrec);
01533    // MSG("Roto", Msg::kDebug) << "RotoServer::ProcessBuffer " << nrec << endl;
01534 
01535    if (fFlatBinaryOutputFile) {
01536      Int_t recLength = fRecvBufferUsed + sizeof(recLength);
01537      fwrite(&recLength,sizeof(recLength),1,fFlatBinaryOutputFile);
01538      fwrite(fRecvBuffer.GetArray(),fRecvBufferUsed,1,fFlatBinaryOutputFile);
01539    }
01540 
01541    Int_t status = kSuccess;
01542    Int_t obj_status = 0;
01543 
01544    // turn buffer into record(s)
01545    MomNavigator* mom = 
01546       RotoObjectifier::BufferInflate(fRecvBuffer.GetArray(),
01547                                      fRecvBufferUsed,obj_status);
01548 
01549    if (!mom) {
01550       logError("buffer inflate returned no MOM, REC %d ERR %d",
01551                nrec,obj_status);
01552       return kFailInflateBuff;
01553    }
01554 
01555    if (4 == obj_status || 8 == obj_status) {
01556 
01557       logError("partial buffer failure rec %d err %d",nrec,obj_status);
01558 
01559       status |= kFailPartialRec;
01560       fNackMessage += "Portion of record could not be converted to RawDataBlocks;";
01561    }      
01562                      
01563    // write records out
01564 
01565    const RawRecord* rawrec = 0;
01566    TIter reciter = mom->FragmentIter();
01567    while ( ( rawrec = dynamic_cast<const RawRecord*>(reciter()) ) ) {
01568      status |= WriteRawRecord(rawrec);
01569      nrec++;
01570    }
01571 
01572    delete mom; // clean up
01573 
01574    return status;
01575 
01576 }

Int_t RotoServer::ProcessCommand ( TSocket *  socket,
RotoRcCmd  command 
) [private]

Definition at line 645 of file RotoServer.cxx.

References BuildStateReport(), CloseFile(), RotoRcCmd::ElementAsStlString(), fCurrentState, RotoRcCmd::fEncoded, fNackMessage, Form(), RotoRcCmd::GetFrom(), RotoRcCmd::GetInstr(), RotoRcCmd::GetType(), RotoRcCmd::InstrAsStlString(), kFailBadRcType, kFailCmdBadFrom, kFailCmdUnknown, kFailReqUnknown, kFailWhoops, kSuccess, logError(), logInfo(), MINOS_ROOTER_BEAMMON, MINOS_ROOTER_CLOSEFILE, MINOS_ROOTER_CLOSESOCKET, MINOS_ROOTER_COMMAND, MINOS_ROOTER_CONFIG, MINOS_ROOTER_DCP, MINOS_ROOTER_DCS, MINOS_ROOTER_OPENFILE, MINOS_ROOTER_OPENSOCKET, MINOS_ROOTER_RECBUFFER, MINOS_ROOTER_REQ_CURRENT_STATE, MINOS_ROOTER_REQ_STATUS_REPORT, MINOS_ROOTER_REQUEST, MINOS_ROOTER_SHUTDOWN, MINOS_ROOTER_STATE_DISCONNECTING, MINOS_ROOTER_STATE_SHUTDOWN_REQ, OpenFile(), ProcessBuffer(), ProcessConfig(), and RotoRcCmd::TypeAsStlString().

Referenced by Run().

00646 {
00647 //
00648 //  Purpose:  Process the command received on socket
00649 //
00650 //  Argument: socket      ptr to socket on which command is to be read
00651 //            command     RunControl encoded command
00652 //
00653 //  Return:   kSuccess (0)  if successful (yields ACK)
00654 //            various       if there was a problem (yields UNABLE_TO)
00655 //
00656 //  Contact:  R. Hatcher
00657 //
00658    int from  = command.GetFrom();
00659    int type  = command.GetType();
00660    int instr = command.GetInstr();
00661 
00662    switch (type) {
00663    case MINOS_ROOTER_COMMAND:
00664       if (MINOS_ROOTER_DCP     != from && 
00665           MINOS_ROOTER_DCS     != from && 
00666           MINOS_ROOTER_BEAMMON != from ) {
00667          logError("MinosEntity 0x%2.2x on %s attempted COMMAND",
00668                   from,socket->GetInetAddress().GetHostName());
00669 
00670          fNackMessage += 
00671             Form("Not from DCP, DCS or BEAMMON but %s (0x%x);",
00672                  RotoRcCmd::ElementAsStlString(from).c_str(),from);
00673          return kFailCmdBadFrom;
00674          break;
00675       }         
00676       switch (instr) {
00677       case MINOS_ROOTER_OPENSOCKET: 
00678          return kSuccess;
00679          break;
00680       case MINOS_ROOTER_CLOSESOCKET: 
00681          // we can't do this immediately here because we need to reply first
00682          fCurrentState = MINOS_ROOTER_STATE_DISCONNECTING;
00683          return kSuccess;
00684          break;
00685       case MINOS_ROOTER_OPENFILE: 
00686          return OpenFile();
00687          break;
00688       case MINOS_ROOTER_CLOSEFILE: 
00689          return CloseFile();
00690          break;
00691       case MINOS_ROOTER_RECBUFFER: 
00692          return ProcessBuffer();
00693          break;
00694       case MINOS_ROOTER_SHUTDOWN: 
00695          logInfo("MinosEntity 0x%2.2x on %s requested shutdown",
00696                  from,socket->GetInetAddress().GetHostName());
00697          // MSG("Roto",Msg::kInfo)
00698          //    << " Roto SHUTDOWN command " << endl;
00699          fCurrentState = MINOS_ROOTER_STATE_SHUTDOWN_REQ;
00700          return kSuccess;
00701          break;
00702       case MINOS_ROOTER_CONFIG:
00703          return ProcessConfig();
00704          break;
00705       default:
00706          logError("MinosEntity 0x%2.2x on %s bad cmd 0x%8.8x",
00707                   from,socket->GetInetAddress().GetHostName(),
00708                   command.fEncoded);
00709 
00710          fNackMessage += 
00711             Form("Unmodelled %s %s;",
00712                  RotoRcCmd::TypeAsStlString(type).c_str(),
00713                  RotoRcCmd::InstrAsStlString(type,instr).c_str());
00714          return kFailCmdUnknown;
00715          break;
00716       }
00717       break;
00718    case MINOS_ROOTER_REQUEST:
00719       switch (instr) {
00720       case MINOS_ROOTER_REQ_CURRENT_STATE: 
00721          return kSuccess;
00722          break;
00723       case MINOS_ROOTER_REQ_STATUS_REPORT: 
00724          BuildStateReport();
00725          return kSuccess;
00726          break;
00727       default:
00728          logError("MinosEntity 0x%2.2x on %s bad cmd 0x%8.8x",
00729                 from,socket->GetInetAddress().GetHostName(),
00730                 command.fEncoded);
00731 
00732          fNackMessage += 
00733             Form("Unmodelled %s %s;",
00734                  RotoRcCmd::TypeAsStlString(type).c_str(),
00735                  RotoRcCmd::InstrAsStlString(type,instr).c_str());
00736          return kFailReqUnknown;
00737          break;
00738       }
00739       break;
00740    default:
00741          logError("MinosEntity 0x%2.2x on %s bad cmd 0x%8.8x",
00742                   from,socket->GetInetAddress().GetHostName(),
00743                   command.fEncoded);
00744 
00745          fNackMessage += 
00746             Form("Unmodelled %s %s;",
00747                  RotoRcCmd::TypeAsStlString(type).c_str(),
00748                  RotoRcCmd::InstrAsStlString(type,instr).c_str());
00749       return kFailBadRcType;
00750       break;
00751    }
00752    return kFailWhoops;
00753 }

Int_t RotoServer::ProcessConfig (  )  [private]

Definition at line 1778 of file RotoServer.cxx.

References fRecvBuffer, logWarn(), SetAutoSaveConfig(), SetBasketSizeConfig(), and SetCompressConfig().

Referenced by ProcessCommand().

01779 {
01780 //
01781 //  Purpose:  Process the config that is in the buffer
01782 //            
01783 //  Argument: (none)
01784 //
01785 //  Return:   if 0 then config processing was uneventful
01786 //
01787 //  Contact:  R. Hatcher
01788 //   
01789 
01790    char config[1024];
01791    char stream[1024];
01792    int  nItems = 0;
01793    bool ok = true;
01794 
01795    //   nItems = sscanf(fRecvBuffer.GetArray(),
01796    //                   "config autosave: %s = %d rec %d sec",
01797    //                   stream,&nrec,&nsec);
01798 
01799    nItems = sscanf(fRecvBuffer.GetArray(),
01800                    "config %s:",config);
01801 
01802    if (!strncmp(config,"autosave",8)) {
01803      unsigned int nrec, nsec;
01804      nItems = sscanf(fRecvBuffer.GetArray(),
01805                      "config autosave: %s = %u rec %u sec",
01806                      stream,&nrec,&nsec);
01807 
01808      if (nItems != 3) ok = false;
01809      else {
01810        int nmod = SetAutoSaveConfig(stream,nrec,nsec);
01811        if (nmod < 1) {
01812          logWarn("ProcessConfig stream \"%s\" unknown\n",stream);
01813        }
01814      }
01815 
01816    }
01817    else if (!strncmp(config,"compress",8)) {
01818      int level;
01819      nItems = sscanf(fRecvBuffer.GetArray(),
01820                      "config compress: %s = %d",
01821                      stream,&level);
01822 
01823      if (nItems != 2) ok = false;
01824      else {
01825        int nmod = SetCompressConfig(stream,level);
01826        if (nmod < 1) {
01827          logWarn("ProcessConfig stream \"%s\" unknown\n",stream);
01828        }
01829      }
01830    }
01831    else if (!strncmp(config,"basketsize",10)) {
01832      int basketsize;
01833      nItems = sscanf(fRecvBuffer.GetArray(),
01834                      "config basketsize: %s = %d",
01835                      stream,&basketsize);
01836 
01837      if (nItems != 2) ok = false;
01838      else {
01839        int nmod = SetBasketSizeConfig(stream,basketsize);
01840        if (nmod < 1) {
01841          logWarn("ProcessConfig stream \"%s\" unknown\n",stream);
01842        }
01843      }
01844 
01845    }
01846    else ok = false;
01847 
01848    if (!ok) 
01849      logWarn("ProcessConfig failed to interpret string: \"%s\"\n",
01850              fRecvBuffer.GetArray());
01851 
01852    return 0;
01853 }

Int_t RotoServer::RecvCommand ( TSocket *  socket,
RotoRcCmd command 
) [private]

Definition at line 537 of file RotoServer.cxx.

References RotoRcCmd::fEncoded, fNackMessage, Form(), fRecvBuffer, fRecvBufferUsed, RotoRcCmd::HasDataToFollow(), kFailBuffResize, kFailRecvByteCnt, kFailRecvCmd, kFailRecvData, kSuccess, lBuffer, logError(), and ResizeBuffer().

Referenced by Run().

00538 {
00539 //
00540 //  Purpose:  Receive RunControl-protocol-like commands from socket
00541 //
00542 //  Argument: socket   ptr to socket on which command is to be read
00543 //            command  RunControl encoded command
00544 //
00545 //  Return:   kSuccess (0)     = success
00546 //            kFailRecvCmd     = error retrieving 4-byte command
00547 //            kFailRecvByteCnt = error retrieving followup byte count
00548 //            kFailRecvData    = error retrieving followup data
00549 //            kFailBuffResize  = could not resize buffer to hold entire record
00550 //                               RecvBuffer holds only partial record
00551 //
00552 //  Contact:  R. Hatcher
00553 //
00554    Int_t  lCommand, ltouse, lBuffer;
00555 
00556    lCommand = fRecvBufferUsed = ltouse = lBuffer = 0;
00557 
00558    //
00559    // Retrieve "command" (4bytes of packed info)
00560    //
00561    lCommand = socket->RecvRaw(&command.fEncoded,sizeof(Int_t));
00562    if (lCommand != sizeof(Int_t)) {
00563       logError("RecvRaw command got %d expect %d",
00564                lCommand,sizeof(Int_t));
00565       return kFailRecvCmd;
00566    }
00567    //
00568    // if DATATOFOLLOW bit is set get the size and the data
00569    //
00570    if (command.HasDataToFollow()) {
00571       // byte count includes its own 4 bytes
00572       Int_t extra_bytes; 
00573       ltouse = socket->RecvRaw(&extra_bytes,sizeof(Int_t));
00574       fRecvBufferUsed = extra_bytes - 4;
00575       if (ltouse != sizeof(Int_t)) {
00576       logError("RecvRaw nbytes got %d expect %d",
00577                ltouse,sizeof(Int_t));
00578          return kFailRecvByteCnt;
00579       }
00580       if (fRecvBufferUsed>0) {
00581          // there be data in dat' d'er socket
00582 
00583          // if the buffer isn't big enough resize it (up only)
00584          if (fRecvBufferUsed>fRecvBuffer.GetSize()) 
00585             ResizeBuffer(fRecvBuffer,fRecvBufferUsed,"Recv");
00586 
00587          Bool_t partial = false;
00588          if (fRecvBufferUsed>fRecvBuffer.GetSize()) {
00589             // couldn't resize buffer large enough
00590             fNackMessage += 
00591                Form("Buffer could only hold %d of %d;",
00592                     fRecvBuffer.GetSize(),fRecvBufferUsed);
00593             partial = true;
00594             fRecvBufferUsed = fRecvBuffer.GetSize();
00595          }
00596 
00597          lBuffer = socket->RecvRaw(fRecvBuffer.GetArray(),fRecvBufferUsed);
00598          if (lBuffer != fRecvBufferUsed) {
00599             logError("RecvRaw buffer got %d expect %d",
00600                      lBuffer,fRecvBufferUsed);
00601             fNackMessage += 
00602                Form("Buffer expected %d, saw %d;",
00603                     fRecvBufferUsed,lBuffer);
00604             return kFailRecvData;
00605          }
00606          if (partial) return kFailBuffResize;
00607 
00608       }
00609    }
00610 
00611    return kSuccess;
00612 }

void RotoServer::ReplyToCommand ( TSocket *  socket,
RotoRcCmd  command,
Int_t  status 
) [private]

Definition at line 756 of file RotoServer.cxx.

References RotoRcCmd::AsStlString(), fCurrentState, RotoRcCmd::fEncoded, fNackMessage, fReplyBuffer, fStateReport, RotoRcCmd::GetInstr(), RotoRcCmd::GetTo(), RotoRcCmd::GetType(), kSuccess, logError(), logInfo(), MINOS_ROOTER_ACKNOWLEDGE, MINOS_ROOTER_COMMAND, MINOS_ROOTER_REPORT, MINOS_ROOTER_REQ_CURRENT_STATE, MINOS_ROOTER_REQ_STATUS_REPORT, MINOS_ROOTER_REQUEST, MINOS_ROOTER_STATE_REPORT, MINOS_ROOTER_UNABLE_TO, ResizeBuffer(), RotoRcCmd::SetDataToFollow(), RotoRcCmd::SetInstr(), RotoRcCmd::SetType(), and RotoRcCmd::SwapFromTo().

Referenced by Run().

00758 {
00759 //
00760 //  Purpose:  Reply to the command received on socket
00761 //            Special commands send more than just ack/nack
00762 //
00763 //  Argument: socket   ptr to socket on which command is to be read
00764 //            command  RunControl encoded command
00765 //            ack      whether to send ACKNOWLEDGE or UNABLE_TO
00766 //
00767 //  Return:   (none)
00768 //
00769 //  Contact:  R. Hatcher
00770 //
00771    static Int_t nreply = 0;
00772    nreply++;
00773 
00774    Int_t type  = command.GetType();
00775    Int_t instr = command.GetInstr();
00776    Bool_t ack  = ( kSuccess == status );
00777 
00778    RotoRcCmd reply = command;
00779    reply.SwapFromTo();
00780 
00781    switch (type) {
00782    case MINOS_ROOTER_COMMAND: {
00783       //
00784       // send ACK/UNABLE_TO for COMMAND
00785       //
00786 
00787       // construct the entirety of what we're sending first
00788       // rather than sending the individual bits
00789       // combine ACK with STATE_REPORT into single socket->SendRaw
00790 
00791       Int_t  ackfield   = 
00792          (ack) ? MINOS_ROOTER_ACKNOWLEDGE : MINOS_ROOTER_UNABLE_TO;
00793       Bool_t nackmsg    = ( ! ack && fNackMessage.length()>0);
00794 
00795       int totmsgsize = sizeof(Int_t);
00796       if (nackmsg) totmsgsize += sizeof(Int_t) + fNackMessage.length();
00797       totmsgsize += sizeof(Int_t);
00798       if (totmsgsize>fReplyBuffer.GetSize())
00799          ResizeBuffer(fReplyBuffer,totmsgsize,"Reply");
00800       Char_t* p = fReplyBuffer.GetArray();
00801 
00802       reply.SetType(ackfield);
00803       reply.SetDataToFollow(nackmsg);
00804 //      socket->SendRaw(&reply.fEncoded,sizeof(Int_t));
00805       memcpy(p,&reply.fEncoded,sizeof(Int_t));
00806       p += sizeof(Int_t);
00807 
00808       if (!ack) {
00809          logError("sent NACK 0x%8.8x to MinosEntity 0x%2.2x on %s",
00810                   reply.fEncoded,reply.GetTo(),
00811                   socket->GetInetAddress().GetHostName());
00812          logError(reply.AsStlString().c_str());
00813          if (fNackMessage.length()>0) 
00814             logError("  %s",fNackMessage.c_str());
00815       }
00816 #ifdef VERBOSE_SYSLOG
00817       else {
00818 //rwh: very verbose
00819          logInfo("ACK to %s",command.AsStlString().c_str());
00820       }
00821 #endif
00822 
00823       if (nackmsg) {
00824          // byte count includes its own 4 bytes
00825          Int_t nackmsg_length = fNackMessage.length() + 4;
00826 //         socket->SendRaw(&nackmsg_length,sizeof(Int_t));
00827 //         socket->SendRaw(fNackMessage.c_str(),nackmsg_length-4);
00828          memcpy(p,&nackmsg_length,sizeof(Int_t));
00829          p += sizeof(Int_t);
00830          memcpy(p,fNackMessage.c_str(),nackmsg_length-4);
00831          p += nackmsg_length-4;
00832       }
00833       //
00834       // protocol says COMMAND also gets a STATE_REPORT reply
00835       //
00836       reply.SetType(MINOS_ROOTER_STATE_REPORT);
00837       reply.SetInstr(fCurrentState);
00838       reply.SetDataToFollow(false);
00839 //      socket->SendRaw(&reply.fEncoded,sizeof(Int_t));
00840       memcpy(p,&reply.fEncoded,sizeof(Int_t));
00841       p += sizeof(Int_t);
00842       socket->SendRaw(fReplyBuffer.GetArray(),totmsgsize);                 
00843         
00844       //if (fgDebugFlags & dbg_ReportReply) {
00845       //   string status_msg = "";
00846       //   if (status != 0) status_msg += Form("\n  status 0x%x",status);
00847       //   MSG("Roto", Msg::kInfo) 
00848       //      << "RotoServer::ReplyToCommand reply#" 
00849       //      << nreply 
00850       //      << " " << reply.AsStlString(reportOpt)
00851       //      << status_msg
00852       //      << endl;
00853 
00854       break;
00855    }
00856    case MINOS_ROOTER_REQUEST:
00857       switch (instr) {
00858       case MINOS_ROOTER_REQ_CURRENT_STATE:
00859          reply.SetType(MINOS_ROOTER_STATE_REPORT);
00860          reply.SetInstr(fCurrentState);
00861          reply.SetDataToFollow(false);
00862          socket->SendRaw(&reply.fEncoded,sizeof(Int_t));
00863          break;
00864       case MINOS_ROOTER_REQ_STATUS_REPORT: {
00865          reply.SetType(MINOS_ROOTER_REPORT);
00866          reply.SetInstr(MINOS_ROOTER_REQ_STATUS_REPORT);
00867          reply.SetDataToFollow(true);
00868          socket->SendRaw(&reply.fEncoded,sizeof(Int_t));
00869          // byte count includes its own 4 bytes
00870          Int_t report_length = fStateReport.length() + 4;
00871          socket->SendRaw(&report_length,sizeof(Int_t));
00872          socket->SendRaw(fStateReport.c_str(),report_length-4);
00873 
00874          //if (fgDebugFlags & dbg_ReportReply) 
00875          //   MSG("Roto", Msg::kInfo) 
00876          //      << "RotoServer::ReplyToCommand reply#" 
00877          //      << nreply 
00878          //      << " " << reply.AsStlString(reportOpt)
00879          //      << endl
00880          //      << "  \"" << fStateReport << "\" (" << report_length << ")"
00881          //      << endl;
00882          break;
00883       }
00884 
00885       default:
00886          break;
00887       }
00888       break;
00889    default:
00890       break;
00891    }      
00892           
00893 }

void RotoServer::ResizeBuffer ( TArray &  buffer,
Int_t  size,
const Char_t *  name 
) [private]

Definition at line 501 of file RotoServer.cxx.

References logError(), and logNotice().

Referenced by Init(), RecvCommand(), and ReplyToCommand().

00502 {
00503 //
00504 //  Purpose:  Attempt to resize receive/reply buffer size
00505 //
00506 //  Argument: buffer   TArray to be resized
00507 //            size     desire size in nominal units
00508 //            name     name for log messages
00509 //
00510 //  Return:   (none)
00511 //
00512 //  Contact:  R. Hatcher
00513 //
00514 
00515    int oldsize = buffer.GetSize();
00516    buffer.Set(0);  // toss old array so we don't copy contents
00517 
00518    Int_t request = size;
00519    Int_t failures = 0;
00520    while ( buffer.GetSize() != request ) {
00521       buffer.Set(request);
00522       if (buffer.GetSize() == request) break; // success!
00523       failures++;
00524       request -= 1024*sizeof(Int_t);  // failed, try smaller size
00525    }
00526 
00527    if (failures) {
00528          logError("resize %s buffer from %d to %d only got %d",
00529                   name,oldsize,size,request);
00530    } else {
00531          logNotice("resize %s buffer from %d to %d",
00532                    name,oldsize,size);
00533    }
00534 }

void RotoServer::Run (  ) 

Definition at line 382 of file RotoServer.cxx.

References CheckTo(), CloseAndDeleteSocket(), PerStreamManager::CloseStream(), dbg_ReportCmd, fCurrentState, fgDebugFlags, fNackMessage, fOutputStreamManager, fServerSocket, fSocket, fTCP_NODELAY_flag, kFailNotToMe, kFailRecvByteCnt, kFailRecvCmd, kFailRecvData, kSuccess, logCritical(), logDebug(), logError(), MINOS_ROOTER_STATE_CONNECTED, MINOS_ROOTER_STATE_DISCONNECTING, MINOS_ROOTER_STATE_SHUTDOWN_REQ, MINOS_ROOTER_STATE_UNCONNECTED, ProcessCommand(), RecvCommand(), ReplyToCommand(), and PerOutputStreamManager::Write().

Referenced by main().

00383 {
00384 //
00385 //  Purpose:  Main loop
00386 //            Test validity of server socket, wait for connection attempt
00387 //            accept commands on open socket, process and reply
00388 //
00389 //  Argument: (none)
00390 //
00391 //  Return:   (none)
00392 //
00393 //  Contact:  R. Hatcher
00394 //
00395 
00396    //
00397    // is this server socket okay? If missing the socket must be 
00398    // a valid RotoSocket.
00399    if (!fServerSocket ) { 
00400      if ( ! fSocket->IsValid() ) {
00401         logCritical("Unable to open file as RotoSocket");
00402         return;
00403      }
00404    }
00405    else if (!fServerSocket->IsValid()) {
00406       string why;
00407       switch (fServerSocket->GetErrorCode()) {
00408       case  0: why = "no error, socket should be valid"; break;
00409       case -1: why = "low level socket() call failed";   break;
00410       case -2: why = "low level bind() call failed - ";
00411                why += "port may already be in use";
00412                break;
00413       case -3: why = "low level listen() call failed";   break;
00414       default: why = "unknown error";                    break;
00415       }
00416       // MSG("Roto",Msg::kFatal) 
00417       //   << endl
00418       //   << "  server socket failed on port "
00419       //   << fServerSocket->GetLocalPort()
00420       //   << " was invalid \n  "
00421       //   << why
00422       //   << endl;
00423       logCritical("server socket on port %d failed, why=%s",
00424                   fServerSocket->GetLocalPort(),why.c_str());
00425       return;
00426    }
00427 
00428    fCurrentState = MINOS_ROOTER_STATE_UNCONNECTED;
00429    Int_t ncmd = 0;
00430 
00431    RotoRcCmd cmd;
00432 
00433    //
00434    // main loop, while shutdown hasn't been requested
00435    //
00436    while (fCurrentState != MINOS_ROOTER_STATE_SHUTDOWN_REQ) {
00437 
00438       // Accept a connection and return a full-duplex communication socket.
00439       if (!fSocket) {
00440          fSocket = fServerSocket->Accept();
00441          fSocket->SetOption(kNoDelay,fTCP_NODELAY_flag);
00442          //fSocket->SetOption(kKeepAlive,1);
00443          if (fCurrentState == MINOS_ROOTER_STATE_UNCONNECTED)
00444              fCurrentState = MINOS_ROOTER_STATE_CONNECTED;
00445       }
00446 
00447       Int_t status = kSuccess;
00448       fNackMessage = "";
00449 
00450       // accept commands on open socket
00451       
00452       status |= RecvCommand(fSocket,cmd);
00453       // failure to get command+data correctly is indicative
00454       // of a broken socket
00455       if (status & (kFailRecvCmd|kFailRecvByteCnt|kFailRecvData) ) {
00456          logError("socket from '%s' abruptly broken",
00457                   fSocket->GetInetAddress().GetHostName());
00458 
00459          // if (fgDebugFlags & dbg_ReportCmd) 
00460          //    MSG("Roto", Msg::kInfo) 
00461          //      << "RotoServer::Run socket appears broken"  << endl;
00462 
00463          // should here cleanly close all files associated with
00464          // this socket, for now (since we're single socketed)
00465          // just close *everything*
00466          fOutputStreamManager->Write();
00467          fOutputStreamManager->CloseStream();
00468          //CloseStream() makes this redundant: fOutputStreamManager->CloseFile();
00469          
00470          CloseAndDeleteSocket(fSocket);
00471          fCurrentState = MINOS_ROOTER_STATE_UNCONNECTED;
00472          continue;
00473       }
00474       ncmd++;
00475 
00476       if (fgDebugFlags & dbg_ReportCmd) 
00477          logDebug(3,"msg %d status %d",ncmd,status);
00478 
00479       //if (fgDebugFlags & dbg_ReportCmd) 
00480       //   MSG("Roto", Msg::kInfo) 
00481       //      << "RotoServer::Run msg#" 
00482       //      << ncmd << " status=" << status
00483       //      << " " << cmd.AsStlString(reportOpt)
00484       //      << endl;
00485 
00486       status |= CheckTo(cmd);
00487       if (status & kFailNotToMe) continue;
00488 
00489       status |= ProcessCommand(fSocket,cmd);
00490 
00491       ReplyToCommand(fSocket,cmd,status);
00492 
00493       if (fCurrentState == MINOS_ROOTER_STATE_DISCONNECTING) {
00494          CloseAndDeleteSocket(fSocket);
00495          fCurrentState = MINOS_ROOTER_STATE_UNCONNECTED;
00496       }
00497    }
00498 }

Int_t RotoServer::SetAutoSaveConfig ( const string &  stream,
UInt_t  nrec,
UInt_t  nsec 
)

Definition at line 236 of file RotoServer.cxx.

References bfld::AsString(), fAutoSaveIntMap, fAutoSaveTimeMap, Per::kBeamMon, Per::kDaqSnarl, and logInfo().

Referenced by config_autosave(), Init(), and ProcessConfig().

00237 {
00238 //
00239 //  Purpose:  Set AutoSave configuration values in <map>s
00240 //
00241 //  Argument: stream    - name of stream ("*" = all)
00242 //            nrec      - record frequency
00243 //            nsec      - max time duration
00244 //
00245 //  Return:   number of stream configs modified
00246 //
00247 //  Contact:  R. Hatcher
00248 //
00249 
00250    int nmod = 0;
00251 
00252    int ibeg = Per::kDaqSnarl;
00253    int iend = Per::kBeamMon;
00254    for (int i = ibeg; i<=iend; i++ ) {
00255       Per::EStreamType stype = (Per::EStreamType) i;
00256       string treeName = Per::AsString(stype);
00257       if (treeName == stream || stream == "*") {
00258          logInfo("AutoSave is %d records or %d seconds for %s stream",
00259                  nrec,nsec,treeName.c_str());
00260          fAutoSaveIntMap[stype]  = nrec;
00261          fAutoSaveTimeMap[stype] = nsec;
00262          nmod++;
00263       }
00264    }
00265 
00266    return nmod;
00267 }

Int_t RotoServer::SetBasketSizeConfig ( const string &  stream,
UInt_t  basketsize 
)

Definition at line 306 of file RotoServer.cxx.

References bfld::AsString(), fBasketSizeMap, Per::kBeamMon, Per::kDaqSnarl, and logInfo().

Referenced by config_basketsize(), Init(), and ProcessConfig().

00307 {
00308 //
00309 //  Purpose:  Set BasketSize configuration values in <map>s
00310 //
00311 //  Argument: stream     - name of stream ("*" = all)
00312 //            basketsize - size of basket
00313 //
00314 //  Return:   number of stream configs modified
00315 //
00316 //  Contact:  R. Hatcher
00317 //
00318 
00319    int nmod = 0;
00320 
00321    int ibeg = Per::kDaqSnarl;
00322    int iend = Per::kBeamMon;
00323    for (int i = ibeg; i<=iend; i++ ) {
00324       Per::EStreamType stype = (Per::EStreamType) i;
00325       string treeName = Per::AsString(stype);
00326       if (treeName == stream || stream == "*") {
00327          logInfo("BasketSize is %d for %s stream",
00328                  basketsize,treeName.c_str());
00329          fBasketSizeMap[stype]  = basketsize;
00330          nmod++;
00331       }
00332    }
00333 
00334    return nmod;
00335 }

Int_t RotoServer::SetCompressConfig ( const string &  stream,
Int_t  level 
)

Definition at line 270 of file RotoServer.cxx.

References bfld::AsString(), fCompressionMap, Per::kBeamMon, Per::kDaqSnarl, and logInfo().

Referenced by config_compress(), Init(), and ProcessConfig().

00271 {
00272 //
00273 //  Purpose:  Set Compression configuration values in <map>s
00274 //
00275 //  Argument: stream    - name of stream ("*" = all)
00276 //            level     - compression level
00277 //                          -1 : use file default
00278 //                           0 : no compression
00279 //                           1 : default ROOT compression
00280 //                        ...9 : maximum compression
00281 //
00282 //  Return:   number of stream configs modified
00283 //
00284 //  Contact:  R. Hatcher
00285 //
00286 
00287    int nmod = 0;
00288 
00289    int ibeg = Per::kDaqSnarl;
00290    int iend = Per::kBeamMon;
00291    for (int i = ibeg; i<=iend; i++ ) {
00292       Per::EStreamType stype = (Per::EStreamType) i;
00293       string treeName = Per::AsString(stype);
00294       if (treeName == stream || stream == "*") {
00295          logInfo("Compression level is %d for %s stream",
00296                  level,treeName.c_str());
00297          fCompressionMap[stype]  = level;
00298          nmod++;
00299       }
00300    }
00301 
00302    return nmod;
00303 }

static void RotoServer::SetDebugFlags ( UInt_t  dbgflgs  )  [inline, static]

Definition at line 48 of file RotoServer.h.

References fgDebugFlags.

00048 { fgDebugFlags = dbgflgs; }

Int_t RotoServer::SetFlatBinaryOutputFile ( const string &  filename  ) 

Definition at line 338 of file RotoServer.cxx.

References fFlatBinaryName, fFlatBinaryOutputFile, and logNotice().

Referenced by main(), and ~RotoServer().

00339 {
00340 //
00341 //  Purpose:  Set name of flat binary output file
00342 //            Open file if necessary
00343 //
00344 //  Argument: filename   - name of file
00345 //
00346 //  Return:   success
00347 //
00348 //  Contact:  R. Hatcher
00349 //
00350 
00351    // if the filename is unchanged do nothing
00352    if (filename == fFlatBinaryName) return 1;
00353 
00354    if (fFlatBinaryOutputFile) {
00355      // close currently open file
00356      logNotice("close flat binary output file: %s",fFlatBinaryName.c_str());
00357      fclose(fFlatBinaryOutputFile);
00358      fFlatBinaryOutputFile = 0;
00359      fFlatBinaryName = "";
00360    }
00361 
00362    if (filename != "") {
00363      // open the requested file
00364      logNotice("open flat binary output file: %s",filename.c_str());
00365      fFlatBinaryOutputFile = fopen(filename.c_str(),"wb");
00366      fFlatBinaryName = filename;
00367    }
00368 
00369    return 1;
00370 }

Int_t RotoServer::SetSymlink ( const char *  symlink_name = 0  ) 

Definition at line 373 of file RotoServer.cxx.

References fSymlink.

Referenced by main().

00374 {
00375     fSymlink = "";
00376     if (symlink_name) fSymlink = symlink_name;
00377     return 1;
00378 }

Int_t RotoServer::WriteRawRecord ( const RawRecord rawrec  )  [private]

Definition at line 1579 of file RotoServer.cxx.

References BogusFileName(), ChooseStreamName(), err(), fname, fOutputStreamManager, PerStreamManager::GetOpenedStream(), kBogusFile, kFailWriteRec, kSuccess, logError(), OpenFile(), PerOutputStream::SetObject(), and PerOutputStream::Store().

Referenced by ProcessBuffer().

01580 {
01581 //
01582 //  Purpose:  Write the inflated RawRecord
01583 //            Build it into objects, write it out
01584 //
01585 //  Argument: (none)
01586 //
01587 //  Return:   if 0 then conversion and write were successful
01588 //
01589 //  Contact:  R. Hatcher
01590 //   
01591 
01592    Int_t status = kSuccess;
01593 
01594    string rotoStrmName = ChooseStreamName(rawrec);
01595 
01596    if (!fOutputStreamManager) {
01597       logError("process buffer had no output stream manager");
01598       status |= kFailWriteRec;
01599       return status;
01600    }
01601 
01602    PerOutputStream* stream = 0;
01603    stream = dynamic_cast<PerOutputStream*>
01604       (fOutputStreamManager->GetOpenedStream(rotoStrmName));
01605 
01606    if (!stream) {
01607       // no open stream with the right name ...
01608       // openfile wasn't called ?? or perhaps the data is
01609       // corrupted.  we want to protect this data so
01610       // put it in a file of bogus data
01611       logError("process buffer had no stream '%s'",
01612                rotoStrmName.c_str());
01613       string streamType = // last part of rotoStrmName after final .
01614          rotoStrmName.substr(rotoStrmName.find_last_of(".")+1,string::npos); 
01615       rotoStrmName =  "bogus." + streamType;
01616       stream = dynamic_cast<PerOutputStream*>
01617          (fOutputStreamManager->GetOpenedStream(rotoStrmName));
01618       if (!stream) {
01619          // perhaps the bogus file isn't open ...
01620          EFileType ftype = kBogusFile;
01621          string fname = BogusFileName();
01622          Int_t err = OpenFile(fname.c_str(),ftype);
01623          if (err) {
01624             logError("process buffer could not open 'bogus' file '%s'",
01625                      fname.c_str());
01626          }
01627          // last try at getting the stream
01628          stream = dynamic_cast<PerOutputStream*>
01629             (fOutputStreamManager->GetOpenedStream(rotoStrmName));
01630          
01631       }
01632    }
01633    
01634    if (stream) {
01635 //         MSG("Roto", Msg::kVerbose) 
01636 //            << "RotoServer::ProcessBuffer put on stream " 
01637 //            << strmName << endl;
01638          // remove const for PerOutputStream::SetObject
01639       RawRecord *rawrec_nonconst =
01640          const_cast<RawRecord *>(rawrec);
01641       stream->SetObject(rawrec_nonconst);
01642       stream->Store();
01643    } 
01644    else {
01645       logError("process buffer still had no stream '%s'",
01646                rotoStrmName.c_str());
01647       //MSG("Roto", Msg::kWarning) 
01648       //   << "RotoServer::ProcessBuffer no stream " << rotoStrmName;
01649       status |= kFailWriteRec;
01650    }
01651 
01652    return status;
01653 }


Member Data Documentation

Definition at line 113 of file RotoServer.h.

Referenced by Init(), and OpenFile().

std::map<Per::EStreamType,UInt_t> RotoServer::fAutoSaveIntMap [private]

Definition at line 120 of file RotoServer.h.

Referenced by OpenFile(), and SetAutoSaveConfig().

std::map<Per::EStreamType,UInt_t> RotoServer::fAutoSaveTimeMap [private]

Definition at line 121 of file RotoServer.h.

Referenced by OpenFile(), and SetAutoSaveConfig().

std::map<Per::EStreamType,UInt_t> RotoServer::fBasketSizeMap [private]

Definition at line 123 of file RotoServer.h.

Referenced by OpenFile(), and SetBasketSizeConfig().

std::map<Per::EStreamType,Int_t> RotoServer::fCompressionMap [private]

Definition at line 122 of file RotoServer.h.

Referenced by OpenFile(), and SetCompressConfig().

Definition at line 103 of file RotoServer.h.

Referenced by BuildStateReport(), Init(), ProcessCommand(), ReplyToCommand(), Run(), and ~RotoServer().

string RotoServer::fFakeDAQFileName [private]

Definition at line 115 of file RotoServer.h.

Referenced by ChooseStreamName(), CloseFile(), Init(), and OpenFile().

string RotoServer::fFlatBinaryName [private]

Definition at line 117 of file RotoServer.h.

Referenced by SetFlatBinaryOutputFile().

Definition at line 118 of file RotoServer.h.

Referenced by ProcessBuffer(), and SetFlatBinaryOutputFile().

UInt_t RotoServer::fgDebugFlags = 0 [static, private]

Definition at line 127 of file RotoServer.h.

Referenced by GetDebugFlags(), Run(), and SetDebugFlags().

string RotoServer::fNackMessage [private]

Definition at line 114 of file RotoServer.h.

Referenced by CloseFile(), Init(), OpenFile(), Run(), WriteRawRecord(), and ~RotoServer().

Int_t RotoServer::fPort [private]

Definition at line 97 of file RotoServer.h.

Referenced by BogusFileName().

TArrayC RotoServer::fRecvBuffer [private]

Definition at line 105 of file RotoServer.h.

Referenced by CloseFile(), Init(), OpenFile(), ProcessBuffer(), ProcessConfig(), and RecvCommand().

Int_t RotoServer::fRecvBufferUsed [private]

Definition at line 106 of file RotoServer.h.

Referenced by CloseFile(), OpenFile(), ProcessBuffer(), and RecvCommand().

TArrayC RotoServer::fReplyBuffer [private]

Definition at line 108 of file RotoServer.h.

Referenced by Init(), and ReplyToCommand().

TServerSocket* RotoServer::fServerSocket [private]

Definition at line 100 of file RotoServer.h.

Referenced by Init(), RotoServer(), Run(), and ~RotoServer().

TSocket* RotoServer::fSocket [private]

Definition at line 101 of file RotoServer.h.

Referenced by Init(), OpenFile(), RotoServer(), Run(), and ~RotoServer().

Definition at line 125 of file RotoServer.h.

Referenced by BogusFileName().

string RotoServer::fStateReport [private]

Definition at line 111 of file RotoServer.h.

Referenced by BuildStateReport(), Init(), and ReplyToCommand().

string RotoServer::fSymlink [private]

Definition at line 129 of file RotoServer.h.

Referenced by OpenFile(), and SetSymlink().

Definition at line 98 of file RotoServer.h.

Referenced by RotoServer(), and Run().


The documentation for this class was generated from the following files:

Generated on 13 Sep 2017 for loon by  doxygen 1.6.1