KVDataSetRepository.cpp

#include "KVDataSetRepository.h"
#include "KVDataSetManager.h"
#include "KVAvailableRunsFile.h"
 
 
 
Bool_t KVDataSetRepository::GetFileInfo(const KVDataSet* dataset, const TString& datatype, const TString& runfile, FileStat_t& fs) const
{
   //Checks if the run file of given type is physically present in dataset subdirectory,
   //i.e. (schematically), if
   //
   //      /root_of_data_repository/[datasetdir]/[datatypedir]/[runfile]
   //
   //exists. If it does, the returned value is kTRUE (=1), in which case the FileStat_t object
   //contains information about the file.
 
   auto _fs = KVDataRepository::GetFileInfo(runfile, dataset->GetDataPathSubdir(), dataset->GetDataTypeSubdir(datatype));
   if (_fs)
      fs = _fs.value();
   return _fs.has_value();
}
 
 
 
 
Bool_t KVDataSetRepository::CheckFileStatus(const KVDataSet* dataset, const TString& datatype, const TString& runfile)
{
   //Checks if the run file of given type is physically present in dataset subdirectory,
   //i.e. (schematically), if
   //
   //      /root_of_data_repository/[datasetdir]/[datatypedir]/[runfile]
   //
   //exists. If it does, the returned value is kTRUE (=1).
 
   return KVDataRepository::CheckFileStatus(runfile, dataset->GetDataPathSubdir(), dataset->GetDataTypeSubdir(datatype));
}
 
 
 
 
TString KVDataSetRepository::GetFullPathToTransferFile(const KVDataSet* dataset, const TString& datatype, const TString& runfile)
{
   //Used by KVDataTransfer.
   //
   //Returns the full path needed to transfer a runfile belonging to the given dataset
   //either from or to the repository, using sftp or bbftp etc.
   //This is just a concatenation of the repository root directory with the dataset
   //subdirectories and filename.
 
   return KVDataRepository::GetFullPathToTransferFile(runfile, dataset->GetDataPathSubdir(), dataset->GetDataTypeSubdir(datatype));
}
 
 
 
 
KVUniqueNameList KVDataSetRepository::GetDirectoryListing(const KVDataSet* dataset, const TString& datatype, const TString& subdir)
{
   //Use the access protocol defined by DataRepository.AccessProtocol (=local by default)
   //in order to open the directory
   //
   //      /root_of_data_repository/[datasetdir]/[datatype]/[subdir]
   //      /root_of_data_repository/[datasetdir]/[datatype]         (if subdir="", default value)
   //      /root_of_data_repository/[datasetdir]                    (if datatype="", default value)
   //
   //and fill a KVUniqueNameList with one KVBase object for each entry in the directory,
   //excluding "." and ".."
 
   return KVDataRepository::GetDirectoryListing(dataset->GetDataPathSubdir(), dataset->GetDataTypeSubdir(datatype), subdir);
}
 
 
 
 
void KVDataSetRepository::CopyFileFromRepository(const KVDataSet* dataset, const TString& datatype, const TString& filename, const TString& destination)
{
   //Copy file [datasetdir]/[datatypedir]/[filename] from the repository to [destination]
   //We check if the file to copy exists.
 
   KVDataRepository::CopyFileFromRepository(filename, destination, dataset->GetDataPathSubdir(), dataset->GetDataTypeSubdir(datatype));
}
 
 
 
 
int KVDataSetRepository::CopyFileToRepository(const TString& source, const KVDataSet* dataset, const TString& datatype, const TString& filename)
{
   //Copy file [source] to [datasetdir]/[datatypedir]/[filename] in the repository
   //The file access permissions are set to '664 (u:rw, g:rw, o:r)
   //Returns status of file transfer command
 
   return KVDataRepository::CopyFileToRepository(filename, source, dataset->GetDataPathSubdir(), dataset->GetDataTypeSubdir(datatype));
}
 
 
 
 
TFile* KVDataSetRepository::CreateNewFile(const KVDataSet* dataset, const TString& datatype, const TString& filename)
{
   //This will create and open a new ROOT runfile for the dataset in the repository,
   //ready to be written.
   //
   //If the subdirectory for 'datatype' does not exist, it will be created.
   //
   //In fact, if the repository is not one in which files can be created and written
   //directly (i.e. if CanWrite() = kFALSE), the file will be created in the local working
   //directory, and only copied into the repository when CommitFile is called.
 
   return KVDataRepository::CreateNewFile(filename, dataset->GetDataPathSubdir(), dataset->GetDataTypeSubdir(datatype));
}
 
 
 
 
void KVDataSetRepository::CommitFile(TFile* file, const TString& datatype, const KVDataSet* dataset)
{
   //Add this file (previously created by a call to CreateNewFile) to the repository.
   //Any objects should be written to the file before calling this method, either by
   //calling the Write() method of each object, or by calling file->Write().
   //No file->Write() is done here: we only close (delete) the TFile.
   //
   //For repositories in which files can be created and written directly (i.e. if CanWrite() = kTRUE),
   //we just have to close the file.
   //For repositories where CanWrite() = kFALSE, we close the file, then copy it to the correct place in the repository,
   //using the previously recorded values of fCommitDataSetDir, fCommitDataType,
   //and fCommitFileName. Then we remove the local copy from disk.
   //
   //NB: after calling this method, the TFile pointer 'file' must not be used!!!
 
   KVDataRepository::CommitFile(file, dataset->GetDataPathSubdir(), dataset->GetDataTypeSubdir(datatype));
}
 
 
 
 
void KVDataSetRepository::MakeSubdirectory(const KVDataSet* dataset, const TString& datatype)
{
   //Create a new subdirectory in the repository:
   //~~~
   //      /root_of_data_repository/[datasetdir]
   //~~~
   //or with 'datatype' given:
   //~~~
   //      /root_of_data_repository/[datasetdir]/[datatypedir]
   //~~~
   //Set access permissions to 775 (u:rwx, g:rwx, o:rx)
 
   KVDataRepository::MakeSubdirectory(dataset->GetDataPathSubdir(), dataset->GetDataTypeSubdir(datatype));
}
 
 
 
 
void KVDataSetRepository::CreateAllNeededSubdirectories(const KVDataSet* DataSet, const Char_t* DataType)
{
   // Ensure that all required subdirectories exist and any missing ones are created
   // in order to store a runfile of given DataType for the given DataSet
 
   KVDataRepository::CreateAllNeededSubdirectories(DataSet->GetDataPathSubdir(), DataSet->GetDataTypeSubdir(DataType));
}
 
 
 
 
void KVDataSetRepository::DeleteFile(const KVDataSet* ds, const TString& datatype, const TString& runfile, Bool_t confirm)
{
   // Delete file from repository.
   //
   // If confirm=kTRUE, ask for confirmation first (=kFALSE, no confirmation required)
 
   KVDataRepository::DeleteFile(runfile, confirm, ds->GetDataPathSubdir(), ds->GetDataTypeSubdir(datatype));
}
 
 
 
 
KVDataSetManager* KVDataSetRepository::GetDataSetManager() const
{
   //Return pointer to data set manager for this repository
   return fDSM.get();
}
 
 
 
 
KVDataSetRepository::~KVDataSetRepository()
{
   // Just to allow std::unique_ptr<KVDataSetManager> member with incomplete (forward) declaration of KVDataSetManager
}
 
 
 
 
void KVDataSetRepository::cd()
{
   KVDataRepository::cd();
   gDataSetManager = GetDataSetManager();
}
 
 
 
 
Bool_t KVDataSetRepository::Init()
{
   KVDataRepository::Init();
   //data set manager
   fDSM.reset(new KVDataSetManager);
 
   //return status of dataset manager
   return fDSM->Init(this);
}
 
 
 
 
KVAvailableRunsFile* KVDataSetRepository::NewAvailableRunsFile(const Char_t* data_type, const KVDataSet* ds)
{
   // Create new instance of class derived from KVAvailableRunsFile.
   //
   // Actual class of object depends on the type of the repository back-end
   // which is used to select one of the
   // Plugin.KVDataAvailableRunsFile's defined in .kvrootrc.
 
   //check and load plugin library
   TPluginHandler* ph = KVBase::LoadPlugin("KVAvailableRunsFile", GetType());
   if (!ph)
      return new KVAvailableRunsFile(data_type, ds);
 
   //execute constructor/macro for plugin
   return ((KVAvailableRunsFile*) ph->ExecPlugin(2, data_type, ds));
}
 
 
 
 
 
KVDataSetRepository* KVDataSetRepository::NewRepository(const TString& local_or_irods)
{
   // Create new instance of KVDataSetRepository
   //
   // local_or_irods = "local" => KVDataRepositoryImpl or "irods" => IRODSDataRepositoryImpl
 
   auto dr = new KVDataSetRepository;
   dr->set_impl_backend(local_or_irods);
 
   return dr;
}
 
 
ClassImp(KVDataSetRepository)