KVDataRepositoryImpl.cpp

#include "KVDataRepositoryImpl.h"
#include "TROOT.h"
#include "TRegexp.h"
#include "TNetFile.h"
 
ClassImp(KVDataRepositoryImpl)
 
 
 
KVDataRepositoryImpl::KVDataRepositoryImpl()
{
   SetType("local");
}
 
 
 
 
int KVDataRepositoryImpl::Chmod(const char* file, UInt_t mode) const
{
   //Used to change file access permissions in the repository
 
   //do we need a special helper for this filesystem ?
   TSystem* helper = FindHelper(file);
   return (helper ? helper->Chmod(file, mode) : gSystem->Chmod(file, mode));
}
 
 
 
 
 
Bool_t KVDataRepositoryImpl::check_path_exists(const TString& path) const
{
   // \return kTRUE if given full path exists in repository
   return !gSystem->AccessPathName(path);
}
 
 
 
 
Bool_t KVDataRepositoryImpl::GetPathInfo(const TString& path, FileStat_t& fs) const
{
   // \return kTRUE if file with given full path exists in the repository
   // \param[in] path full path to file, see get_path_with_access_root()
   // \param[out] fs informations on the file (if it exists)
 
   return !gSystem->GetPathInfo(path, fs);
}
 
 
 
 
int KVDataRepositoryImpl::copy_file_from(const TString& source, const TString& destination) const
{
   return CopyFile(source, destination);
}
 
 
 
 
int KVDataRepositoryImpl::copy_file_to(const TString& source, const TString& destination) const
{
   return CopyFile(source, destination);
}
 
 
 
 
void KVDataRepositoryImpl::make_directory(const TString& path) const
{
   std::cout << "Creating new repository directory: " << path << std::endl;
   gSystem->mkdir(path, kTRUE); // create all parent directories as needed
   //change file access permissions to 775
   Chmod(path, 0775);
}
 
 
 
 
KVUniqueNameList KVDataRepositoryImpl::get_directory_listing(const TString& path) const
{
   //open directory
   void* dirp = gSystem->OpenDirectory(path.Data());
   if (!dirp) {
      Error("KVDataRepository::GetDirectoryListing", "Cannot open %s",
            path.Data());
      return 0;
   }
 
   KVUniqueNameList dirlist(kTRUE);
   dirlist.SetOwner(kTRUE);
 
   TString direntry = gSystem->GetDirEntry(dirp);
   while (direntry != "") {        //loop over all entries in directory
      if (direntry == "." || direntry == "..") {
         //skip "." and ".."
      }
      else {
         dirlist.Add(new KVBase(direntry));
      }
      //get next entry
      direntry = gSystem->GetDirEntry(dirp);
   }
   //close directory
   gSystem->FreeDirectory(dirp);
   return dirlist;
}
 
 
 
 
int KVDataRepositoryImpl::delete_file(const TString& path) const
{
   return gSystem->Unlink(path);
}
 
 
 
 
TSystem* KVDataRepositoryImpl::FindHelper(const char* path, void* dirptr) const
{
   // Create helper TSystem to handle file and directory operations that
   // might be special for remote file access, like via rfiod or rootd.
 
   TPluginHandler* h;
   TSystem* helper = 0;
   TUrl url(path, kTRUE);
 
   // look for existing helpers
   TIter next(&fHelpers);
   while ((helper = (TSystem*) next()))
      if (HelperIsConsistentWith(helper, path, dirptr))
         return helper;
 
   if (!path)
      return 0;
 
   // create new helper
   TRegexp re("^root.*:");  // also roots, rootk, etc
   TString pname = path;
   if (pname.Index(re) != kNPOS) {
      // rootd daemon ...
      if ((h = gROOT->GetPluginManager()->FindHandler("TSystem", path)) &&
            h->LoadPlugin() == 0)
         helper = (TSystem*) h->ExecPlugin(2, path, kFALSE);
      else
#ifdef __WITHOUT_TNETSYSTEM_CTOR_BOOL_T
         helper = new TNetSystem(path);
#else
         helper = new TNetSystem(path, kFALSE);
#endif
   }
   else if (!strcmp(url.GetProtocol(), "http") &&
            pname.BeginsWith("http")) {
      // http ...
      if ((h = gROOT->GetPluginManager()->FindHandler("TSystem", path)) &&
            h->LoadPlugin() == 0)
         helper = (TSystem*) h->ExecPlugin(0);
      else {
         ;  // no default helper yet
      }
   }
   else if ((h = gROOT->GetPluginManager()->FindHandler("TSystem", path))) {
      if (h->LoadPlugin() == -1)
         return 0;
      helper = (TSystem*) h->ExecPlugin(0);
   }
 
   if (helper)
      fHelpers.Add(helper);
 
   return helper;
}
 
 
 
 
Bool_t KVDataRepositoryImpl::HelperIsConsistentWith(TSystem* helper, const TString& path, void* dirptr) const
{
   // Copy of (protected) method TSystem::ConsistentWith
   // Check consistency of this helper with the one required
   // by 'path' or 'dirptr'
 
   Bool_t checkproto = kFALSE;
   if (path) {
      if (!helper->GetDirPtr()) {
         TUrl url(path, kTRUE);
         if (!strncmp(url.GetProtocol(), helper->GetName(), strlen(helper->GetName())))
            checkproto = kTRUE;
      }
   }
 
   Bool_t checkdir = kFALSE;
   if (helper->GetDirPtr() && helper->GetDirPtr() == dirptr)
      checkdir = kTRUE;
 
   return (checkproto || checkdir);
}
 
 
 
 
 
int KVDataRepositoryImpl::CopyFile(const TString& f, const TString& t, Bool_t overwrite) const
{
   //Method to copy any file from anywhere to anywhere
   //(if the necessary TFile and TSystem plugins are available).
   //
   // Copy a file.
   //
   // If overwrite is true and file already exists the file will be overwritten
   //
   //\returns 0 when successful, -1 in case
   // of failure, -2 in case the file already exists and overwrite was false.
 
   if (!gSystem->AccessPathName(t) && !overwrite)
      return -2;
 
   //save current directory
   TDirectory* dir_sav = gDirectory;
 
   auto ok = TFile::Cp(f, t);
 
   return ok ? 0 : -1;
}