In This Package:

JobInfoWriterAlg.cc

Go to the documentation of this file.

#include "JobInfoWriterAlg.h"

#include "Event/JobHeader.h"
#include "Event/JobInfo.h"
#include "DybKernel/IDybStorageSvc.h"
#include "DataSvc/IJobInfoSvc.h"
#include "RootIOSvc/RootIOIncident.h"

#include "GaudiKernel/IIncidentSvc.h"
#include "GaudiKernel/RegistryEntry.h"

JobInfoWriterAlg::JobInfoWriterAlg(const std::string& name, 
                                   ISvcLocator* pSvcLocator)
  : GaudiAlgorithm(name,pSvcLocator),
    m_storageSvc(0),
    m_jobInfoSvc(0)
{
  declareProperty("JobInfoLocation",
                  m_jobInfoLocation=DayaBay::JobHeaderLocation::Default,
                  "Location in file where job info is to be found.");
  declareProperty("WriteToFile",m_writeToFile=false,
                  "Write the job info to the current output file?");
  declareProperty("WriteToDatabase",m_writeToDatabase=false,
                  "Write the job info to the offline database?");
}

JobInfoWriterAlg::~JobInfoWriterAlg()
{
}

StatusCode JobInfoWriterAlg::initialize()
{
  // Initialize the necessary services
  if( m_writeToFile ){
    StatusCode sc = this->service("DybStorageSvc",m_storageSvc,true);
    if(sc.isFailure()){
      error() << "Failed to get DybStorageSvc" << endreq;
      return sc;
    }
  }
  StatusCode sc = this->service("JobInfoSvc",m_jobInfoSvc,true);
  if(sc.isFailure()){
    error() << "Failed to get JobInfoSvc" << endreq;
    return sc;
  }

  // Get and hold on to the incident service and add ourself.
  sc = this->service("IncidentSvc",m_incsvc,true);
  if (sc.isFailure()) {
      error() << "Failed to get IncidentSvc" << endreq;
      return sc;
  }
  m_incsvc->addListener(this,"RootIOIncident");

  return StatusCode::SUCCESS;
}

StatusCode JobInfoWriterAlg::execute()
{
  return StatusCode::SUCCESS;
}

StatusCode JobInfoWriterAlg::finalize()
{
  m_jobInfoSvc->release();

  // Must remove self.  O.w. we may finalize before RootIOSvc and
  // leave beind a dangling handler.
  m_incsvc->removeListener(this,"RootIOIncident");
  m_incsvc->release();

  return StatusCode::SUCCESS;
}


StatusCode JobInfoWriterAlg::endRun()
{
  // Write the job info to file/database at the end of the run
  StatusCode sc = StatusCode::SUCCESS;
  if( m_writeToFile ) sc = this->writeDataToFile();
  if( !sc.isSuccess() ) return sc;
  if( m_writeToDatabase ) sc = this->writeDataToDatabase();
  return sc;
}

StatusCode JobInfoWriterAlg::writeDataToFile(){
  // Write job info to current output file

  debug() << "Writing JobInfo" << endreq;

  std::vector<DayaBay::JobInfo*> jobInfo = m_jobInfoSvc->cachedJobInfo();

  // Create Job Header
  DayaBay::JobHeader jobHeader;
  jobHeader.setJobInfoList( jobInfo );

  // Have to put JobHeader in a registry for DybStorageSvc to work correctly
  DataSvcHelpers::RegistryEntry* regEntry 
    = new DataSvcHelpers::RegistryEntry(m_jobInfoLocation);
  regEntry->setObject(&jobHeader);

  debug() << "Storing JobHeader with "
          << jobInfo.size() << " entries at " 
          << m_jobInfoLocation << endreq;
  StatusCode sc = m_storageSvc->store(&jobHeader, m_jobInfoLocation);
  debug() << "Stored JobHeader" << endreq;
  if(sc.isFailure()){
    error() << "Failed to store Job Header to output file" << endreq;
  }

  // Clear job info to prevent deleting
  jobInfo.clear();
  jobHeader.setJobInfoList( jobInfo );

  return sc;
}

StatusCode JobInfoWriterAlg::writeDataToDatabase(){
  // Write Job Info to offline database
  warning() << "Writing job info to offline database is not yet implemented."
            << endreq;
  return StatusCode::SUCCESS;
}

void JobInfoWriterAlg::handle(const Incident& incident)
{
    if (!m_writeToFile) return;

    // Handle the incident in a trivial manner

    const RootIOIncident* rioinc = dynamic_cast<const RootIOIncident*>(&incident);
    if (!rioinc) {
        warning() 
            << "Ignoring unexpected incident not of class RootIOIncident" 
            << endreq;
        return;
    }
    
    if (rioinc->state() != RootIOIncident::opened_output) {
        return;
    }

    StatusCode sc = this->writeDataToFile();
    if (sc.isFailure()) {
        error()
            << "Failed to write JobInfo to output file "
            << "while handling opened output incidence"
            << endreq;
    }
    debug() << "Handled closing_output for " << rioinc->filename() << endreq;
}

---