DbuDaqFileModule.cxx

Go to the documentation of this file.

// $Id: DbuDaqFileModule.cxx,v 1.12 2007/01/30 17:00:04 rhatcher Exp $
#include "DatabaseUpdater/DbuDaqFileModule.h"
#include "DatabaseUpdater/DbuSignalHandler.h"

#include "OnlineUtil/mdBlockDefinitions.h"

#include "DatabaseUpdater/DbuRunSummary.h"
#include "DatabaseUpdater/DbuDaqFileSummary.h"
#include "DatabaseUpdater/DbuDaqConfigFilesText.h"

#include "DatabaseUpdater/DbuBits.h"
#include "DatabaseUpdater/RunTypeName.h"

#include <cstdio>
#include <cassert>

// ROOT include files
#include "TObject.h"
#include "TCollection.h"
#include "TIterator.h"
#include "TObjectTable.h"
// TString for Form function
#include "TString.h"  
#include "TSystem.h"
#include "TFile.h"
#include "TMath.h"
#include "TROOT.h"

// MINOS include files
#include "DatabaseInterface/Dbi.h"
#include "DatabaseInterface/DbiCascader.h"
#include "DatabaseInterface/DbiTableProxy.h"
#include "DatabaseInterface/DbiTableProxyRegistry.h"
#include "DatabaseInterface/DbiOutRowStream.h"
#include "DatabaseInterface/DbiWriter.h"
#include "DatabaseInterface/DbiCache.h"
#include "DatabaseInterface/DbiResultPtr.h"
#include "DatabaseInterface/DbiString.h"
#include "DatabaseInterface/DbiStatement.h"

#include "RawData/RawRecord.h"
#include "RawData/RawDaqSnarlHeader.h"

#include "RawData/RawLIAdcSummaryBlock.h"
#include "RawData/RawLITimingSummaryBlock.h"

#include "RawData/RawRunStartBlock.h"
#include "RawData/RawRunCommentBlock.h"
#include "RawData/RawRunEndBlock.h"
#include "RawData/RawSubRunEndBlock.h"
#include "RawData/RawRunConfigBlock.h"
#include "RawData/RawConfigFilesBlock.h"
#include "RawData/RawDigitDataBlock.h"

#include "JobControl/JobCommand.h"
#include "JobControl/JobCModuleRegistry.h"
#include "MinosObjectMap/MomNavigator.h"
#include "MessageService/MsgService.h"
#include "Util/UtilString.h"

#include <signal.h>
#include "OnlineUtil/msgLogLib/msgLog.h"

#include <fstream>

CVSID("$Id: DbuDaqFileModule.cxx,v 1.12 2007/01/30 17:00:04 rhatcher Exp $");
JOBMODULE(DbuDaqFileModule, 
          "DbuDaqFileModule", "Generate RunSummary entries in database.");

const Int_t        gkFakeRun          = -1;
const Int_t        gkFakeSubRun       = -1;
const VldContext   gkFakeVldContext   = VldContext();
const std::string  gkFakeFile         = "";

const VldTimeStamp nullTime = VldTimeStamp((time_t)0,0);

//......................................................................

const Int_t sec_fivemin = 5*60;

//......................................................................

//
// Helper functions
//
inline void updateMinTimeStamp(VldTimeStamp& ts, const VldTimeStamp& ts_new)
{
  // update "ts" to the min of it's current value or the new value
  // (set it to the new value if it is the nullTime)
  if ( nullTime == ts_new ) return; // bad data
  if ( nullTime == ts || ts_new < ts ) ts = ts_new;
}
inline void updateMaxTimeStamp(VldTimeStamp& ts, const VldTimeStamp& ts_new)
{
  // update "ts" to the max of it's current value or the new value
  // (set it to the new value if it is the nullTime)
  if ( nullTime == ts_new ) return; // bad data
  if ( nullTime == ts || ts_new > ts ) ts = ts_new;
}
inline void updateMinInt(Int_t& minInt, const Int_t curInt)
{
  if ( curInt < 0 ) return;  // bad data
  if ( minInt < 0 || curInt < minInt ) minInt = curInt;
}
inline void updateMaxInt(Int_t& maxInt, const Int_t curInt)
{
  if ( curInt < 0 ) return;  // bad data
  if ( maxInt < 0 || curInt > maxInt ) maxInt = curInt;
}

const char* oracleTimeStamp(VldTimeStamp& ts)
{
  // return a string of the form "14-Oct-2004 00:14:10" (implied UTC)
  // use internal circular list of buffers to avoid problems
  // when multiple calls in a single iostream statment

  struct tm *ptm;
  time_t seconds = (time_t) ts.GetSec();
  ptm = gmtime(&seconds);  // returns ptr to static data
  const char *oracleFmt = "%d-%b-%Y %H:%M:%S";

  const  int nbuffers = 8;
  static int ibuffer  = nbuffers;
  ibuffer = (ibuffer+1)%nbuffers;  // each call move to next buffer
  static char timeString[nbuffers][64];
  strftime(timeString[ibuffer],sizeof(timeString[ibuffer]),oracleFmt,ptm);
  return timeString[ibuffer];
}

//......................................................................

DbuDaqFileModule::DbuDaqFileModule() :
   fURL(""), fDbNo(0), fDbiStatement(0),
   fHeartbeatIntervalSec(sec_fivemin),
   fCurrentRunSummary(0), fCurrentDaqFileSummary(0), 
   fCurrentConfigFilesText(0),
   fCurrentRun(gkFakeRun),               fNextRun(gkFakeRun), 
   fCurrentSubRun(gkFakeSubRun),         fNextSubRun(gkFakeSubRun),
   fCurrentVldContext(gkFakeVldContext), fNextVldContext(gkFakeVldContext),
   fCurrentFile(gkFakeFile),             fNextFile(gkFakeFile)
{}

//......................................................................

DbuDaqFileModule::~DbuDaqFileModule() {}

//......................................................................
  
JobCResult DbuDaqFileModule::Ana(const MomNavigator* mom)
{
   // process the record set

   MSG("Dbu",Msg::kVerbose) << " DbuDaqFileModule::Ana() " << endl;

   ExtractRunAndFile(mom);  // fake up Begin/End Run/File
   DoBeginEndRunAndFile();

   fCurrentDaqFileSummary->fRecSets++;  // new record set

   JobCResult result = JobCResult::kPassed;
   
   // Get any and all raw records attached to the data record pointed 
   // to by "mom".  The dynamic cast from TObject is ugly but necessary
   TObject   *tobj   = 0;
   bool incNonLIRec = false;
   TIter reciter = const_cast<MomNavigator*>(mom)->FragmentIter();
   while ( (tobj = reciter() ) ) {
      RawRecord *rawrec = dynamic_cast<RawRecord *>(tobj);
      JobCResult aresult = ProcessRawRecord(rawrec);
      if (aresult.Failed()) result = aresult;
      const std::string strmname = 
          rawrec->GetTempTags().GetCharString("stream");
      if ( strmname == "DaqMonitor" || strmname == "DaqSnarl" )
          incNonLIRec = true;
   }

   if ( incNonLIRec ) fCurrentDaqFileSummary->fRecSetsNotLIOnly++;

   return result;
}

//......................................................................

void DbuDaqFileModule::BeginJob()
{
   // make the DbiStatement connection

   MSG("Dbu",Msg::kDebug) << "DbuDaqFileModule::BeginJob() start" << endl;

   Update_ENV_TSQL();

   fDbiStatement = 
     DbiTableProxyRegistry::Instance().GetCascader().CreateStatement(fDbNo);

   MSG("Dbu",Msg::kDebug) << "DbuDaqFileModule::BeginJob() end" << endl;

}

//......................................................................

void DbuDaqFileModule::EndJob()
{
   // this should make sure all entries are flushed

  fNextRun        = gkFakeRun;
  fNextSubRun     = gkFakeSubRun;
  fNextVldContext = gkFakeVldContext;
  fNextFile       = gkFakeFile;
  DoBeginEndRunAndFile();

  MSG("Dbu",Msg::kInfo)
    << "DbuDaqFileModule::EndJob() " << endl;

  //logInfo("DbuDaqFileModule::EndJob() processing begun");

  MSG("Dbu",Msg::kInfo) << "Delete DbiStatement" << endl;
  delete fDbiStatement;  // delete statement to release connection
  fDbiStatement = 0;

  logInfo("DbuDaqFileModule::EndJob() finished");
}

//......................................................................

void DbuDaqFileModule::ExtractRunAndFile(const MomNavigator* mom)
{
   // Pull out the run # and file name
   // Assume that any given record set comes from one-and-only-one
   // Run and File (true for normal Daq files)
   
   RawRecord *rawrec = dynamic_cast<RawRecord*>(mom->GetFragment("RawRecord"));
   if ( !rawrec ) {
     logWarn("ExtractRunAndFile() MomNavigator has no RawRecord");
     return;
   }

   const RawDaqHeader* daqHdr = 
     dynamic_cast<const RawDaqHeader*>(rawrec->GetRawHeader());
   if ( !daqHdr ) {
     logWarn("ExtractRunAndFile() RawRecord had no RawDaqHeader");
     return;
   }

   fNextVldContext   = daqHdr->GetVldContext();
   fNextRun          = daqHdr->GetRun();
   fNextSubRun       = daqHdr->GetSubRun();
   fNextRunType      = daqHdr->GetRunType();
   fNextTimeFrameNum = daqHdr->GetTimeFrameNum();

   const Registry& registry = rawrec->GetTempTags();
   const char* tmpfile = 0;
   registry.Get("file",tmpfile);
   // we only want the basename
   const char* basename = gSystem->BaseName(tmpfile);
   fNextFile   = basename;

   //logDebug(1,"Extract Run %d SubRun %d File %s",
   //         fNextRun,fNextSubRun,fNextFile.c_str());

}

//......................................................................

void DbuDaqFileModule::DoBeginEndRunAndFile()
{
   // Call the appropriate sequence of Begin/End Run/File
   // To work in the fashion that's most appropriate
   // we need to BeginRun before BeginFile and EndFile before EndRun.
   // And of course, end either before the next begin.

   bool newDetector  = ( fNextVldContext.GetDetector() != 
                         fCurrentVldContext.GetDetector() );
   bool newSimFlag   = ( fNextVldContext.GetSimFlag()  !=
                         fCurrentVldContext.GetSimFlag()  );
   bool newContext   = ( newDetector || newSimFlag );
   bool newFile      = ( fNextFile   != fCurrentFile   || newContext );
   bool newRun       = ( fNextRun    != fCurrentRun    || newContext );
   bool newSubRun    = ( fNextSubRun != fCurrentSubRun || newRun || newContext );
   bool newSomething = ( newFile || newRun || newSubRun );

   if (newSomething) {
     logDebug(1,"Current '%s' %d %d, Next '%s' %d %d new %c %c",
              fCurrentFile.c_str(),fCurrentRun,fCurrentSubRun,
              fNextFile.c_str(),fNextRun,fNextSubRun,
              (newFile?'T':'F'),(newRun?'T':'F'),(newSubRun?'T':'F'));
     MSG("Dbu",Msg::kDebug) 
         << "DoBeginEndRunAndFile status: " 
         << (newDetector?"new":"old") << "Detector, "
         << (newSimFlag ?"new":"old") << "SimFlag, "
         << (newFile    ?"new":"old") << "File, "
         << (newRun     ?"new":"old") << "Run, "
         << (newSubRun  ?"new":"old") << "SubRun "
         << endl;
     if (newFile) MSG("Dbu",Msg::kDebug) << "new file: " << fNextFile << endl;
     if (newRun)  MSG("Dbu",Msg::kDebug) << "new run:  " << fNextRun  << endl;

   }
   
   //MSG("Dbu",Msg::kVerbose) 
   //<< "DoBeginEndRunAndFile status: " 
   //<< (newDetector?"new":"old") << "Detector, "
   //<< (newSimFlag ?"new":"old") << "SimFlag, "
   //<< (newFile    ?"new":"old") << "File, "
   //<< (newRun     ?"new":"old") << "Run, "
   //<< (newSubRun  ?"new":"old") << "SubRun "
   //<< endl;

   if ( newFile   && fCurrentFile != gkFakeFile ) MyOwn_EndFile();
   if ( newRun    && fCurrentRun  != gkFakeRun  ) MyOwn_EndRun();
  
   if ( newRun    ) fCurrentRun    = fNextRun;
   if ( newSubRun ) fCurrentSubRun = fNextSubRun;
   if ( newFile   ) fCurrentFile   = fNextFile;
   fCurrentVldContext   = fNextVldContext;  // always moves on
   fCurrentRunType      = fNextRunType;
   fCurrentTimeFrameNum = fNextTimeFrameNum;

   if ( newRun    && fCurrentRun  != gkFakeRun  ) MyOwn_BeginRun();
   if ( newFile   && fCurrentFile != gkFakeFile ) MyOwn_BeginFile();

}

//......................................................................

void DbuDaqFileModule::BuildExtContextAndSelect()
{

   // construct an extended context
   VldTimeStamp tsStart(1995, 1, 1, 0, 0, 0); // earliest time for MINOS
   VldTimeStamp   tsEnd(2038, 1, 8,19,14,07); // the end of time
   Detector::Detector_t det     = fCurrentVldContext.GetDetector();
   SimFlag::SimFlag_t   simflag = fCurrentVldContext.GetSimFlag();
   fExtDbiSqlContext = DbiSqlContext(DbiSqlContext::kStarts,
                                     tsStart,tsEnd,det,simflag);
   
   Int_t seqNoMin = DbuDaqFileSummary::CalcUniqueSeqNo
     (det,fCurrentRun,DbuDaqFileSummary::kMinSubRun);
   Int_t seqNoMax = DbuDaqFileSummary::CalcUniqueSeqNo
     (det,fCurrentRun,DbuDaqFileSummary::kMaxSubRun);

   fWhereSelect = Form("SEQNO >= %d AND SEQNO <= %d",seqNoMin,seqNoMax);

   //MSG("Dbu",Msg::kDebug) << "WHERE " << fWhereSelect << endl;
}

//......................................................................

void DbuDaqFileModule::CommitDbuRunSummary()
{

   // Commit DbuRunSummary

  bool success = false;
  
  if ( fCurrentRunSummary ) {

    DbuRunSummary* drs = fCurrentRunSummary; // just a shorthand

    // patch up start/end times with sub run info
    DbiResultPtr<DbuDaqFileSummary>
      rsFile("DBUDAQFILESUMMARY",fExtDbiSqlContext,
             Dbi::kAnyTask,fWhereSelect.c_str());
    
    UInt_t nFile = rsFile.GetNumRows();
    for (UInt_t k=0; k < nFile; ++k) {
      const DbuDaqFileSummary* fs = rsFile.GetRow(k);
      if ( fs->fSubRun > drs->fLastSubRun ) drs->fLastSubRun = fs->fSubRun;
      updateMinTimeStamp(drs->fStartTime,fs->fFirstMonitorTime);
      updateMaxTimeStamp(drs->fEndTime,  fs->fLastMonitorTime);
      updateMinTimeStamp(drs->fStartTime,fs->fFirstSnarlTime);
      updateMaxTimeStamp(drs->fEndTime,  fs->fLastSnarlTime);
    }

    std::string cft_md5   = DbuDaqConfigFilesText::kNoMD5;
    int         cft_seqno = 0;

    // first commit the config text (if necessary)
    CommitDbuDaqConfigFilesText(cft_md5,cft_seqno);

    Int_t fmt = DbuRunSummary::GetFmtFlag();
    DbuRunSummary::SetFmtFlag(0);
    MSG("Dbu",Msg::kSynopsis)
      << "CommitDbuRunSummary(): " << *fCurrentRunSummary << endl;
    DbuRunSummary::SetFmtFlag(fmt);

    success = fCurrentRunSummary->Commit(fDbiStatement,cft_md5,cft_seqno);
  }

  if ( success ) {
    delete fCurrentRunSummary;
    fCurrentRunSummary = 0;
  }
}

//......................................................................

void DbuDaqFileModule::CommitDbuDaqFileSummary()
{

   // Commit DbuDaqFileSummary
  
  bool success = false;
  
  if ( fCurrentDaqFileSummary ) {

    MSG("Dbu",Msg::kSynopsis)
      << "CommitDbuDaqFileSummary(): " << *fCurrentDaqFileSummary << endl;

    success = fCurrentDaqFileSummary->Commit(fDbiStatement);
    // wrote it to the DB (maybe) generate SAM python script
    WritePythonFile(success);
  }
  
  if ( success ) {
    delete fCurrentDaqFileSummary;
    fCurrentDaqFileSummary = 0;
  }
}

//......................................................................
                                        
void DbuDaqFileModule::CommitDbuDaqConfigFilesText(std::string& cft_md5, 
                                                   int& cft_seqno)
{

   // Commit DbuDaqConfigFilesText

  bool success = false;

  if ( fCurrentConfigFilesText ) {
    // force the MD5 to be (re)calculated
    cft_md5   = fCurrentConfigFilesText->CalcMD5();
    // look to see if this already exists
    cft_seqno = fCurrentConfigFilesText->LookupSeqNo(fDbiStatement);
    MSG("Dbu",Msg::kDebug) << " first SEQNO lookup: " << cft_seqno << endl;
    if ( 0 == cft_seqno ) {
      // we need to write it, and get the newly added seqno

      MSG("Dbu",Msg::kSynopsis)
        << "CommitDbuDaqConfigFilesText(): " << *fCurrentConfigFilesText << endl;

      VldTimeStamp bot(time_t(0),0);
      VldTimeStamp eot(time_t(0x7fffffff),0);
      VldRange range(0xFF,0xFF,bot,eot,"all time and space");
      Int_t aggNo = -1;
      Dbi::Task task = 0;
      VldTimeStamp create;
      std::string dbName = GetConfig().GetCharString("dbName"); // "offline";
      DbiWriter<DbuDaqConfigFilesText> writer(range,aggNo,task,create,dbName);
      writer << *fCurrentConfigFilesText;
      writer.Close();
      cft_seqno = fCurrentConfigFilesText->LookupSeqNo(fDbiStatement);
      MSG("Dbu",Msg::kDebug) << " second SEQNO lookup: " << cft_seqno << endl;
    }
  }
  
  if ( success ) {
   delete fCurrentConfigFilesText;
   fCurrentConfigFilesText = 0;
  }
}

//......................................................................

void DbuDaqFileModule::WritePythonFile(bool dbWriteSuccess)
{
  // write the python file for the current DbuDaqFileSummary
  Registry& r = GetConfig();
  Int_t control      = r.GetInt("GenSAMPythonFile");
  if ( control == 0 || ( control == 2 && !dbWriteSuccess ) ) return;

  DbuRunSummary& drs = *fCurrentRunSummary;          // an alias
  DbuDaqFileSummary& dfs = *fCurrentDaqFileSummary;  // an alias
  string& refBaseName = dfs.fBaseName;

  string::size_type dotpos = refBaseName.find(".");

  const char* path = r.GetCharString("SAMPythonPath");  // unexpanded path
  const char* expandedPathName = 
    gSystem->ExpandPathName(path);  // take ownership of result
  string filename = expandedPathName;
  filename += "/";
  filename += refBaseName.substr(0,dotpos); // [inclusive,exclusive)
  filename += ".sam.py";
  delete [] expandedPathName;

  ofstream sam_py(filename.c_str());

  VldTimeStamp now;
  sam_py
    << "# File: " << refBaseName << endl
    << "# Path: " << dfs.fDirName << endl
    << "# Last mod: " << dfs.fModTime.AsString("sql") << endl
    << "# Processed At: " << now.AsString("sql") << endl
    << "# Processed On: " << dfs.fProcHost << endl
    << endl;

  sam_py 
    << "from SamFile.SamDataFile import SamDataFile" << endl
    << endl
    << "from SamFile.SamDataFile import ApplicationFamily" << endl
    << "from SamFile.SamDataFile import CRC" << endl
    << "from SamFile.SamDataFile import SamTime" << endl
    << "from SamFile.SamDataFile import RunDescriptorList" << endl
    << "from SamFile.SamDataFile import SamSize" << endl
    << endl
    << "import SAM" << endl
    << endl;

  int rvi = dfs.fRootVersion;
  int rvmajor = rvi/10000;
  int rvminor = rvi/100 - 100*rvmajor;
  int rvtiny  = rvi%100;
  string rootVersionString = Form("v%02d-%02d-%02d",rvmajor,rvminor,rvtiny);
  string detname = UtilString::ToLower(Detector::AsString(dfs.fDetector));

  VldTimeStamp startTime = dfs.fFirstMonitorTime;
  VldTimeStamp endTime   = dfs.fLastMonitorTime;
  // the above _should_ do in general ... but sometimes things are weird
  updateMinTimeStamp(startTime,dfs.fFirstSnarlTime);
  updateMaxTimeStamp(endTime,dfs.fLastSnarlTime);

  sam_py
    << "metadata = SamDataFile(" << endl
    << "   fileName='" << refBaseName << "'," << endl
    << "   fileType=SAM.DataFileType_ImportedDetector," << endl
    << "   fileContentStatus=SAM.DataFileContentStatus_Good," << endl
    << "   fileFormat=SAM.DataFileFormat_ROOT," << endl
    << "   fileSize=SamSize('" << dfs.fSize << "B')," << endl
    << "   crc=CRC(999L,SAM.CRC_Adler32Type), # to be computed later" << endl
    << "   group='minos'," << endl
    << "   applicationFamily=ApplicationFamily('online','rotorooter','" 
    <<                       rootVersionString << "')," << endl
    << "# last arg in ApplicationFamily is the ROOT version used in writing file" << endl
    << "   dataTier='raw-" << detname << "'," << endl
    << "   datastream='alldata'," << endl  // undifferentiated for raw DAQ data
    << "   runNumber=" << dfs.fRun << "," << endl
    << "   runType='" << RunTypeName(drs.fRunType,drs.fDetector,drs.fRun) << "'," << endl
    << "   startTime=SamTime('" << oracleTimeStamp(startTime)
    <<                       "(UTC)',SAM.SamTimeFormat_UTCFormat)," << endl
    << "   endTime=SamTime('" << oracleTimeStamp(endTime)
    <<                       "(UTC)',SAM.SamTimeFormat_UTCFormat)," << endl
    << "   eventCount=" << dfs.fRecSets << "," << endl  // # of record sets (what JobC reports)
    << "   firstEvent=" << dfs.fFirstSnarlNum << "," << endl
    << "   lastEvent=" << dfs.fLastSnarlNum  /* << "," */ << endl
    << ")"
    << endl;

}

//......................................................................

void DbuDaqFileModule::MyOwn_BeginRun()
{
   // Do whatever with fCurrentRun
   if ( fCurrentRun == gkFakeRun ) return; // never start a fake run
   logInfo("BeginRun %d",fCurrentRun);
   MSG("Dbu",Msg::kDebug) << " ########## MyOwn_BeginRun ########## " << fCurrentRun << endl;

   if ( fCurrentRunSummary ) {
     // should have been handled in EndRun
     DbuRunSummary* drs = fCurrentRunSummary; // just a shorthand
     logWarn("BeginRun still has a fCurrentRunSummary for %s run %d",
             Detector::AsString(drs->fDetector),drs->fRun);
     // well, just delete it...
     // ..if it's still there then probably the commit failed for
     // some reason (most likely write privs problem).
     delete fCurrentRunSummary;
     fCurrentRunSummary = 0;
   }

   // Check if we already have a DbuRunSummary entry in the DB for this run

   BuildExtContextAndSelect();

   DbiResultPtr<DbuRunSummary>
     rsPtrRun("DBURUNSUMMARY",fExtDbiSqlContext,
               Dbi::kAnyTask,fWhereSelect.c_str());
   
   MSG("Dbu",Msg::kDebug)
     << "DbiSqlContext: "
     << fExtDbiSqlContext.GetTimeStart() << " "
     << fExtDbiSqlContext.GetTimeEnd() << " "
     << " DetMask " << (int)fExtDbiSqlContext.GetDetector()
     << " SimMask " << (int)fExtDbiSqlContext.GetSimFlag()
     << endl
     << "fWhereSelect: " << fWhereSelect
     << endl;


   UInt_t nRunMatch = rsPtrRun.GetNumRows();
   if ( nRunMatch == 0 ) {
     fCurrentRunSummary = new DbuRunSummary;  // start afresh

     VldContext& vldc = fCurrentVldContext;   // just an alias
     VldTimeStamp ts  = vldc.GetTimeStamp();
     fCurrentRunSummary->fDetector  = vldc.GetDetector();
     fCurrentRunSummary->fSimFlag   = vldc.GetSimFlag();
     fCurrentRunSummary->fRun       = fCurrentRun;
     //rwh:fCurrentRunSummary->fStartTime = ts;
     //rwh:fCurrentRunSummary->fEndTime   = ts;
     fCurrentRunSummary->fRunType   = fCurrentRunType;

     fCurrentConfigFilesText = new DbuDaqConfigFilesText; // start afresh
   }
   else {
     const DbuRunSummary* dbuRunSum = rsPtrRun.GetRow(0);  // take first
     fCurrentRunSummary = new DbuRunSummary(*dbuRunSum);   // copy it

     const DbuDaqConfigFilesText* cft = dbuRunSum->fDbuDaqConfigFilesText;
     fCurrentConfigFilesText = new DbuDaqConfigFilesText(*cft); // copy it

     if ( nRunMatch > 1 ) {
       MSG("Dbu",Msg::kWarning) 
         << "BeginRun multiple DbuRunSummary entries for " 
         << fCurrentRun << endl;
       //assert(0);
     }
   }

  Int_t fmt = DbuRunSummary::GetFmtFlag();
  DbuRunSummary::SetFmtFlag(0);
   MSG("Dbu",Msg::kInfo)
     << "BeginRun Run " << fCurrentRun << " had " << nRunMatch 
     << " entries in DB"
     << endl << *fCurrentRunSummary << endl;
  DbuRunSummary::SetFmtFlag(fmt);
                          
}

//......................................................................

void DbuDaqFileModule::MyOwn_EndRun()
{
   // Do whatever with fCurrentRun
   if ( fCurrentRun == gkFakeRun ) return; // never end a fake run
   logInfo("EndRun %d",fCurrentRun);
   MSG("Dbu",Msg::kDebug) << " ########## MyOwn_EndRun ########## " << fCurrentRun << endl;

   CommitDbuRunSummary();
}

//......................................................................

void DbuDaqFileModule::MyOwn_BeginFile()
{
   // Do whatever with fCurrentFile
   if ( fCurrentFile == gkFakeFile ) return; // never start a fake file
   logInfo("BeginFile %s run %d sub %d",
           fCurrentFile.c_str(),fCurrentRun,fCurrentSubRun);
   MSG("Dbu",Msg::kDebug) << " ########## MyOwn_BeginFile ########## " << fCurrentFile << endl;

   if ( fCurrentDaqFileSummary ) {
     // should have been handled in EndFile
     DbuDaqFileSummary* ddfs = fCurrentDaqFileSummary; // just a shorthand
     logWarn("BeginFile still has a fCurrentDbuDaqFileSummary for %s run %d sub %d",
             Detector::AsString(ddfs->fDetector),ddfs->fRun,ddfs->fSubRun);
     // well, just delete it...
     // ..if it's still there then probably the commit failed for
     // some reason (most likely write privs problem).
     delete fCurrentDaqFileSummary;
     fCurrentDaqFileSummary = 0;
   }

   fCurrentDaqFileSummary = new DbuDaqFileSummary;

   VldContext& vldc = fCurrentVldContext; // just an alias
   VldTimeStamp ts  = vldc.GetTimeStamp();
   fCurrentDaqFileSummary->fDetector  = vldc.GetDetector();
   fCurrentDaqFileSummary->fSimFlag   = vldc.GetSimFlag();
   fCurrentDaqFileSummary->fRun       = fCurrentRun;
   fCurrentDaqFileSummary->fSubRun    = fCurrentSubRun;
   //rwh:fCurrentDaqFileSummary->fStartTime = ts;
   //rhw:fCurrentDaqFileSummary->fEndTime   = ts;

   // find the TFile for the new filename
   TSeqCollection* listOfFiles = gROOT->GetListOfFiles();
   TIter fileItr(listOfFiles);
   TFile* afile = 0;
   std::string currentBaseName = gSystem->BaseName(fCurrentFile.c_str());

   while ( ( afile = (TFile*)fileItr.Next() ) ) {
     std::string fname = afile->GetName();
     std::string fbasename = gSystem->BaseName(fname.c_str());

     if ( currentBaseName == fbasename ) {  // test without any path info
       // found the file, ask questions
       fCurrentDaqFileSummary->fBaseName       = gSystem->BaseName(fname.c_str());
       fCurrentDaqFileSummary->fDirName        = gSystem->DirName(fname.c_str());
       fCurrentDaqFileSummary->fSize           = afile->GetSize();
       fCurrentDaqFileSummary->fCompressLevel  = afile->GetCompressionLevel();
       fCurrentDaqFileSummary->fCompressFactor = afile->GetCompressionFactor();
       fCurrentDaqFileSummary->fRootVersion    = afile->GetVersion();

#if ROOT_VERSION_CODE >= ROOT_VERSION(4,1,4)
       FileStat_t fileStat;
       gSystem->GetPathInfo(fname.c_str(),fileStat);
       fCurrentDaqFileSummary->fModTime        = VldTimeStamp(fileStat.fMtime,0);
#else
       MSG("Dbu",Msg::kFatal)
         << "Sorry, this module will only work with "
         << "ROOT version v4.01.04 and beyond"
         << endl;
       assert(0);
#endif

       fCurrentDaqFileSummary->fProcHost       = gSystem->HostName();
       
     } // the file
   } // loop over all files ROOT has
   
}

//......................................................................

void DbuDaqFileModule::MyOwn_EndFile()
{
   // Do whatever with fCurrentFile
   if ( fCurrentFile == gkFakeFile ) return; // never end a fake file
   logInfo("EndFile %s run %d sub %d",
           fCurrentFile.c_str(),fCurrentRun,fCurrentSubRun);
   MSG("Dbu",Msg::kDebug) << " ########## MyOwn_EndFile ########## " << fCurrentFile << endl;

   if ( fCurrentRunSummary ) 
     fCurrentRunSummary->ResetConsistencyBits(DbuBits::kInProgress);
   CommitDbuDaqFileSummary();
}

//......................................................................

void DbuDaqFileModule::BeginRun()
{
   MSG("Dbu",Msg::kDebug) << " ########## Standard BeginRun ########## " 
                          << GetCurrentRun()
                          << endl;
}

void DbuDaqFileModule::EndRun()
{
   MSG("Dbu",Msg::kDebug) << " ########## Standard EndRun ########## " 
                          << GetCurrentRun()
                          << endl;
}

void DbuDaqFileModule::BeginFile()
{
   MSG("Dbu",Msg::kDebug) << " ########## Standard BeginFile ########## " 
                          << GetCurrentFile()
                          << endl;
}

void DbuDaqFileModule::EndFile()
{
   MSG("Dbu",Msg::kDebug) << " ########## Standard BeginFile ########## "
                          << GetCurrentFile()
                          << endl;
}

//......................................................................

const Registry& DbuDaqFileModule::DefaultConfig() const 
{
//======================================================================
// The default configuration for this module
//======================================================================
  static Registry r;
  
  std::string name = this->GetName();
  name += ".config.default";
  r.SetName(name.c_str());
  
  r.UnLockValues();

  // comma separated list of config files that don't go into
  // common (shared across runs) DbuDaqConfigFilesText table
  r.Set("AuxConfigFileList","liStartTimes.config"); 

  // frequency (VldTimeStamp in the data) for outputing a heartbeat indicator
  r.Set("HeartbeatIntervalSec",sec_fivemin);

  // database into which to write
  r.Set("dbName","offline");

  // generate a SAM python file?
  // 0=never, 1=always, 2=only if DB write successful
  r.Set("GenSAMPythonFile",2);
  // write the SAM python file where?
  // set NULL to skip SAM python file generation
  r.Set("SAMPythonPath","."); 

  r.LockValues();

  return r;
}

//......................................................................

void DbuDaqFileModule::Config(const Registry& r) 
{
//======================================================================
// Configure the module using the registry r
//======================================================================

   int tmpi;
   const char* tmps = 0;

   if (r.Get("AuxConfigFileList",tmps))    fAuxConfigFileList    = tmps;
   if (r.Get("HeartbeatIntervalSec",tmpi)) fHeartbeatIntervalSec = tmpi;

   const char* dbName     = r.GetCharString("dbName");
   Int_t genPython        = r.GetInt("GenSAMPythonFile");
   const char* pythonPath = r.GetCharString("SAMPythonPath");
   std::string pythonMsg;
   switch ( genPython ) {
   case 0:  pythonMsg = "No SAMPythonFile generation";   break;
   case 1:  pythonMsg = "Always generate SAMPythonFile"; break;
   case 2:  pythonMsg = "Generate SAMPythonFile if DB write okay"; break;
   default: pythonMsg = "<<huh?>>";
   }
   if ( genPython > 0 ) {
     pythonMsg += ", written in path='";
     pythonMsg += pythonPath;
     pythonMsg += "'";
   }

   MSG("Dbu",Msg::kInfo) 
      << "DbuDaqFileModule::Config  " << endl
      << " AuxConfigFileList: " << fAuxConfigFileList << endl
      << " HeartbeatInterval: " << fHeartbeatIntervalSec << " sec" << endl
      << " dbName: '" << dbName << "'" << endl
      << " " << pythonMsg 
      << endl;

   logInfo("DbuDaqFileModule::Config() heartbeat %d sec in %s",
           fHeartbeatIntervalSec, dbName);

}

//......................................................................

void DbuDaqFileModule::Update_ENV_TSQL()
{
//======================================================================
// copy ENV_TSQL_UPDATE_XXX to ENV_TSQL_XXX
//======================================================================

   const char* strUser = gSystem->Getenv("ENV_TSQL_UPDATE_USER");
   const char* strPswd = gSystem->Getenv("ENV_TSQL_UPDATE_PSWD");
   const char* strUrl  = gSystem->Getenv("ENV_TSQL_UPDATE_URL");

   if (strUser) gSystem->Setenv("ENV_TSQL_USER",strUser);
   if (strPswd) gSystem->Setenv("ENV_TSQL_PSWD",strPswd);
   if (strUrl)  gSystem->Setenv("ENV_TSQL_URL",strUrl);

   fURL  = "";
   fDbNo = 0;

   // find the "offline" DB from the URL (not the "temp" one)

   const char* strUrlUsed = gSystem->Getenv("ENV_TSQL_URL");
   string urlList = (strUrlUsed) ? strUrlUsed : "";
   while ( urlList != "") {
     UInt_t maxStringPos = urlList.size();
     string url = urlList;
     UInt_t nextStringPos = urlList.find(";");
     if ( nextStringPos < maxStringPos ) {
       url = urlList.substr(0,nextStringPos);
       urlList.erase(0,nextStringPos+1);
     }
     else urlList = "";
     
     maxStringPos = url.size();
     
     if (url.find(GetConfig().GetCharString("dbName")) < maxStringPos) {
       fURL = url;
       break;
     }
     
     // if not chosen dbName ("offline") move along to next possibility
     ++fDbNo;
   }
}

//......................................................................

JobCResult DbuDaqFileModule::ProcessRawRecord(const RawRecord* rawrec)
{

   JobCResult result = JobCResult::kPassed;

   // test if the RawRecord was from the DAQ
   const RawDaqHeader* header = 
      dynamic_cast<const RawDaqHeader*>(rawrec->GetRawHeader());
   if (!header) {
      MSG("Dbu",Msg::kError)
         << "RawRecord lacked RawDaqHeader:" 
         << *(rawrec->GetRawHeader())
         << endl;
      logWarn("RawRecord lacked RawDaqHeader");
      return JobCResult::kFailed;
   }

   const VldContext           vldc      = header->GetVldContext();
   const Detector::Detector_t det       = vldc.GetDetector();
   const Int_t                run       = header->GetRun();
   const Short_t              subrun    = header->GetSubRun();
   const Short_t              runtype   = header->GetRunType();
   const VldTimeStamp         ts        = vldc.GetTimeStamp(); // ts of current record

   // this section is some (optional) heartbeat/debugging output
   const std::string strmname = rawrec->GetTempTags().GetCharString("stream");
   const int         strmindx = rawrec->GetTempTags().GetInt("index");

   Int_t this_time = vldc.GetTimeStamp().GetSec();
   static Int_t last_heartbeat = 0;
   bool pulse = ( this_time - last_heartbeat > fHeartbeatIntervalSec );

   if ( pulse || fHeartbeatIntervalSec < 0 ) {
     // send out heart beat signal
     const char* fmttime = vldc.GetTimeStamp().AsString("c");
     MSG("Dbu",Msg::kDebug) 
       << "heartbeat: " 
       << fCurrentFile << " (" << strmname << " " << strmindx << ") "
       << endl << " " << *header << endl;

     logDebug(3,"heartbeat: %c%8.8d_%4.4d %s (%s %d)",
              Detector::AsString(det)[0],
              run,subrun,fmttime,strmname.c_str(),strmindx);

     last_heartbeat = this_time;
   }

   // Keep track of highest subrun seen for this run

   if ( fCurrentRunSummary->fLastSubRun < subrun )
     fCurrentRunSummary->fLastSubRun = subrun;

   // Verify that RunType isn't different

   if ( fCurrentRunSummary->fRunType != runtype ) {
     logWarn("RunType changed in RUN %d from %d to %d",run,
             fCurrentRunSummary->fRunType,runtype);
     fCurrentRunSummary->fRunType = runtype;
   }

   // Simple accounting of # of records in each stream

   Int_t tf = header->GetTimeFrameNum();
   updateMinInt(fCurrentDaqFileSummary->fFirstTimeFrame,tf);
   updateMaxInt(fCurrentDaqFileSummary->fLastTimeFrame,tf);

   if      ( strmname == "DaqSnarl"      ) {
     fCurrentDaqFileSummary->fSnarlRecs++;

     if (fCurrentDaqFileSummary->fSnarlRecs != strmindx+1)
       logWarn("fSnarlRec count %d != strmindx %d+1",
               fCurrentDaqFileSummary->fSnarlRecs,strmindx);

     VldTimeStamp& refFirstSnarlTime   = fCurrentDaqFileSummary->fFirstSnarlTime;
     VldTimeStamp& refLastSnarlTime    = fCurrentDaqFileSummary->fLastSnarlTime;
     updateMinTimeStamp(refFirstSnarlTime,ts);
     updateMaxTimeStamp(refLastSnarlTime,ts);

     const RawDaqSnarlHeader* snarlHeader = 
       dynamic_cast<const RawDaqSnarlHeader*>(header);

     Int_t snarl = snarlHeader->GetSnarl();
     updateMinInt(fCurrentDaqFileSummary->fFirstSnarlNum,snarl);
     updateMaxInt(fCurrentDaqFileSummary->fLastSnarlNum,snarl);

     fCurrentDaqFileSummary->fTrigBitsSeen |= snarlHeader->GetTrigSrc();

   }
   else {

     // non DaqSnarl records ...

     VldTimeStamp& refFirstMonitorTime = fCurrentDaqFileSummary->fFirstMonitorTime;
     VldTimeStamp& refLastMonitorTime  = fCurrentDaqFileSummary->fLastMonitorTime;
     updateMinTimeStamp(refFirstMonitorTime,ts);
     updateMaxTimeStamp(refLastMonitorTime,ts);

     if ( strmname == "DaqMonitor"    ) {
       fCurrentDaqFileSummary->fMonitorRecs++;
       
       if (fCurrentDaqFileSummary->fMonitorRecs != strmindx+1)
         logWarn("fMonitorRec count %d != strmindx %d+1",
                 fCurrentDaqFileSummary->fMonitorRecs,strmindx);
     }
     else if ( strmname == "LightInjection") {
       fCurrentDaqFileSummary->fLightInjRecs++;
       
       if (fCurrentDaqFileSummary->fLightInjRecs != strmindx+1)
         logWarn("fLightInjRec count %d != strmindx %d+1",
                 fCurrentDaqFileSummary->fLightInjRecs,strmindx);
     }
     else {
       MAXMSG("Dbu",Msg::kWarning,100) 
         << " Saw unhandled stream='" << strmname << "'" << endl;
     }
   }

   //

   // For each RawBlock in the RawRecord extract what we can
   // The dynamic cast from TObject is ugly but necessary
   TIter itr = rawrec->GetRawBlockIter();
   const RawDataBlock*       rdb           = 0;
   const RawRunEndBlock*     runendblk     = 0;
   const RawSubRunEndBlock*  subrunendblk  = 0;

   // The dynamic cast from TObject is ugly but necessary
   // Careful! the itr() advances the iterator as a side effect!
   while ((rdb = dynamic_cast<const RawDataBlock*>(itr()))) {

      string blkName = rdb->GetName();
      fCurrentDaqFileSummary->fBlockCount[blkName]++;

      // runstart/runend we retain outside the loop
      // so we can process them after others in the same record
      if (!runendblk)    runendblk    = 
                           dynamic_cast<const RawRunEndBlock*>(rdb);
      if (!subrunendblk) subrunendblk = 
                           dynamic_cast<const RawSubRunEndBlock*>(rdb);

      ProcessRawBlock(rdb, run, subrun, strmname, strmindx);

   }

   // if we saw a (sub)run end block process it here after
   // any other blocks in the record

   if ( subrunendblk ) {                 
     // this is a SubRunEnd block
     VldTimeStamp startTime = subrunendblk->GetStartTime();
     VldTimeStamp endTime   = subrunendblk->GetEndTime();
     
     // "start time" in SubRunEnd block is start of whole run
     // updateMinTimeStamp(fCurrentDaqFileSummary->fFirstMonitorTime,startTime);
     updateMaxTimeStamp(fCurrentDaqFileSummary->fLastMonitorTime,  endTime);
     
     MSG("Dbu",Msg::kDebug) << *subrunendblk << endl;
     const char* fmttime = subrunendblk->GetEndTime().AsString("c");
     logInfo("%-16s RUN %d SUB %d @ %s (%s %d)",
             "SubRunEndBlk",run,subrun,fmttime,strmname.c_str(),strmindx);
   } // SubRunEndBlock

   if (runendblk) {
      //RawDataBlock::SetForceHexDump(true);
      //cout << *runendblk << endl;
      //RawDataBlock::SetForceHexDump(false);

      MSG("Dbu",Msg::kDebug) << *runendblk << endl;
      const char* fmttime = runendblk->GetEndTime().AsString("c");
      logInfo("%-16s RUN %d SUB %d @ %s (%s %d)",
              "RunEndBlk",run,subrun,fmttime,strmname.c_str(),strmindx);

      fCurrentRunSummary->ResetConsistencyBits(DbuBits::kSawNoRunEnd);

      //Int_t runEndSnarls  = runendblk->GetNumberOfSnarls();
      //Int_t runEndMonitor = runendblk->GetNumberOfNonSnarls();
      //if (fCurrentRunSummary->fSnarlRec   != runEndSnarls ||
      //    fCurrentRunSummary->fMonitorRec != runEndMonitor   ) {
      //   // flag that what we saw doesn't match RunEnd
      //   fCurrentRunSummary->SetConsistencyBits(DbuBits::kRecCountUnverified);
      //   MSG("Dbu",Msg::kDebug) 
      //     << "Counted/Expected " 
      //     << fCurrentRunSummary->fSnarlRec << "/" << runEndSnarls
      //     << " SnarlRec, "
      //     << fCurrentRunSummary->fMonitorRec << "/" << runEndMonitor
      //     << " MonitorRec "
      //     << endl;
      //}
      //else
      //  fCurrentRunSummary->ResetConsistencyBits(DbuBits::kRecCountUnverified);

      // no matter what, pick the larger count
      // (not necessarily replace them with "official" counts)
      // any mismatch is probably due to Dispatcher not serving all streams
      //if (fCurrentRunSummary->fSnarlRec   < runEndSnarls )
      //    fCurrentRunSummary->fSnarlRec   = runEndSnarls;
      //if (fCurrentRunSummary->fMonitorRec < runEndMonitor )
      //    fCurrentRunSummary->fMonitorRec = runEndMonitor;
      
      VldTimeStamp startTime = runendblk->GetStartTime();
      VldTimeStamp endTime   = runendblk->GetEndTime();

      bool bogus_time = false;

      if (startTime == nullTime) bogus_time = true;
      if (endTime   == nullTime) bogus_time = true;

      updateMinTimeStamp(fCurrentRunSummary->fStartTime,startTime);
      updateMaxTimeStamp(fCurrentRunSummary->fEndTime,  endTime);


      // last subrun (e.g. file) doesn't have separate RawSubRunEndBlock
      // "start time" in RunEnd block is start of whole run not particular subrun
      // updateMinTimeStamp(fCurrentDaqFileSummary->fFirstMonitorTime,startTime);
      updateMaxTimeStamp(fCurrentDaqFileSummary->fLastMonitorTime,  endTime);

      
      if (bogus_time) {
        MSG("Dbu",Msg::kError) 
          << "RunEnd block for " << fCurrentRunSummary->fRun
          << " had either a bad start or end time " << endl
          << *runendblk << endl;
      } 
      
      fCurrentRunSummary->fTermCode        = runendblk->GetTerminationCode();
      fCurrentRunSummary->fRunEndSnarls    = runendblk->GetNumberOfSnarls();
      fCurrentRunSummary->fRunEndNonSnarls = runendblk->GetNumberOfNonSnarls();
      fCurrentRunSummary->fNErrs           = runendblk->GetNumberOfErrors();
      fCurrentRunSummary->fTimeFrames      = runendblk->GetTotalTimeFrames();
      fCurrentRunSummary->fDroppedFrames   = runendblk->GetDroppedTimeFrames();
      
      // one can NOT!! assume that RunEnd is the last record 
      // for this run/subrun (based on empirical evidence)
      //

   } // RunEndBlock

   return result;
}

//......................................................................

void DbuDaqFileModule::ProcessRawBlock(const RawDataBlock* rdb,
                                       const Int_t run, const Short_t subrun, 
                                       const std::string& strmname,
                                       const int strmindx)
{

  // Actions for individual block types
  // Only one possible type so if/elseif/... is appropriate
   
  if ( const RawDigitDataBlock* ddblk = 
       dynamic_cast<const RawDigitDataBlock*>(rdb) ) { 
    fCurrentDaqFileSummary->fTotalDigitBlocks++;
    fCurrentDaqFileSummary->fTotalDigits += ddblk->GetNumberOfDigits();
    Int_t errDigits = ddblk->GetNumOfErrorDigits();
    if (errDigits > 0) {
      fCurrentDaqFileSummary->fErrorDigitBlocks++;
      fCurrentDaqFileSummary->fErrorDigits += errDigits;
    }
    MSG("Dbu",Msg::kVerbose) << *ddblk << endl;
    

  }
  else if ( const RawLIAdcSummaryBlock* liadcblk = 
       dynamic_cast<const RawLIAdcSummaryBlock*>(rdb) ) { 
    fCurrentDaqFileSummary->fAdcLIBlocks++;
    MSG("Dbu",Msg::kVerbose) << *liadcblk << endl;

  }
  else if ( const RawLITimingSummaryBlock* litimingblk = 
            dynamic_cast<const RawLITimingSummaryBlock*>(rdb) ) {
    fCurrentDaqFileSummary->fTimingLIBlocks++;
    MSG("Dbu",Msg::kVerbose) << *litimingblk << endl;

  }
  else if ( const RawRunStartBlock* runstartblk = 
            dynamic_cast<const RawRunStartBlock*>(rdb) ) {
    // this is a RunStart block
    fCurrentRunSummary->ResetConsistencyBits(DbuBits::kSawNoRunStart);
    VldTimeStamp startTime = runstartblk->GetStartTime();
    
    MSG("Dbu",Msg::kDebug) << *runstartblk << endl;
    const char* fmttime = runstartblk->GetStartTime().AsString("c");
    logInfo("%-16s RUN %d SUB %d @ %s (%s %d)",
            "RunStartBlk",run,subrun,fmttime,strmname.c_str(),strmindx);
  }
  else if ( const RawRunCommentBlock* runcommentblk = 
            dynamic_cast<const RawRunCommentBlock*>(rdb) ) {
    // this is a RunComment block
    fCurrentRunSummary->ResetConsistencyBits(DbuBits::kSawNoRunComment);
    
    MSG("Dbu",Msg::kDebug) << *runcommentblk << endl;
    const char* fmttime = runcommentblk->GetTime().AsString("c");
    logInfo("%-16s RUN %d SUB %d @ %s (%s %d)",
            "RunCommentBlk",run,subrun,fmttime,strmname.c_str(),strmindx);

    string runCommentString = runcommentblk->GetRunComment();
    if ( fCurrentRunSummary->fRunComment.find(runCommentString) == string::npos ) {
      // current block's text not found in current value
      // clear value if never yet set, otherwise prepare to append
      if (DbuRunSummary::kNoComment == fCurrentRunSummary->fRunComment)
        fCurrentRunSummary->fRunComment = runCommentString;
      else {
        logWarn("%-16s RUN %d SUB %d @ %s (%s %d) already had RunComment",
                "RunCommentBlk",run,subrun,fmttime,strmname.c_str(),strmindx);
        fCurrentRunSummary->fRunComment += "\n";    
        fCurrentRunSummary->fRunComment += runCommentString;
      }
    }
      }
  else if ( const RawRunConfigBlock* runconfigblk = 
            dynamic_cast<const RawRunConfigBlock*>(rdb) ) {
    // this is a RunConfig block
    fCurrentRunSummary->ResetConsistencyBits(DbuBits::kSawNoRunConfig);

    MSG("Dbu",Msg::kDebug) << *runconfigblk << endl;
    const char* fmttime = runconfigblk->GetTime().AsString("c");
    logInfo("%-16s RUN %d SUB %d @ %s (%s %d)",
            "RunConfigBlk",run,subrun,fmttime,strmname.c_str(),strmindx);

    string runPrepareString = runconfigblk->GetRunConfig();
    if ( fCurrentRunSummary->fRunPrepare.find(runPrepareString) == string::npos ) {
      // current block's text not found in current value
      // clear value if never yet set, otherwise prepare to append
      if (DbuRunSummary::kNoRunPrepare == fCurrentRunSummary->fRunPrepare)
        fCurrentRunSummary->fRunPrepare = runPrepareString;
      else {
        logWarn("%-16s RUN %d SUB %d @ %s (%s %d) already had RunPrepare",
                "RunConfigBlk",run,subrun,fmttime,strmname.c_str(),strmindx);
        fCurrentRunSummary->fRunPrepare += "\n";    
        fCurrentRunSummary->fRunPrepare += runPrepareString;
      }
    }
    
  }
  else if ( const RawConfigFilesBlock* configfilesblk = 
            dynamic_cast<const RawConfigFilesBlock*>(rdb) ) {
    // this is a ConfigFiles block
    fCurrentRunSummary->ResetConsistencyBits(DbuBits::kSawNoConfigFiles);
    
    HandleConfigFilesBlock(configfilesblk);

    //MSG("Dbu",Msg::kDebug) << *configfilesblk << endl;
    MSG("Dbu",Msg::kDebug) << "RawConfigFilesBlock seen" << endl;
    const char* fmttime = configfilesblk->GetTime().AsString("c");
    logInfo("%-16s RUN %d SUB %d @ %s (%s %d)",
          "ConfigFilesBlk",run,subrun,fmttime,strmname.c_str(),strmindx);

  }
  
}

//......................................................................

void DbuDaqFileModule::HandleConfigFilesBlock(const RawConfigFilesBlock* configfilesblk)
{

  // config file text info gets shunted into a separate table than
  // the DbuDaqRunSummary to avoid repeating the long text files
  // that rarely change.  the exception to this are short term
  // config files (e.g. liStartTimes.config) which will change often
  // these we won't put into that table but associate directly with
  // the run itself.

  // one could imagine using OnlineUtil/configLib to parse
  // these concatenated config files ... but
  // (1) it *really* wants to read a file from disk
  //     in $DAQ_CONFIG_DIR, (~) getpwuid->pw_dir or /minos/config/
  // (2) it can't deal with nested section (ie. our <configFileText>)
  // (3) it can't deal with multiple sections <tag>,/tag> 
  //     of the same name. <global> is in several files, 
  //     configLib would simply stop at the first.
  // (4) ?recheck? calling it again on a second section of
  //     the same name clears out the previously parsed data
  // basically configLib + kvp are half-assed parsers
  // kvp by itself apparently can't deal with continuation lines
  // which is why one needs configLib
  
  // possible solution write file parts out to /tmp
  // with names like  /tmp/F000RRRRRRR/dcp.config
  // and change $DAQ_CONFIG_DIR (save/restore before/after write/read)
  
  // new files have a defined string identifying the file
  // but older files one has to guess based on (hopefully) unique
  // strings in each type of config file.
  std::string guess_type = configfilesblk->GuessFileType();

  MSG("Dbu",Msg::kDebug) 
      << "HandleConfigFilesBlock guess_type '" << guess_type << "' "
      << " fAuxConfigFileList '" << fAuxConfigFileList << "' "
      << " find at " << (int)fAuxConfigFileList.find(guess_type)
      << " npos is " << (int)string::npos
      << endl;

  if ( fAuxConfigFileList.find(guess_type) == string::npos ) {
     // a config file type not in the exception list

     // if still the dummy default, clear it
     if ( fCurrentConfigFilesText->fText == DbuDaqConfigFilesText::kNoText )
          fCurrentConfigFilesText->fText = "";

     // add the text if it isn't already there
     const Char_t* new_text = configfilesblk->GetConfigFile();
     if ( fCurrentConfigFilesText->fText.find(new_text) == string::npos ) {
          
          fCurrentConfigFilesText->fText += "\n//[configFileText fileType=\"";
          fCurrentConfigFilesText->fText += guess_type;
          fCurrentConfigFilesText->fText += "\"]\n";
          
          fCurrentConfigFilesText->fText += new_text;
    
          fCurrentConfigFilesText->fText += "\n//[/configFileText fileType=\"";
          fCurrentConfigFilesText->fText += guess_type;
          fCurrentConfigFilesText->fText += "\"]\n";

     };
  
  }
  else {
     // a config file type in the exception list
     // put it in the DbuDaqRunSummary table

     // if still the dummy default, clear it
     if ( fCurrentRunSummary->fAuxConfigText == DbuRunSummary::kNoAuxConfig )
          fCurrentRunSummary->fAuxConfigText = "";
     if ( fCurrentRunSummary->fAuxConfigText == DbuRunSummary::kUnfilled )
          fCurrentRunSummary->fAuxConfigText = "";

     // add the text if it isn't already there
     const Char_t* new_text = configfilesblk->GetConfigFile();
     if ( fCurrentRunSummary->fAuxConfigText.find(new_text) == string::npos ) {
          
          fCurrentRunSummary->fAuxConfigText += "\n//[configFileText fileType=\"";
          fCurrentRunSummary->fAuxConfigText += guess_type;
          fCurrentRunSummary->fAuxConfigText += "\"]\n";
          
          fCurrentRunSummary->fAuxConfigText += new_text;
    
          fCurrentRunSummary->fAuxConfigText += "\n//[/configFileText fileType=\"";
          fCurrentRunSummary->fAuxConfigText += guess_type;
          fCurrentRunSummary->fAuxConfigText += "\"]\n";

     };
  }

}

//......................................................................

void DbuDaqFileModule::Help()
{
  const char* n = this->GetName();

  MSG("Dbu",Msg::kInfo)
     << "Help for module " << n << endl
     << endl
     << "  A Dbu for generating RunSummary, SubRun and ConfigFilesText entries" << endl
     << endl
     << "  /" << n << "/Record [which] ..." << endl
     << "  /" << n << "/Disregard [which] ..." << endl
     << "     controls which information to DBU" << endl
     << "     [which] is: " << endl
     << "        AtStart       - record upon seeing RunStart as well as RunEnd" << endl
     << endl;
  
}

---