KVDataRepository.cpp

/*
$Id: KVDataRepository.cpp,v 1.21 2009/01/16 14:55:20 franklan Exp $
$Revision: 1.21 $
$Date: 2009/01/16 14:55:20 $
*/
 
//Created by KVClassFactory on Wed Apr 26 16:17:37 2006
//Author: franklan
 
#include "KVDataRepository.h"
#include "KVDataRepositoryImpl.h"
#include "KVBase.h"
#include "KVList.h"
#include "TError.h"
#include "Riostream.h"
#include "TObjString.h"
#include "TFile.h"
#include "TOrdCollection.h"
#include "TRegexp.h"
#include "TPluginManager.h"
#include "TROOT.h"
#include "KVConfig.h"
#include <TClass.h>
#include <TMethodCall.h>
 
using namespace std;
 
ClassImp(KVDataRepository)
 
KVDataRepository* gDataRepository = nullptr;
 
//___________________________________________________________________________
 
 
 
void KVDataRepository::cd()
{
   //Make this the 'active' or 'default' data repository,
   //i.e. gDataRepository points to this
   gDataRepository = this;
}
 
 
 
 
 
Bool_t KVDataRepository::Init()
{
   //Initialises data repository based on information in .kvrootrc file.
   //Each line beginning "name.DataRepository" is used for this data repository,
   //where "name" is the name of this repository.
   //
   //Then we create and initialise the data set manager for this repository.
   //
   //returns kTRUE if all goes well.
   //returns kFALSE if not (i.e. data set manager cannot be initialised, no available datasets)
 
   fLocalrootdir =
      gEnv->GetValue(Form("%s.DataRepository.RootDir", GetName()), "");
   if (fLocalrootdir == "") {
      Error("Init", "Top-level directory for repository %s is not defined. Set %s.DataRepository.RootDir variable in .kvrootrc",
            GetName(), GetName());
      return kFALSE;
   }
   fAccessprotocol =
      gEnv->GetValue(Form("%s.DataRepository.AccessProtocol", GetName()),
                     "local");
   fReadprotocol =
      gEnv->GetValue(Form("%s.DataRepository.ReadProtocol", GetName()),
                     "local");
   _impl->SetReadProtocol(fReadprotocol);
   //can we create and write directly new files in the repository ?
   //for local repositories, default is yes, unless 'DataRepository.CanWrite' = 'NO'
   fCanWrite = (Bool_t)gEnv->GetValue(Form("%s.DataRepository.CanWrite", GetName()), kTRUE);
   //xrootd protocol
   fXrootdserver =
      gEnv->GetValue(Form("%s.DataRepository.XRDServer", GetName()), "");
   fXrootdrootdir =
      gEnv->GetValue(Form("%s.DataRepository.XRDRootDir", GetName()), "");
 
   //rfio protocol
   fRfioserver =
      gEnv->GetValue(Form("%s.DataRepository.RFIOServer", GetName()), "");
   fRfiorootdir =
      gEnv->GetValue(Form("%s.DataRepository.RFIORootDir", GetName()),
                     "");
   //file transfer protocol
   fTransfertype =
      gEnv->
      GetValue(Form("%s.DataRepository.FileTransfer.type", GetName()),
               "sftp");
   if (fTransfertype.Contains("bbftp")) {
      fTransferExec = fTransfertype;
      fTransfertype = "bbftp";
      if (!KVBase::FindExecutable(fTransferExec)) {
         Error("Init", "Executable for bbftp client not found. Check %s.DataRepository.FileTransfer.type",
               GetName());
      }
   }
   else if (fTransfertype.Contains("sftp")) {
      fTransferExec = fTransfertype;
      fTransfertype = "sftp";
      if (!KVBase::FindExecutable(fTransferExec)) {
         fTransferExec = "";
      }
   }
   else if (fTransfertype.Contains("root")) {
      fTransferExec = "root";
      fTransfertype = "xrd";
   }
   fTransferserver =
      gEnv->
      GetValue(Form("%s.DataRepository.FileTransfer.server", GetName()),
               "");
   fTransferuser = gEnv->GetValue(Form("%s.DataRepository.FileTransfer.user", GetName()), "");  //if not given, we use current username
   if (fTransferuser == "") {
      UserGroup_t* user = gSystem->GetUserInfo();
      fTransferuser = user->fUser;
   }
   //set full paths to be used for checking existence of files and for opening files
   SetFullPath(fAccessroot, fAccessprotocol);
   SetFullPath(fReadroot, fReadprotocol);
 
   return kTRUE;
}
 
 
 
 
void KVDataRepository::Print(Option_t*) const
{
   //Print info on repository
   Info("Print", "configuration of repository is as follows - ");
   cout << "\tname = " << GetName() << endl;
   cout << "\tRootDir = " << fLocalrootdir.Data() << endl;
   cout << "\tAccessProtocol = " << fAccessprotocol.Data() << endl;
   cout << "\tAccessRootDir = " << fAccessroot.Data() << endl;
   cout << "\tReadProtocol = " << fReadprotocol.Data() << endl;
   cout << "\tReadRootDir = " << fReadroot.Data() << endl;
   cout << "\tCanWrite = " << fCanWrite << endl;
   cout << "\tXRDServer = " << fXrootdserver.Data() << endl;
   cout << "\tXRDRootDir = " << fXrootdrootdir.Data() << endl;
   cout << "\tRFIOServer = " << fRfioserver.Data() << endl;
   cout << "\tRFIORootDir = " << fRfiorootdir.Data() << endl;
   cout << "\tTransferType = " << fTransfertype.Data() << endl;
   cout << "\tTransferServer = " << fTransferserver.Data() << endl;
   cout << "\tTransferUser = " << fTransferuser.Data() << endl;
}
 
 
 
 
 
KVDataRepository::KVDataRepository()
{
   //Default constructor
   SetType("local");
}
 
 
 
 
KVDataRepository::KVDataRepository(const TString& name, const TString& root_dir, const TString& access_backend)
   : KVBase(name), fLocalrootdir{root_dir}
{
   // Create a new data repository with characteristics given by argument values
   //
   // \param[in] name name of repository
   // \param[in] root_dir full path to root directory of data repository
   // \param[in] access_backend protocol to access repository. Can be "local" (default), or "irods"
 
   fLocalrootdir = root_dir;
   set_impl_backend(access_backend);
   //set full paths to be used for checking existence of files and for opening files
   SetFullPath(fAccessroot, fAccessprotocol);
   SetFullPath(fReadroot, fReadprotocol);
}
 
 
 
 
void KVDataRepository::ReadWithXrootd(const TString& server, const TString& rootdir)
{
   // Call this method if you can read files in the repository using an xrootd server.
   //
   // \param[in] server complete URL of xrootd server (without any network transport specification i.e. 'root://', 'https://', etc.)
   // \param[in] rootdir the full path of the root directory used to access the repository through the xrootd server (replaces root directory given to constructor)
 
   fXrootdserver = server;
   fXrootdrootdir = rootdir;
   fReadprotocol = "root";
   SetFullPath(fReadroot, fReadprotocol);
   _impl->SetReadProtocol("root");
}
 
 
 
 
void KVDataRepository::SetFullPath(TString& path, const TString& tmp)
{
   //Will replace contents of 'path' with the full base path needed for the given protocol:
   //  + protocol = "local" :  `path = fLocalrootdir`
   //  + protocol = "root" :   `path = "root://" + fXrootdserver + "/" + fXrootdrootdir`
   //  + protocol = "rfio" :   `path = "rfio:" + fRfioserver + ":" + fRfiorootdir`
 
   if (tmp == "local")
      path = fLocalrootdir;
   else if (tmp == "root")
      path.Form("root://%s/%s", fXrootdserver.Data(),
                fXrootdrootdir.Data());
   else if (tmp == "rfio")
      path.Form("rfio:%s:%s", fRfioserver.Data(), fRfiorootdir.Data());
   else
      Warning("SetFullPath",
              "Unknown protocol in call to SetFullPath : %s", tmp.Data());
}
 
 
 
 
void KVDataRepository::set_impl_backend(const TString& impl_type)
{
   // Initialises the back-end used to access/interrogate the repository, accessed
   // through member pointer std::unique_ptr<KVDataRepositoryImpl> _impl
   //
   // \param[in] impl_type type of back-end. can be "local" (repository on local disk) or "irods" (access through iRODs client)
   //
   // if impl_type!="local", we set CanWrite() = false
 
   auto ph = KVBase::LoadPlugin("KVDataRepositoryImpl", impl_type);
   //execute constructor/macro for plugin
   _impl.reset(((KVDataRepositoryImpl*) ph->ExecPlugin(0)));
   if (impl_type != "local") SetCanWrite(false);
}
 
 
#ifdef __CCIN2P3_RFIO
 
ClassImp(KVRFIOSystem)
 
//This class corrects a bug in TRFIOSystem::Unlink
//and adds a fully-functioning Chmod method and
//CopyFile which can handle either or both of source
//and target file being accessed via rfiod (the other is
//assumed to be on the local filesystem).
 
 
 
extern "C" {
   FILE*   rfio_fopen(const char* path, const char* mode);
   int     rfio_fclose(FILE* s);
   int     rfio_fread(void* buffer, size_t size, size_t count, FILE* stream);
   int     rfio_fwrite(const void* buffer, size_t size, size_t count, FILE* stream);
   int     rfio_feof(FILE* stream);
   int     rfio_stat(const char* path, struct stat* statbuf);
   int     rfio_rmdir(const char* path);
   int     rfio_unlink(const char* path);
   int     rfio_chmod(const char* path, mode_t mode);
};
 
 
 
 
 
Int_t KVRFIOSystem::Unlink(const char* path)
{
   // Unlink, i.e. remove, a file or directory. Returns 0 when succesfull,
   // -1 in case of failure.
 
   TUrl url(path);
   struct stat finfo;
   if (rfio_stat(url.GetFile(), &finfo) < 0)
      return -1;
 
   if (R_ISDIR(finfo.st_mode))
      return rfio_rmdir(url.GetFile());
   else
      return rfio_unlink(url.GetFile());
}
 
 
 
 
 
int KVRFIOSystem::Chmod(const char* file, UInt_t mode)
{
   // Set the file permission bits. Returns -1 in case or error, 0 otherwise.
 
   TUrl url(file);
   return rfio_chmod(url.GetFile(), mode);
}
 
 
#endif