#include "FileCatalogMetadataExtras.h"

Classes
struct	PerFileMetadata

Public Member Functions
	FileCatalogMetadataExtras (fhicl::ParameterSet const &pset, art::ActivityRegistry &reg)

	~FileCatalogMetadataExtras ()

void	reconfigure (fhicl::ParameterSet const &p)

Private Member Functions
void	postBeginJob ()

void	postEndJob ()

void	postOpenFile (std::string const &fn)

void	postCloseFile ()

void	preEvent (art::Event const &ev)

void	postEvent (art::Event const &ev)

void	postOpenOutputFile (std::string const &fn)

void	postCloseOutputFile (art::OutputFileInfo const &finfo)

void	checkOutputFiles ()

void	addPerFileMetadata (std::string const &fn)

void	renameOutputFile (std::string const &fn)

std::string	expandTemplate () const

Static Private Member Functions
static bool	isArtFile (std::string const &fn)

Private Attributes
std::multimap< std::string, std::string >	fPerJobMetadata

bool	fGeneratePerFileMetadata

std::vector< std::string >	fCopyMetadataAttributes

std::string	fRenameTemplate

bool	fRenameOverwrite

std::map< std::string, PerFileMetadata >	fPerFileMetadataMap

std::vector< std::string >	fOutputFiles

std::string	fLastInputFile

unsigned int	fOutputFileCount

Detailed Description

Definition at line 98 of file FileCatalogMetadataExtras.h.

Constructor & Destructor Documentation

util::FileCatalogMetadataExtras::FileCatalogMetadataExtras	(	fhicl::ParameterSet const &	pset,
		art::ActivityRegistry &	reg
	)

Definition at line 26 of file FileCatalogMetadataExtras_service.cc.

References postBeginJob(), postCloseFile(), postCloseOutputFile(), postEndJob(), postEvent(), postOpenFile(), preEvent(), reconfigure(), art::ActivityRegistry::sPostBeginJob, art::ActivityRegistry::sPostCloseFile, art::ActivityRegistry::sPostCloseOutputFile, art::ActivityRegistry::sPostEndJob, art::ActivityRegistry::sPostOpenFile, art::ActivityRegistry::sPostProcessEvent, and art::ActivityRegistry::sPreProcessEvent.

                                                                                      :
   fGeneratePerFileMetadata(false),
   fRenameOverwrite(false),
   fOutputFileCount(0)
 {
   reconfigure(pset);
 
   // Register for callbacks.
 
   reg.sPostBeginJob.watch(this, &FileCatalogMetadataExtras::postBeginJob);
   reg.sPostEndJob.watch(this, &FileCatalogMetadataExtras::postEndJob);
   reg.sPostOpenFile.watch(this, &FileCatalogMetadataExtras::postOpenFile);
   reg.sPostCloseFile.watch(this, &FileCatalogMetadataExtras::postCloseFile);
   reg.sPreProcessEvent.watch(this, &FileCatalogMetadataExtras::preEvent);
   reg.sPostProcessEvent.watch(this, &FileCatalogMetadataExtras::postEvent);
   reg.sPostCloseOutputFile.watch(this, &FileCatalogMetadataExtras::postCloseOutputFile);
 }

util::FileCatalogMetadataExtras::~FileCatalogMetadataExtras ( )

Definition at line 48 of file FileCatalogMetadataExtras_service.cc.

References checkOutputFiles().

 {
   // Shouldn't really be necessary to call checkOutputFiles, as we can
   // catch final closed files via postEndJob callback.  But do it just
   // for extra safety, and can't do any harm.
 
   checkOutputFiles();
 }

Member Function Documentation

void util::FileCatalogMetadataExtras::addPerFileMetadata ( std::string const & fn )

private

Definition at line 371 of file FileCatalogMetadataExtras_service.cc.

References util::FileCatalogMetadataExtras::PerFileMetadata::fEndTime, fGeneratePerFileMetadata, file, util::FileCatalogMetadataExtras::PerFileMetadata::fillMetadata(), fPerFileMetadataMap, isArtFile(), and art::SQLErrMsg::throwIfError().

Referenced by util::FileCatalogMetadataExtras::PerFileMetadata::PerFileMetadata(), and postCloseOutputFile().

 {
   // Do nothing if generating per-file metadata is disabled.
 
   if(!fGeneratePerFileMetadata)
     return;
 
   // Do nothing if this is not an art file (not an error).
 
   if(!isArtFile(fn))
     return;
 
   // Locate metadata.
   // If we don't have metadata for this file in the metadata map,
   // look for a renamed (non-existing) file.
 
   std::string map_fn = fn;
   if(fPerFileMetadataMap.count(map_fn) == 0) {
     std::vector<std::string> renamed_files;
     for(auto const& map_ele : fPerFileMetadataMap) {
       std::string filename = map_ele.first;
       std::ifstream file(filename);
       if(file.good() && file.is_open())
         file.close();
       else
         renamed_files.push_back(filename);
     }
 
     if(renamed_files.size() == 1)
       map_fn = renamed_files.front();
     else {
       throw cet::exception("FileCatalogMetadataExtras")
         << "Could not access metadata because there is more than one renamed output file.\n";
     }
   }
   if(map_fn != fn) {
     mf::LogInfo info("FileCatalogMetadataExtras");
     info << "No metadata for file " << fn 
          << "\nUsing renamed file " << map_fn << " metadata instead.";
   }
 
   if(fPerFileMetadataMap.count(map_fn) == 0)
     throw cet::exception("FileCatalogMetadataExtras")
       << "No metadata found for file " << map_fn << ".\n";
   PerFileMetadata& md = fPerFileMetadataMap[map_fn];
 
   // Update end time.
 
   md.fEndTime = time(0);
 
   // Update sam metadata in root file.  
   // Open exsiting root file for update.
 
   TFile* file = TFile::Open(fn.c_str(), "UPDATE");
   if(file != 0 && !file->IsZombie() && file->IsOpen()) {
 
     // Open the sqlite datatabase.
 
     art::SQLite3Wrapper sqliteDB(file, "RootFileDB");
     if(sqliteDB) {
 
       // Sqlite database inside art file successfully opened.
       //
       // Before attempting to add per-file sam metadata, test
       // whether the FileCatalog_metadata table exists.  It is
       // normal for the FileCatalog_metadata table to not exist,
       // since generating sam metadata is optional.
 
       art::SQLErrMsg errMsg;
       sqlite3_exec(sqliteDB, "BEGIN TRANSACTION;", 0, 0, errMsg);
       sqlite3_stmt *stmt = 0;
       int ok = sqlite3_prepare_v2(sqliteDB, "SELECT 1 FROM FileCatalog_metadata;",
                                   -1, &stmt, NULL);
       if(ok == SQLITE_OK) {
         sqlite3_step(stmt);
         ok = sqlite3_finalize(stmt);
       }
       if(ok == SQLITE_OK) {
 
         // Now we have verified that the sqlite database in this art
         // file contqains a FileCatalog_metadata table.
 
         // Convert our per-file metadata to name-value pairs.
 
         std::multimap<std::string, std::string> mdmap;
         md.fillMetadata(mdmap);
 
         // Insert metadata into sqlite database.
         // This loop is basically copied exactly from RootOutputFile.cc.
 
         sqlite3_prepare_v2(sqliteDB,
                            "INSERT INTO FileCatalog_metadata(Name, Value) VALUES(?, ?);",
                            -1, &stmt, NULL);
         sqlite3_stmt *delete_stmt = 0;
         sqlite3_prepare_v2(sqliteDB,
                            "DELETE FROM FileCatalog_metadata WHERE Name=?;",
                            -1, &delete_stmt, NULL);
         std::string lastName;
         for ( auto const & nvp : mdmap ) {
           std::string const & theName  (nvp.first);
           std::string const & theValue (nvp.second);
 
           // On the first occurrence of each per-file metadata name,
           // delete any existing (per-job) metadata with the same
           // name.
 
           if(theName != lastName) {
             lastName = theName;
             if(theName.size() != 0) {
               sqlite3_bind_text(delete_stmt, 1, theName.c_str(),
                                 theName.size() + 1, SQLITE_STATIC);
               sqlite3_step(delete_stmt);
               sqlite3_reset(delete_stmt);
               sqlite3_clear_bindings(delete_stmt);
             }
           }
           sqlite3_bind_text(stmt, 1, theName.c_str(),
                             theName.size() + 1, SQLITE_STATIC);
           sqlite3_bind_text(stmt, 2, theValue.c_str(),
                             theValue.size() + 1, SQLITE_STATIC);
           sqlite3_step(stmt);
           sqlite3_reset(stmt);
           sqlite3_clear_bindings(stmt);
         }
         sqlite3_finalize(stmt);
         sqlite3_finalize(delete_stmt);
         sqlite3_exec(sqliteDB, "END TRANSACTION;", 0, 0, errMsg);
       }
       else {
 
         // The else clause is reached if there is no
         // FileCatalog_metadata table.
 
         sqlite3_exec(sqliteDB, "ROLLBACK TRANSACTION;", 0, 0, errMsg);
       }
       errMsg.throwIfError();
     }
   }
 
   // Close (possibly updated) root file.
 
   if(file != 0) {
     if(file->IsOpen())
       file->Close();
     delete file;
   }
 
   // Delete the metadata we used from the metadata map, so we don't 
   // accidentally use it again.
 
   fPerFileMetadataMap.erase(map_fn);
 }

void util::FileCatalogMetadataExtras::checkOutputFiles ( )

private

Definition at line 320 of file FileCatalogMetadataExtras_service.cc.

References fGeneratePerFileMetadata, file, fOutputFiles, and postOpenOutputFile().

Referenced by util::FileCatalogMetadataExtras::PerFileMetadata::PerFileMetadata(), postBeginJob(), postCloseFile(), postEndJob(), postEvent(), postOpenFile(), preEvent(), and ~FileCatalogMetadataExtras().

 {
   // In this method we generate pseudo-callbacks for opening and
   // closing output files.  We have to do it this way, because the art
   // ActivityRegistry doesn't currently support callbacks for output
   // files.
 
   // We can skip all of this stuff if we have not been asked to
   // generate per-file metadata.
 
   if(!fGeneratePerFileMetadata)
     return;
 
   // Get a sorted list of currently open output files.
 
   std::vector<std::string> output_files;
   TIter next(gROOT->GetListOfFiles());
   while(TFile* file = (TFile*)next()) {
     if(file->GetBytesWritten() > 0)
       output_files.push_back(file->GetName());
   }
   std::sort(output_files.begin(), output_files.end());
 
   // Compare current output files with previously known output files.
 
   std::vector<std::string> opened_files(output_files.size());
   std::vector<std::string> closed_files(fOutputFiles.size());
   std::vector<std::string>::iterator it;
   it = std::set_difference(output_files.begin(), output_files.end(),
                            fOutputFiles.begin(), fOutputFiles.end(),
                            opened_files.begin());
   opened_files.resize(it - opened_files.begin());
   it = std::set_difference(fOutputFiles.begin(), fOutputFiles.end(),
                            output_files.begin(), output_files.end(),
                            closed_files.begin());
   closed_files.resize(it - closed_files.begin());
 
   // Generate pseudo-callbacks for opened and closed output files.
   // As of art v1_08_00, callbacks for closed output files are provided
   // by art ActivityRegistry.
 
   for(auto const& of : opened_files)
     postOpenOutputFile(of);
   
   // Update list of open output files.
 
   fOutputFiles.swap(output_files);
 }

std::string util::FileCatalogMetadataExtras::expandTemplate ( ) const

private

Definition at line 642 of file FileCatalogMetadataExtras_service.cc.

References DEFINE_ART_SERVICE, f, fLastInputFile, fOutputFileCount, fRenameTemplate, and n.

Referenced by util::FileCatalogMetadataExtras::PerFileMetadata::PerFileMetadata(), and renameOutputFile().

 {
   // Make a copy of the template that we can modify, which will be
   // the eventual return value.
 
   std::string filename = fRenameTemplate;
 
   // If template doesn't contain any ${...} expressions, stick the
   // field "${bnum 0} before the file extension.
 
   if(filename.find_first_of("${}") == std::string::npos) {
     size_t n = filename.find_last_of('.');
     if(n == std::string::npos)
       n = filename.size();
     std::string head = filename.substr(0, n);
     std::string tail = filename.substr(n);
     filename = head + std::string("${bnum 0}") + tail;
   }
 
   // Get the current system time (for ${date} ane ${time}).
 
   time_t curtime = time(0);
 
   // Parse file name, looking for ${...} expressions.  We assume these
   // expressions are not nested, and can be evaluated in any order.
   // The text inside the braces, can be either a) a keyword plus
   // arguments, or b) an environment variable.  If neither is the case,
   // a warning is printed and the value of the subargument, if any,
   // is substituted.
 
   size_t f = 0;
   while((f = filename.find("${")) != std::string::npos) {
 
     // Find closing brace.  Throw exception in case of problem.
 
     size_t n = filename.substr(f).find("}");
     if(n == std::string::npos)
       throw cet::exception("FileCatalogMetadataExtras")
         << "Output file name template: " << filename
         << " has mismatched braces.\n";
 
     // Split current filename into three pieces: head, argument of current 
     // ${...}, and tail.
 
     std::string head = filename.substr(0, f);
     std::string arg = filename.substr(f+2, n-2);
     std::string tail = filename.substr(f+n+1);
 
     // Make sure that the head and argument string don't contain
     // any of the reserved characters ${}.  This check catches
     // nested ${...} expressions, mismatched braces, and
     // other typos.
 
     if(head.find_first_of("${}") != std::string::npos ||
        arg.find_first_of("${}") != std::string::npos)
       throw cet::exception("FileCatalogMetadataExtras")
         << "Problem parsing output file name template: " << filename << ".\n";
 
     // Extract the first and second word out of the argument string,
     // which we interpret as keyword and subargument.
 
     std::string keyword;
     std::string subarg;
     {
       std::istringstream istr(arg);
       istr >> keyword;
       istr >> subarg;
     }
 
     // Do interpretation of keyword and subargument.
 
     std::string expanded;
     if(keyword == "base") {
 
       // Base name of input file.
 
       size_t n = fLastInputFile.find_last_of('/');
       size_t f = (n == std::string::npos ? 0 : n+1);
       expanded = fLastInputFile.substr(f);
       if(subarg.size() != 0 && expanded.rfind(subarg) == expanded.size() - subarg.size())
         expanded = expanded.substr(0, expanded.size() - subarg.size());
     }
     else if(keyword == "dir") {
 
       // Directory part of path.
       // If path doesn't include a directory, expand to ".".
 
       size_t n = fLastInputFile.find_last_of('/');
       if(n != std::string::npos)
         expanded = fLastInputFile.substr(0, n);
       else
         expanded = ".";
     }
     else if(keyword == "path") {
 
       // Full input file path.
 
       expanded = fLastInputFile;
       if(subarg.size() != 0 && expanded.rfind(subarg) == expanded.size() - subarg.size())
         expanded = expanded.substr(0, expanded.size() - subarg.size());
     }
     else if(keyword == "num") {
 
       // Output file count.
       // Note that outputFileCount_ is incremented after this method is called,
       // so outputFileCount_ is zero on the first call.
       // Use the subargument to define an offset.
 
       unsigned int offset = 1;
       if(subarg.size() != 0) {
         std::istringstream istr(subarg);
         istr >> offset;
       }
       std::ostringstream ostr;
       ostr << fOutputFileCount + offset;
       expanded = ostr.str();
     }
     else if(keyword == "bnum") {
 
       // Output file count.
       // Same as "num," except expands to empty string for first file.
 
       unsigned int offset = 1;
       if(subarg.size() != 0) {
         std::istringstream istr(subarg);
         istr >> offset;
       }
       if(fOutputFileCount > 0) {
         std::ostringstream ostr;
         ostr << fOutputFileCount + offset;
         expanded = ostr.str();
       }
     }
     else if(keyword == "date") {
 
       // Date formatted as YYYYMMDD in local time zone.
 
       struct tm ts;
       struct tm* pts = 0;
       pts = localtime_r(&curtime, &ts);
       if(pts) {
         std::ostringstream ostr;
         ostr << std::setw(4) << std::setfill('0') << pts->tm_year + 1900
              << std::setw(2) << pts->tm_mon + 1
              << std::setw(2) << pts->tm_mday;
         expanded = ostr.str();
       }
       else {
 
         // localtime call failed.
 
         expanded = "00000000";
       }
     }
     else if(keyword == "time") {
 
       // Time of day formatted as HHMMSS in local time zone.
 
       struct tm ts;
       struct tm* pts = 0;
       pts = localtime_r(&curtime, &ts);
       if(pts) {
         std::ostringstream ostr;
         ostr << std::setw(2) << std::setfill('0') << pts->tm_hour
              << std::setw(2) << pts->tm_min
              << std::setw(2) << pts->tm_sec;
         expanded = ostr.str();
       }
       else {
 
         // localtime call failed.
 
         expanded = "000000";
       }
     }
     else {
 
       // If we get here, the keyword is not known.
       // Try to interpret the keyword as an environment variable.
 
       const char* p = getenv(keyword.c_str());
       if(p != 0 && *p != 0)
         expanded = p;
       else {
 
         // Environment variable not defined.
 
         mf::LogWarning("FileCatalogMetadataExtras")
           << "Unknown keyword " << keyword 
           << " in output file name template " << filename << ".\n";
         expanded = subarg;
       }
     }
 
     // Make sure no reserved characters made it into the expanded argument.
     // This ensures we can't get into an infinite loop.
 
     if(expanded.find_first_of("${}") != std::string::npos)
       throw cet::exception("FileCatalogMetadataExtras")
         << "Problem parsing output file name template: " << filename << ".\n";
 
     // Reassemble file name.
 
     filename = head + expanded + tail;
   }
 
   // Make sure that the finished file name doesn't contain
   // reserved characters ${}.
 
   if(filename.find_first_of("${}") != std::string::npos)
     throw cet::exception("FileCatalogMetadataExtras")
       << "Problem parsing output file name template: "<< filename << ".\n";
   return filename;
 }

bool util::FileCatalogMetadataExtras::isArtFile ( std::string const & fn )

staticprivate

Definition at line 278 of file FileCatalogMetadataExtras_service.cc.

References file.

Referenced by addPerFileMetadata(), util::FileCatalogMetadataExtras::PerFileMetadata::PerFileMetadata(), postOpenOutputFile(), and renameOutputFile().

 {
   bool result = false;
   if(fn.size() != 0) {
 
     // Try to open the file for reading.
     // Apparently, TFile will sometimes throw an exception.
 
     TFile* file = 0;
     try {
       file = TFile::Open(fn.c_str(), "READ");
     }
     catch (...) {
       file = 0;
     }
 
     if(file != 0 && !file->IsZombie() && file->IsOpen()) {
 
       // File successfully opened.
       // Check whether the file contains a RootFileDB object.
 
       TKey* key = file->GetKey("RootFileDB");
       if(key != 0)
         result = true;
     }
 
     // Close file.
 
     if(file != 0) {
       if(file->IsOpen())
         file->Close();
       delete file;
     }
   }
 
   // Done.
 
   return result;
 }

void util::FileCatalogMetadataExtras::postBeginJob ( )

private

Definition at line 81 of file FileCatalogMetadataExtras_service.cc.

References art::FileCatalogMetadata::addMetadata(), checkOutputFiles(), fPerJobMetadata, art::FileCatalogMetadata::getMetadata(), and fhicl::detail::atom::value().

Referenced by FileCatalogMetadataExtras(), and util::FileCatalogMetadataExtras::PerFileMetadata::PerFileMetadata().

 {
   checkOutputFiles();
 
   // Get art metadata service.
 
   art::ServiceHandle<art::FileCatalogMetadata> mds;
 
   // Loop over metadata.
 
   for(auto i=fPerJobMetadata.cbegin(); i!=fPerJobMetadata.cend(); ++i) {
     const std::string& name = i->first;
     const std::string& value = i->second;
 
     // Ignore null values.
 
     if(value.size() > 0) {
 
       // See if this (name, value) already exists.
 
       bool exists = false;
       art::FileCatalogMetadata::collection_type md;
       mds->getMetadata(md);
       for(auto const & nvp : md) {
         if(nvp.first == name) {
           exists = true;
 
           // If value doesn't match, throw an exception.
 
           if(nvp.second != value) {
             throw cet::exception("FileCatalogMetadataExtras")
               << "Found duplicate name " << name << " with non-matching value.\n";
           }
         }
       }
 
       // Add new (name, value).
 
       if(!exists)
         mds->addMetadata(name, value);
     }
   }
 }

void util::FileCatalogMetadataExtras::postCloseFile ( )

private

Definition at line 142 of file FileCatalogMetadataExtras_service.cc.

References checkOutputFiles().

Referenced by FileCatalogMetadataExtras(), and util::FileCatalogMetadataExtras::PerFileMetadata::PerFileMetadata().

 {
   checkOutputFiles();
 }

void util::FileCatalogMetadataExtras::postCloseOutputFile ( art::OutputFileInfo const & finfo )

private

Definition at line 261 of file FileCatalogMetadataExtras_service.cc.

References addPerFileMetadata(), art::OutputFileInfo::fileName(), and renameOutputFile().

Referenced by FileCatalogMetadataExtras(), and util::FileCatalogMetadataExtras::PerFileMetadata::PerFileMetadata().

 {
   const std::string& fn = finfo.fileName();
 
   // Update metadata for this output file.
 
   addPerFileMetadata(fn);
 
   // Rename output file.
 
   renameOutputFile(fn);
 }

void util::FileCatalogMetadataExtras::postEndJob ( )

private

Definition at line 127 of file FileCatalogMetadataExtras_service.cc.

References checkOutputFiles().

Referenced by FileCatalogMetadataExtras(), and util::FileCatalogMetadataExtras::PerFileMetadata::PerFileMetadata().

 {
   checkOutputFiles();
 }

void util::FileCatalogMetadataExtras::postEvent ( art::Event const & ev )

private

Definition at line 156 of file FileCatalogMetadataExtras_service.cc.

References checkOutputFiles(), art::Event::event(), util::FileCatalogMetadataExtras::PerFileMetadata::fEventCount, util::FileCatalogMetadataExtras::PerFileMetadata::fFirstEvent, util::FileCatalogMetadataExtras::PerFileMetadata::fLastEvent, fLastInputFile, fOutputFiles, util::FileCatalogMetadataExtras::PerFileMetadata::fParents, fPerFileMetadataMap, util::FileCatalogMetadataExtras::PerFileMetadata::fRunNumbers, util::FileCatalogMetadataExtras::PerFileMetadata::fSubRunNumbers, art::Event::run(), and art::Event::subRun().

Referenced by FileCatalogMetadataExtras(), and util::FileCatalogMetadataExtras::PerFileMetadata::PerFileMetadata().

 {
   checkOutputFiles();
 
   // Update metadata for open output files.
 
   art::RunNumber_t run = evt.run();
   art::SubRunNumber_t subrun = evt.subRun();
   art::EventNumber_t event = evt.event();
 
   for(auto const& fn : fOutputFiles) {
     auto iMap = fPerFileMetadataMap.find(fn);
     if (iMap == fPerFileMetadataMap.end()) {
       throw cet::exception("FileCatalogMetadataExtras")
         << "no metadata for output file '" << fn << "'\n";
     }
     PerFileMetadata& md = iMap->second;
 
     if(md.fRunNumbers.count(run) == 0)
       md.fRunNumbers.insert(run);
     if(md.fSubRunNumbers.count(subrun) == 0)
       md.fSubRunNumbers.insert(subrun);
     if(md.fEventCount == 0)
       md.fFirstEvent = event;
     md.fLastEvent = event;
     ++md.fEventCount;
     if(!fLastInputFile.empty() && md.fParents.count(fLastInputFile) == 0)
       md.fParents.insert(fLastInputFile);
   }
 }

void util::FileCatalogMetadataExtras::postOpenFile ( std::string const & fn )

private

Definition at line 134 of file FileCatalogMetadataExtras_service.cc.

References checkOutputFiles(), and fLastInputFile.

Referenced by FileCatalogMetadataExtras(), and util::FileCatalogMetadataExtras::PerFileMetadata::PerFileMetadata().

 {
   fLastInputFile = fn;
   checkOutputFiles();
 }

void util::FileCatalogMetadataExtras::postOpenOutputFile ( std::string const & fn )

private

Definition at line 189 of file FileCatalogMetadataExtras_service.cc.

References fCopyMetadataAttributes, util::FileCatalogMetadataExtras::PerFileMetadata::fEndTime, file, fLastInputFile, util::FileCatalogMetadataExtras::PerFileMetadata::fNVPairs, util::FileCatalogMetadataExtras::PerFileMetadata::fParents, fPerFileMetadataMap, util::FileCatalogMetadataExtras::PerFileMetadata::fStartTime, isArtFile(), and fhicl::detail::atom::value().

Referenced by checkOutputFiles(), and util::FileCatalogMetadataExtras::PerFileMetadata::PerFileMetadata().

 {
   // Add initial per-file metadata for this output file.
 
   if(fPerFileMetadataMap.count(fn) != 0)
     throw cet::exception("FileCatalogMetadataExtras")
       << "Output file " << fn << " already has metadata.\n";
   PerFileMetadata md;
   md.fStartTime = time(0);
   md.fEndTime = md.fStartTime;
 
   // Extract data from current input file.
 
   if(fLastInputFile.size() != 0) {
     md.fParents.insert(fLastInputFile);
 
     if(isArtFile(fLastInputFile) && fCopyMetadataAttributes.size() != 0) {
 
       // Open sqlite database from input file.
 
       TFile* file = TFile::Open(fLastInputFile.c_str(), "READ");
       if(file != 0 && !file->IsZombie() && file->IsOpen()) {
 
         // Open the sqlite datatabase.
 
         art::SQLite3Wrapper sqliteDB(file, "RootFileDB");
         if(sqliteDB) {
 
           // Construct query to read all sam metadata.
 
           sqlite3_stmt *stmt = 0;
           int ok = sqlite3_prepare_v2(sqliteDB, "SELECT Name, Value FROM FileCatalog_metadata;",
                                       -1, &stmt, NULL);
 
           // Above statement will return an error if this art file doesn't
           // contain sam metadata.
 
           if(ok == SQLITE_OK) {
 
             // Loop over all rows returned by query.
 
             while((ok = sqlite3_step(stmt)) == SQLITE_ROW) {
 
               // Reinterpret cast below is necessary because return
               // type from sqlite3_colum_text is const unsigned char*,
               // which has no automatic conversion to const char*.
 
               std::string name =
                 std::string(reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0)));
               std::string value =
                 std::string(reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1)));
 
               // Loop over copy attributes.  Add any matching names to
               // general per-file metadata.
 
               for(auto const& attr : fCopyMetadataAttributes) {
                 if(name == attr)
                   md.fNVPairs.insert(std::pair<std::string, std::string>(name, value));
               }
             }
             sqlite3_finalize(stmt);
           }
         }
       }
     }
   }
 
   fPerFileMetadataMap[fn] = md;
 }

void util::FileCatalogMetadataExtras::preEvent ( art::Event const & ev )

private

Definition at line 149 of file FileCatalogMetadataExtras_service.cc.

References checkOutputFiles().

Referenced by FileCatalogMetadataExtras(), and util::FileCatalogMetadataExtras::PerFileMetadata::PerFileMetadata().

 {
   checkOutputFiles();
 }

void util::FileCatalogMetadataExtras::reconfigure ( fhicl::ParameterSet const & p )

Definition at line 59 of file FileCatalogMetadataExtras_service.cc.

References fCopyMetadataAttributes, fGeneratePerFileMetadata, fPerJobMetadata, fRenameOverwrite, fRenameTemplate, and fhicl::ParameterSet::get().

Referenced by FileCatalogMetadataExtras().

 {
   std::vector<std::string> md = pset.get<std::vector<std::string> >("Metadata");
   fGeneratePerFileMetadata = pset.get<bool>("GeneratePerFileMetadata");
   fCopyMetadataAttributes = pset.get<std::vector<std::string> >("CopyMetadataAttributes");
   fRenameTemplate = pset.get<std::string>("RenameTemplate");
   fRenameOverwrite = pset.get<bool>("RenameOverwrite");
 
   // Process name-value pairs.
 
   if(md.size() %2 != 0)
     throw cet::exception("FileCatalogMetadataExtras")
       << "Metadata array has odd number of entries.\n";
   for(unsigned int i=0; i<md.size(); i += 2)
     fPerJobMetadata.insert(std::pair<std::string, std::string>(md[i], md[i+1]));
 
   return;
 }

void util::FileCatalogMetadataExtras::renameOutputFile ( std::string const & fn )

private

Definition at line 576 of file FileCatalogMetadataExtras_service.cc.

References expandTemplate(), file, fOutputFileCount, fRenameOverwrite, fRenameTemplate, and isArtFile().

Referenced by util::FileCatalogMetadataExtras::PerFileMetadata::PerFileMetadata(), and postCloseOutputFile().

 {
   // If the rename template is an empty string, do nothing.
 
   if(fRenameTemplate.size() == 0)
     return;
 
   // Make sure the original file is a readable art file.
   // Do nothing if it is not (not an error).
 
   if(isArtFile(fn)) {
 
     // Expand the output template.
 
     std::string new_fn = expandTemplate();
     if(new_fn.size() != 0) {
 
       // Test whether a file with the new name already exists.
       // If file does exist, action depends on value of fRenameOverwrite
       // parameter.
 
       bool do_rename = false;
       std::ifstream file(new_fn);
       if(file.good()) {
         if(fRenameOverwrite) {
 
           // File exists, but overwriting is enabled.
           // Delete the existing file and proceed with renaming.
 
           remove(new_fn.c_str());
           do_rename = true;
         }
         else {
 
           // File exists, and overwriting is not enabled.
           // Print a warning and do not rename.
 
           mf::LogWarning("FileCatalogMetadataExtras")
             << "Rename failed because a file already exists with name " << new_fn << std::endl;
           do_rename = false;
         }
       }
       else {
 
         // Target file does not exist.  Proceed with rename.
 
         do_rename = true;
       }
 
       // Do the rename.
 
       if(do_rename) {
         mf::LogInfo("FileCatalogMetadataExtras")
           << "Renaming " << fn << " to " << new_fn << std::endl;
         rename(fn.c_str(), new_fn.c_str());
       }
     }
 
     // Increment output file count (only count art files).
 
     ++fOutputFileCount;
   }
 }