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 "KVBase.h"
#include "TString.h"
#include "TSystem.h"
#include "KVAvailableRunsFile.h"
#include "TEnv.h"
#include "KVList.h"
#include "KVUniqueNameList.h"
class TFile;
class KVDataSet;
class KVDataSetManager;
 
class KVDataRepository: public KVBase {
 
protected:
 
   TString fLocalrootdir;
   TString fAccessprotocol;
   TString fReadprotocol;
   TString fXrootdserver;
   TString fXrootdrootdir;
   Bool_t fXRDtunnel;
   TString fXRDtunHost;
   TString fXRDtunUser;
   TString fXRDtunSpec;
   Int_t fXRDtunRetry;
   Int_t fXRDtunPort;
   TString fRfioserver;
   TString fRfiorootdir;
   TString fAccessroot;
   TString fReadroot;
   TString fTransfertype;
   TString fTransferExec;
   TString fTransferserver;
   TString fTransferuser;
    Bool_t fCanWrite;
    const KVDataSet* fCommitDataSet;
    TString fCommitDataType;
    TString fCommitFileName;
    KVDataSetManager* fDSM;
   void SetFullPath(TString& path, const Char_t* protocol);
   virtual const Char_t* GetReadProtocol(const Char_t* dataset, const Char_t* datatype);
   virtual KVDataSetManager* NewDataSetManager();
 
   virtual int             Chmod(const char* file, UInt_t mode);
   virtual void PrepareXRDTunnel();
 
    TSeqCollection* fHelpers;
   TObject* OpenDataSetFile(const KVDataSet* ds, const Char_t* type, const TString& fname, Option_t* opt = "");
public:
   virtual int  CopyFile(const char* f, const char* t, Bool_t overwrite = kFALSE);
   TSystem*               FindHelper(const char* path, void* dirptr = 0);
   Bool_t            HelperIsConsistentWith(TSystem* helper, const char* path, void* dirptr = 0);
 
   KVDataRepository();
   virtual ~ KVDataRepository();
 
   virtual Bool_t Init();
 
   virtual Bool_t CheckSubdirExists(const Char_t* dir,
                                    const Char_t* subdir = 0);
   virtual Bool_t GetFileInfo(const KVDataSet* dataset,
                              const Char_t* datatype,
                              const Char_t* runfile, FileStat_t& fs) const;
   virtual Bool_t CheckFileStatus(const KVDataSet* dataset,
                                  const Char_t* datatype,
                                  const Char_t* runfile);
 
   virtual const Char_t* GetFullPathToOpenFile(const KVDataSet* dataset,
         const Char_t* datatype,
         const Char_t* runfile);
 
   virtual const Char_t* GetFullPathToTransferFile(const KVDataSet* dataset,
         const Char_t* datatype,
         const Char_t* runfile);
 
   virtual Bool_t IsRemote() const
   {
      return kFALSE;
   };
   virtual Bool_t IsConnected()
   {
      return kTRUE;
   };
   virtual Bool_t CanWrite() const
   {
      return fCanWrite;
   }
   virtual KVUniqueNameList GetDirectoryListing(const KVDataSet* dataset,
         const Char_t* datatype = "", const Char_t* subdir = "");
 
   virtual void CopyFileFromRepository(const KVDataSet* dataset,
                                       const Char_t* datatype,
                                       const Char_t* filename,
                                       const Char_t* destination);
   virtual int CopyFileToRepository(const Char_t* source,
                                    const KVDataSet* dataset,
                                    const Char_t* datatype,
                                    const Char_t* filename);
 
   virtual TFile* CreateNewFile(const KVDataSet* dataset,
                                const Char_t* datatype,
                                const Char_t* filename);
   virtual void CommitFile(TFile* file, const Char_t* datatype, const KVDataSet* dataset);
 
   virtual void MakeSubdirectory(const KVDataSet* dataset,
                                 const Char_t* datatype = "");
 
   virtual void DeleteFile(const KVDataSet* dataset,
                           const Char_t* datatype,
                           const Char_t* filename, Bool_t confirm =
                              kTRUE);
 
   void Print(Option_t* opt = "") const override;
   virtual const Char_t* GetFileTransferType() const
   {
      return fTransfertype;
   };
   virtual const Char_t* GetFileTransferExec() const
   {
      return fTransferExec;
   };
   virtual const Char_t* GetFileTransferServer() const
   {
      return fTransferserver;
   };
   virtual const Char_t* GetFileTransferUser() const
   {
      return fTransferuser;
   };
   virtual const Char_t* GetRootDirectory() const
   {
      return fLocalrootdir;
   };
 
   virtual KVDataSetManager* GetDataSetManager() const;
 
   void cd();
   static KVDataRepository* NewRepository(const Char_t* type);
   virtual KVAvailableRunsFile* NewAvailableRunsFile(const Char_t*, const KVDataSet*);
   virtual TObject* OpenDataSetRunFile(const KVDataSet* ds,
                                       const KVString& type,
                                       const run_index_t& run,
                                       Option_t* opt = "");
   void CreateAllNeededSubdirectories(const KVDataSet* DataSet, const Char_t* DataType);
 
   virtual void PrintAvailableDatasetsUpdateWarning() const
   {
      ;
   }
 
   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