VP1FileUtilities Class Reference

#include <VP1FileUtilities.h>

Collaboration diagram for VP1FileUtilities:

Public Member Functions
	VP1FileUtilities (const std::string &inputDirectory, unsigned int fileLimit, const std::string &outputDir="", bool forceMakeOutputDir=false, bool removeInputFile=true)
virtual	~VP1FileUtilities ()
void	produceNewFile (const std::string &sourceFile, unsigned int runNumber, unsigned long long eventNumber, unsigned int timeStamp, const std::string &textLabel="")

Static Public Member Functions
static bool	fileExistsAndReadable (const std::string &)

Private Member Functions
void	cleanUp ()

Private Attributes
std::string	m_inputDirectory
int	m_fileLimit
std::string	m_outputDirectory
bool	m_forceMakeOutputDir
bool	m_removeInputFile

Detailed Description

Definition at line 24 of file VP1FileUtilities.h.

Constructor & Destructor Documentation

VP1FileUtilities()

VP1FileUtilities::VP1FileUtilities	(	const std::string &	inputDirectory,
		unsigned int	fileLimit,
		const std::string &	outputDir = "",
		bool	forceMakeOutputDir = false,
		bool	removeInputFile = true
	)

Definition at line 32 of file VP1FileUtilities.cxx.

                                                                                                                     :
  m_inputDirectory(inputDirectory),
  m_fileLimit(fileLimit),
  m_outputDirectory(outputDir),
  m_forceMakeOutputDir(forceMakeOutputDir),
  m_removeInputFile(removeInputFile)
{
  // Check if the input directory exists and is writable
  QFileInfo inpDir(m_inputDirectory.c_str());
  if(!inpDir.exists()||!inpDir.isDir()||!inpDir.isReadable()||!inpDir.isWritable()) {
    std::string errMessage = std::string("VP1FileUtilities: ERROR!! The directory ") + inputDirectory + std::string(" either does not exist or is not writable");
    throw std::runtime_error(errMessage.c_str());
  }
 
  // Check if the output directory exists and is writable
  if (m_outputDirectory != "") {
      QFileInfo inpDir(m_outputDirectory.c_str());
      if(!inpDir.exists()||!inpDir.isDir()||!inpDir.isReadable()||!inpDir.isWritable()) {
          std::string errMessage = std::string("VP1FileUtilities: ERROR!! The directory ") + m_outputDirectory + std::string(" does not exist.");
          if (m_forceMakeOutputDir) {
              errMessage += "\nforceMakeOutputDir=True --> Creating the output folder now...";
              QDir().mkdir(m_outputDirectory.c_str());
          } else {
              throw std::runtime_error(errMessage.c_str());
          }
      }
  }
 
}

~VP1FileUtilities()

VP1FileUtilities::~VP1FileUtilities ( )

virtual

Definition at line 63 of file VP1FileUtilities.cxx.

{
}

Member Function Documentation

cleanUp()

void VP1FileUtilities::cleanUp ( )

private

Definition at line 175 of file VP1FileUtilities.cxx.

{
  //std::cout << "VP1FileUtilities::cleanUp()" << std::endl;
 
  QDir dir;
  dir.setPath(QString(m_outputDirectory.c_str()));
 
  QStringList nameFilters;
  nameFilters << "vp1_*.pool.root";
 
  dir.setFilter(QDir::Files);
  dir.setNameFilters(nameFilters);
  dir.setSorting(QDir::Time|QDir::Reversed);
  QFileInfoList list = dir.entryInfoList();
 
  if(int(list.size()) > m_fileLimit)
  {
    const QFileInfo& fileInfo = list.at(0);
 
    if(!dir.remove(fileInfo.fileName()))
      throw std::runtime_error("VP1FileUtilities::cleanup() - WARNING: Unable to do the clean up!");
  }
 
  QString poolCatalog("PoolFileCatalog.xml");
  std::string poolCatalogStr = poolCatalog.toStdString();
  std::cout << "looking for " << poolCatalogStr << " in " <<  QDir::currentPath().toStdString() << std::endl;
  if ( QDir::current().entryList().contains( poolCatalog ) ) {
      std::cout << "VP1FileUtilities::cleanUp() - removing the file '" << poolCatalogStr << "' because it causes problems for subsequent Athena commands opening the copied file." << std::endl;
      QDir cwd = QDir::currentPath();
      if ( ! cwd.remove( poolCatalog ) )
        std::cerr << "VP1FileUtilities WARNING! Unable to delete " << poolCatalogStr << std::endl;
  }
 
  return;
}

fileExistsAndReadable()

bool VP1FileUtilities::fileExistsAndReadable ( const std::string &  file )

static

Definition at line 211 of file VP1FileUtilities.cxx.

{
  return !file.empty() && QFileInfo(file.c_str()).exists();
}

produceNewFile()

void VP1FileUtilities::produceNewFile	(	const std::string &	sourceFile,
		unsigned int	runNumber,
		unsigned long long	eventNumber,
		unsigned int	timeStamp,
		const std::string &	textLabel = ""
	)

Definition at line 67 of file VP1FileUtilities.cxx.

{
  // Check if the sourceFile exists
  QString srcName(sourceFile.c_str());
  QFile srcFile(srcName);
 
  if(!srcFile.exists())
    throw std::runtime_error("Source file does not exist!");
 
  QString inpDirName(m_inputDirectory.c_str());
  QString outDirName(m_outputDirectory.c_str());
 
  // Construct new filename
  QString newFileName = inpDirName;
  std::ostringstream newFileStr;
 
  // if input directory name is empty don't add / to the file name
  // also take into account a possibility of trailing slash in directory name
  if(m_inputDirectory!="" && m_inputDirectory.rfind('/')!=m_inputDirectory.size()-1)
    newFileStr << "/";
 
  QString latestEventFileName = inpDirName + QString(newFileStr.str().c_str()) + QString("latest_vp1event");
 
  if (textLabel != "" ) {
    newFileStr << "vp1_r" << runNumber << "_ev" << eventNumber << "_u" << timeStamp << "_t" << textLabel << ".pool.root";
  } else {
    newFileStr << "vp1_r" << runNumber << "_ev" << eventNumber << "_u" << timeStamp << ".pool.root";
  }
 
  newFileName += QString(newFileStr.str().c_str());
 
 
  // adding the output folder, if not empty
  if (outDirName != "")
      newFileName = outDirName + QDir::separator() + newFileName;
 
  // do copy
  std::cout << "VP1FileUtilities -- copying '" <<  (srcFile.fileName()).toStdString() << "' to: '" << newFileName.toStdString() << "'..." << std::endl;
 
 
  // get size of the file to be copied
  qint64 inputSize = srcFile.size();
  std::cout << "VP1FileUtilities -- Size of the input file to be copied: " << inputSize << std::endl;
 
 
  if(!srcFile.copy(newFileName)) {
      throw std::runtime_error("VP1FileUtilities -- Unable to copy the temp file to the new file, so unable to produce the new vp1 event file");
  }
 
  // remove the input file (if not disabled by user)
  std::cout << "VP1FileUtilities -- delete temp file? --> " <<  m_removeInputFile << std::endl;
  if (m_removeInputFile) {
    bool copyDone = false;
    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now() ;
    typedef std::chrono::duration<int,std::milli> millisecs_t ;
    while (!copyDone) {
 
      // get handle on new file
      QFileInfo checkFile(newFileName);
 
 
      // check if file exists (and it is a file, and not a directory)
      if (checkFile.exists() && checkFile.isFile() && (checkFile.size() == inputSize) )
        {
          std::cout << "VP1FileUtilities -- Size of the file to be deleted: " << checkFile.size() << std::endl;
          copyDone = true;
          if(!srcFile.remove())
            std::cerr << "VP1FileUtilities -- WARNING! Unable to delete " << sourceFile << std::endl;
        }
      else
        {
          std::cout << "VP1FileUtilities -- I could not find the output file, so probably the copy action is not finished yet. I'll wait for a short while and I will retry..." << std::endl;
          std::this_thread::sleep_for(std::chrono::milliseconds(500)); //make the program waiting for 0.5 seconds
          std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now() ;
          millisecs_t duration( std::chrono::duration_cast<millisecs_t>(end-start) ) ;
          if (duration.count() > 2000.0 )
            {
              std::cout << "VP1FileUtilities -- WARNING!!! " << duration.count() << " milliseconds passed and still I cannot find the output file. Probably there was a problem. Giving up with the removal of the source file...\n" ;
              copyDone = true;
            }
        }
    }
  }
 
  // create/update the latest event file
  QFile latestEvent(latestEventFileName);
  if(latestEvent.exists() && !latestEvent.remove())
    throw std::runtime_error("VP1FileUtilities -- Unable to overwrite the existing latest event file");
 
  if(!latestEvent.open(QIODevice::WriteOnly | QIODevice::Text))
    throw std::runtime_error("VP1FileUtilities -- Unable to create new latest event file");
  latestEvent.write(newFileName.toStdString().c_str());
  latestEvent.close();
 
  // do cleanup if requested. '-1' means 'KEEP ALL FILES'
  if (m_fileLimit != -1) {
      std::cout << "VP1FileUtilities -- cleaning up..." << std::endl;
      cleanUp();
  }
}

Member Data Documentation

m_fileLimit

int VP1FileUtilities::m_fileLimit

private

Definition at line 64 of file VP1FileUtilities.h.

m_forceMakeOutputDir

bool VP1FileUtilities::m_forceMakeOutputDir

private

Definition at line 66 of file VP1FileUtilities.h.

m_inputDirectory

std::string VP1FileUtilities::m_inputDirectory

private

Definition at line 63 of file VP1FileUtilities.h.

m_outputDirectory

std::string VP1FileUtilities::m_outputDirectory

private

Definition at line 65 of file VP1FileUtilities.h.

m_removeInputFile

bool VP1FileUtilities::m_removeInputFile

private

Definition at line 67 of file VP1FileUtilities.h.

---

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

• VP1FileUtilities.h
• VP1FileUtilities.cxx