KVDataRepository.h

/*
$Id: KVDataRepository.h,v 1.12 2007/12/11 12:45:47 franklan Exp $
$Revision: 1.12 $
$Date: 2007/12/11 12:45:47 $
*/
 
 
#ifndef __KVDATAREPOSITORY_H
#define __KVDATAREPOSITORY_H
 
#include <functional>
#include <optional>
#include "KVBase.h"
#include "TString.h"
#include "TSystem.h"
#include "TEnv.h"
#include "KVList.h"
#include "KVUniqueNameList.h"
#include "KVDataRepositoryImpl.h"
 
class TFile;
 
class KVDataRepository: public KVBase {
 
   TString fLocalrootdir;
   TString fAccessprotocol = "local";
   TString fReadprotocol = "local";
   TString fXrootdserver;
   TString fXrootdrootdir;
   TString fRfioserver;
   TString fRfiorootdir;
   TString fAccessroot;
   TString fReadroot;
   TString fTransfertype;
   TString fTransferExec;
   TString fTransferserver;
   TString fTransferuser;
   Bool_t fCanWrite = kTRUE; //kTRUE if new files can be created and written directly in the repository; kFALSE if they have to be written locally then copied to repository
 
   void SetFullPath(TString& path, const TString& protocol);
 
   struct PathConcatenator {
      TString root_dir;
      PathConcatenator(const TString& _root) : root_dir{_root} {}
      TString get_full_path() const
      {
         return root_dir;
      }
      template<typename... Strings>
      TString get_full_path(const TString& path, const Strings& ... others)
      {
         if (!path.IsNull()) {
            TString tmp;
            AssignAndDelete(tmp, gSystem->ConcatFileName(root_dir, path));
            root_dir = tmp;
         }
         return get_full_path(others...);
      }
      template<typename ExistCheck, typename MakeDir>
      void ensure_full_path_exists(ExistCheck, MakeDir) const {}
      template<typename ExistCheck, typename MakeDir, typename... Strings>
      void ensure_full_path_exists(ExistCheck ec, MakeDir md, const TString& path, const Strings& ... others)
      {
         if (!path.IsNull()) {
            TString tmp;
            AssignAndDelete(tmp, gSystem->ConcatFileName(root_dir, path));
            root_dir = tmp;
            if (!ec(root_dir))
               md(root_dir);
         }
         ensure_full_path_exists(ec, md, others...);
      }
   };
   template<typename... Paths>
   TString get_path_with_access_root(const Paths& ... paths) const
   {
      PathConcatenator pc{fAccessroot};
      auto tmp = pc.get_full_path(paths...);
      gSystem->ExpandPathName(tmp);
      return tmp;
   }
   template<typename... Paths>
   TString get_path_with_read_root(const Paths& ... paths) const
   {
      PathConcatenator pc{fReadroot};
      auto tmp = pc.get_full_path(paths...);
      gSystem->ExpandPathName(tmp);
      return tmp;
   }
   template<typename... Paths>
   TString get_path_with_arbitrary_root(const TString& arb_root, const Paths& ... paths) const
   {
      PathConcatenator pc{arb_root};
      auto tmp = pc.get_full_path(paths...);
      gSystem->ExpandPathName(tmp);
      return tmp;
   }
 
protected:
   std::unique_ptr<KVDataRepositoryImpl> _impl;
   void set_impl_backend(const TString& impl_type);
   template<typename... Paths>
   void CreateAllNeededSubdirectories(const TString& path1, const Paths& ... paths) const
   {
      auto check_path = [&](TString & p) {
         gSystem->ExpandPathName(p);
         return _impl->check_path_exists(p);
      };
      auto mkdir = [&](TString & p) {
         gSystem->ExpandPathName(p);
         _impl->make_directory(p);
      };
 
      PathConcatenator pc{fAccessroot};
      pc.ensure_full_path_exists(check_path, mkdir, path1, paths...);
   }
   void CreateAllNeededSubdirectories() const {}
 
public:
   KVDataRepository();
   KVDataRepository(const TString& name, const TString& root_dir, const TString& access_backend = "local");
 
   void ReadWithXrootd(const TString& server, const TString& rootdir);
   const Char_t* GetType() const override
   {
      return _impl->GetType();
   }
   virtual Bool_t Init();
   template<typename... Paths>
   Bool_t CheckSubdirExists(const TString& path1, const Paths& ... paths) const
   {
      return _impl->check_path_exists(get_path_with_access_root(path1, paths...));
   }
   template<typename... Paths>
   std::optional<FileStat_t> GetFileInfo(const TString& filename, const Paths& ... paths) const
   {
      FileStat_t fs;
      if (_impl->GetPathInfo(get_path_with_access_root(paths..., filename), fs))
         return fs;
      return std::nullopt;
   }
   template<typename... Paths>
   Bool_t CheckFileStatus(const TString& filename, const Paths& ... paths) const
   {
      return _impl->check_path_exists(get_path_with_access_root(paths..., filename));
   }
 
   template<typename... Paths>
   TString GetRepositoryPath(const Paths& ... paths) const
   {
 
      auto tp = get_path_with_arbitrary_root("/tmp", paths...);
      tp.Remove(0, 5);
      return tp;
   }
   template<typename... Paths>
   TString GetFullPathToOpenFile(const TString& filename, const Paths& ... paths) const
   {
 
      if (_impl->look_for_files_downloaded_to_temp_dir()) {
         return get_path_with_arbitrary_root(TString(gSystem->TempDirectory()), filename);
      }
      return get_path_with_read_root(paths..., filename);
   }
 
   template<typename... Paths>
   TString GetFullPathToTransferFile(const TString& filename, const Paths& ... paths) const
   {
 
      return get_path_with_arbitrary_root(fLocalrootdir, paths..., filename);
   }
   Bool_t CanWrite() const
   {
      return fCanWrite;
   }
   void SetCanWrite(Bool_t yes = kTRUE)
   {
      fCanWrite = yes;
   }
 
   template<typename... Paths>
   KVUniqueNameList GetDirectoryListing(const Paths& ... paths) const
   {
 
      return _impl->get_directory_listing(get_path_with_access_root(paths...));
   }
   template<typename... Paths>
   void CopyFileFromRepository(const TString& filename, const TString& destination, const Paths& ... paths) const
   {
      if (CheckFileStatus(filename, paths...)) {
         auto path = get_path_with_access_root(paths..., filename);
         _impl->copy_file_from(path, destination);
      }
   }
   template<typename... Paths>
   int CopyFileToRepository(const TString& filename, const TString& source, const Paths& ... paths) const
   {
 
      CreateAllNeededSubdirectories(paths...);
      auto path = get_path_with_access_root(paths..., filename);
      auto status = _impl->copy_file_to(source, path);
      if (status == 0) {
         _impl->Chmod(path, 0664);
      }
      else {
         Error("CopyFileToRepository", "Problem copying file %s to repository (status=%d)",
               source.Data(), status);
      }
      return status;
   }
   template<typename... Paths>
   TFile* CreateNewFile(const TString& filename, const Paths& ... paths) const
   {
 
      std::cout << "CreateNewFile : " << filename << std::endl;
      if (!CanWrite()) {
         return new TFile(filename, "recreate");
      }
      CreateAllNeededSubdirectories(paths...);
      return new TFile(GetFullPathToOpenFile(filename, paths...), "recreate");
   }
   template<typename... Paths>
   void CommitFile(TFile* file, const Paths& ... paths)
   {
      TString CommitFileName = file->GetName();
      delete file;
 
      if (CanWrite()) {           //all we have to do for repositories in which files can be written directly
         return;
      }
 
      CreateAllNeededSubdirectories(paths...);
 
      std::cout << std::endl << "Copying file " << CommitFileName << " to repository" << std::endl;
 
      auto s = get_path_with_arbitrary_root(gSystem->pwd(), CommitFileName);
 
      CopyFileToRepository(CommitFileName, s, paths...);
      gSystem->Unlink(CommitFileName);
   }
   template<typename... Paths>
   void MakeSubdirectory(const TString& path1, const Paths& ... paths) const
   {
 
      _impl->make_directory(get_path_with_access_root(path1, paths...));
   }
   template<typename... Paths>
   void DeleteFile(const TString& filename, Bool_t confirm, const Paths& ... paths) const
   {
 
      auto tmp = get_path_with_access_root(paths...);
      auto path = get_path_with_arbitrary_root(tmp, filename);
      std::cout << "Deleting file from repository: " << filename << std::endl;
      if (confirm) {
         std::cout <<
                   "Are you sure you want to delete this file permanently ? (y/n)"
                   << std::endl;
         TString answer;
         std::cin >> answer;
         answer.ToUpper();
         if (!answer.BeginsWith("Y")) {
            std::cout << "File not deleted" << std::endl;
            return;
         }
      }
      _impl->delete_file(path);
   }
   template<typename... Paths>
   TObject* OpenFile(const TString& filename, const std::function<TObject*(const TString&)>& open_file, const Paths& ... paths)
   {
 
      auto path = GetFullPathToOpenFile(filename, paths...);
      if (_impl->look_for_files_downloaded_to_temp_dir()) {
         if (gSystem->AccessPathName(path)) {
            CopyFileFromRepository(filename, path, paths...);
         }
      }
      return open_file(path);
   }
   template<typename... Paths>
   TFile* OpenROOTFile(const TString& filename, const Paths& ... paths)
   {
 
      auto open_file = [](const TString & f) {
         return TFile::Open(f);
      };
      return dynamic_cast<TFile*>(OpenFile(filename, open_file, paths...));
   }
 
   void Print(Option_t* opt = "") const override;
   TString GetFileTransferType() const
   {
      return fTransfertype;
   }
   TString GetFileTransferExec() const
   {
      return fTransferExec;
   }
   TString GetFileTransferServer() const
   {
      return fTransferserver;
   }
   TString GetFileTransferUser() const
   {
      return fTransferuser;
   }
   TString GetRootDirectory() const
   {
      return fLocalrootdir;
   }
 
   virtual void cd();
 
   ClassDefOverride(KVDataRepository, 0)       //Base class handling files in data repository
};
 
R__EXTERN KVDataRepository* gDataRepository;
 
#ifdef __CCIN2P3_RFIO
#include "TRFIOFile.h"
class KVRFIOSystem : public TRFIOSystem {
public:
   KVRFIOSystem(): TRFIOSystem() { };
   virtual ~KVRFIOSystem() { };
 
   Int_t       Unlink(const char* path);
   int             Chmod(const char* file, UInt_t mode);
 
   ClassDef(KVRFIOSystem, 0) // TRFIOSystem with fully-functioning Unlink and Chmod methods
};
#endif
#endif