PerFile.cxx

Go to the documentation of this file.

//
// PerFile
//
// Package: Per (Persistency).
//
// S. Kasahara 11/00
//
// Purpose: This class opens, maintains (e.g. keeps track of number of 
//          clients), and closes a single ROOT file.  It is a helper class 
//          for the PerFileManager class.  The user does not open/close files 
//          directly with the PerFile class, but instead should open 
//          and close files through the singleton PerFileManager class.
//

#include <errno.h>
#include "TNetFile.h"
#include "TSystem.h"
#ifdef HAVE_NO_NETERRORS_HEADER
// pre-2003-08-29 (3.10/00) header
  #include "rootd.h"
#else
  #include "NetErrors.h"
#endif
#include "Persistency/PerFile.h"
#include "MessageService/MsgService.h"

std::ostream& operator<<(std::ostream& ms, const PerFile& fm) {
  return fm.Print(ms);
}

ClassImp(PerFile)

//   Definition of static data members
//   *********************************

CVSID("$Id: PerFile.cxx,v 1.17 2005/09/25 19:25:52 schubert Exp $");


// Definition of methods (alphabetical order)
// ***************************************************

bool PerFile::AddNewClient(Per::EAccessMode accessmode) {
  //
  //  Purpose:  Add new client to the previously opened file if new requested 
  //            accessmode is compatible with the accessmode in which the file
  //            was originally opened. If successful fNumClient is incremented.
  //
  //  Arguments: 
  //    accessmode: enumerated file access mode of type EAccessMode (defined
  //                in Per.h).
  //
  //  Return:    true means client was successfully added to file.
  //             false means new accessmode was incompatible with original
  //             accessmode.
  //
  //  Contact:   S. Kasahara
  // 
  //  Notes: access modes kNew & kRecreate are considered compatible, 
  //         all other mode combinations are considered incompatible.

  bool accessok = false;

  if(fAccessMode == accessmode) {
    accessok = true;
  }
  else {
    if((fAccessMode == Per::kNew || fAccessMode == Per::kRecreate) &&
       (accessmode == Per::kNew || accessmode == Per::kRecreate)) {
        accessok = true;
    }
  }

  if(accessok) fNumClient++;
  return accessok;  
}

UInt_t PerFile::Close(bool kForce) {
  //
  //  Purpose:  Decrement the number of clients to open file, and close
  //            file if number of clients reaches zero.  Argument kForce set
  //            true forces closure of file regardless of number of clients
  //            (default is kForce==false).
  //
  //  Arguments: 
  //    kForce:  bool to force file closure regardless of number of clients.
  //             (by default kForce is set false).
  //
  //  Return:  number of clients of file remaining after method completes.
  //
  //  Contact:   S. Kasahara
  // 

  if (!kForce) {
    if(fNumClient > 0) fNumClient--; // decrement number of clients by one
  }
  else {
    fNumClient=0; // user requested forced file closure.
  }

  if( !fNumClient ) {
    // No clients left, close file
    if (IsOpen()) {
      if (fTFile -> IsWritable()) {
        // Write out Key with name "FileEnd" as final object to file.  
        // This marker is used by a reader of an open file to determine 
        // when a file has actually been closed by the writer.
        TDirectory *savedir = gDirectory;
        fTFile -> cd();  // change to file directory
        TNamed *isend = new TNamed("FileEnd","PerFile End Key");
        isend -> Write(NULL,TObject::kOverwrite);
        delete isend;
        savedir -> cd(); // change back to users directory
      }
      fTFile -> Close();
      delete fTFile;
      fTFile = 0;
    }
  }

  return fNumClient;
}

bool PerFile::HasFileEndKey() const {
  //
  //  Purpose:  Determine if file has been closed by the writer.  This
  //            is determined by the presence or absence of a "FileEnd"
  //            Key.
  //
  //  Arguments: none.
  //
  //  Return:  true if "FileEnd" Key is present, else false.
  //
  //  Contact:   S. Kasahara
  // 
  //  Notes:  This method is used by a reader of an open file to determine 
  //          when that file has actually been closed by the writer.  
  //

  if ( IsOpen() && (fTFile -> Get("FileEnd")) )
    return true;
  else 
    return false;

}

PerFile::PerFile(string fullfilepathname, Per::EAccessMode accessmode):
  fFullFilePathName(fullfilepathname),fAccessMode(accessmode),fTFile(0),
  fNumClient(0),fRemote(false),fErrorCode(Per::kErrSuccess) {
  //
  //  Purpose:  PerFile constructor.  Opens ROOT TFile with requested 
  //            filename and accessmode.  Uses the static TFile::Open
  //            method to open both local and remote files transparently.
  //            User should use PerFile::IsOpen() to check to see if
  //            file was opened successfully.
  //
  //  Arguments: 
  //    fullfilepathname:  full file path name to be opened.  If file is
  //                       remote, must follow protocol as defined in
  //                       the TFile::Open method.  Specifically for remote
  //                       files served by the rootd server daemon, the
  //                       file name is prefaced by "root:" or "roots:" 
  //                       and the node name as in:
  //                       "root://urheim.hep.umn.edu/~minos/filename.dat"
  //                       See the TNetFile class description or  
  //                       http://root.cern.ch/root/NetFile.html for more 
  //                       information on the remote file name format.
  //    accessmode: enumerated access mode of type EAccessMode (defined in
  //                Per.h) in which file is to be opened:  
  //                kRead = open file in read only mode.
  //                kNew = open new file in read/write. If file exists 
  //                       previously, do not overwrite.
  //                kRecreate = same as kNew, but if file exists previously
  //                            overwrite.
  //                kUpdate = open existing file in read/write mode.
  //
  //  Return: n/a.
  //
  //  Notes: Authorization for remote access follows the protocol
  //         discussed in http://root.cern.ch/root/NetFile.html with
  //         useage dependent on how the rootd server was configured on
  //         the remote site.  
  //         One approach, when not using secure authentication, is
  //         to store the username&password required for remote access in
  //         a .netrc file located in the user's home directory.  The format 
  //         for a line in the .netrc file is:
  //         machine <machine name> login <username> password <password>
  //         e.g.
  //         machine urheim.hep.umn.edu login myusername password mypassword
  //                     
  //         If the constructor fails to open the file successfully, 
  //         PerFile::GetErrorCode can be used to determine the reason
  //         for the failure.
  // 
  //  Contact:   S. Kasahara
  // 

  gSystem -> ResetErrno();
  
  // Open File assuming default compression mode.  May want to specify
  // eventually both the compression mode and a job related title.
  // Determine if file is remote
  if ( fullfilepathname.find("root:") == 0 
    || fullfilepathname.find("roots:") == 0 ) {
    fRemote = true;
    // Assumes that user has correctly set up authorization according to
    // instructions in http://root.cern.ch/root/NetFile.html
    // Use of TNetFile is enforced instead of relying on TFile::Open, because
    // TFile::Open defaults to TFile even if the user has specified "root:"
    // if it determines that access is local and parses the file string to
    // determine the local file path.  This does not result in 
    // a correct file path if rootd has been set up for anonymous useage.
    // Update: 9/25/2005, SK/GMI  The TEnv configuration variable
    // "TFile.ForceRemote" is now set true in the PerFileManager, so
    // that TFile::Open can be used in all cases. The old line:
    // fTFile =new TNetFile(fullfilepathname.c_str(),Per::AsString(accessmode),
    //                      "Persistency file");
    // has been replaced by:
    fTFile = TFile::Open(fullfilepathname.c_str(),Per::AsString(accessmode),
                         "Persistency file");
  }
  else {
    fTFile = TFile::Open(fullfilepathname.c_str(),Per::AsString(accessmode),
                         "Persistency file");
  }


  if (fTFile == (TFile*)0 || fTFile -> IsZombie() || !fTFile ->IsOpen()) {
    // File did not open successfully
    MSG("Per", Msg::kInfo) << "Unable to open " << fullfilepathname 
        << " with accessmode " << Per::AsString(accessmode) << endl;
    fErrorCode = Per::kErrFileError;
    if ( fTFile && fRemote ) {
      TNetFile* netfile = dynamic_cast<TNetFile*>(fTFile);
      if (netfile) {
        switch ( netfile -> GetErrorCode() ) {
        case kErrFileExists:
          fErrorCode = Per::kErrFileExists; break;
        case kErrNoFile:
          fErrorCode = Per::kErrFileNotFound; break;
        case kErrNoSpace:
          fErrorCode = Per::kErrFileNoSpace; break;
        default:
          break;
        }
      }
    }
    else if (fTFile) {
      // Local file, determine why file failed to open through system calls
      if (accessmode == Per::kNew &&
          !(gSystem -> AccessPathName(fullfilepathname.c_str(),kFileExists))) {
        // New file failed to open due to existing file of same name
        fErrorCode = Per::kErrFileExists;
      }
      else if (accessmode == Per::kRead &&
         (gSystem -> AccessPathName(fullfilepathname.c_str(),kFileExists))) {
        // File failed to open because it does not exist
        fErrorCode = Per::kErrFileNotFound;
      }
      else {
        switch (fTFile -> GetErrno()) {
          // TFile::TFile runs its own error checking so all file open errors 
          // won't appear in errno
        case ENOSPC:
          fErrorCode = Per::kErrFileNoSpace; break;
        default:
          break;
        }
      }
    }
    if(fTFile) delete fTFile; fTFile = 0;
  }
  else {
    fNumClient++;
    // fRemote is used to describe rootd served files only
    // rootd files that are not closed will not UseCache because
    // of dispatcher service concerns
    if ( !fRemote || HasFileEndKey() ) fTFile->UseCache();
  }
  
}

PerFile::~PerFile() {
  //
  //  Purpose:  PerFile destructor.  Closes ROOT TFile and retrieves
  //            allocated memory.
  //
  //  Contact:   S. Kasahara
  // 

  if (IsOpen()) {
    fTFile -> Close();
    delete fTFile; fTFile = 0;
  }
  fNumClient = 0;

}

std::ostream& PerFile::Print(std::ostream& ms) const {
  //
  //  Purpose:  Print status of file on ostream.
  //
  //  Arguments: ms ostream to display on.
  //
  //  Return:  ostream reference.
  //
  //  Contact:   S. Kasahara
  // 


  ms << (IsRemote() ? "Remote" : "Local") << " File " << fFullFilePathName;
 
  if (IsOpen()) {
    ms << " is open with accessmode " << Per::AsString(fAccessMode) 
       << " and " << fNumClient << " client(s)."<< endl;
  }
  else {
    ms << " was not opened successfully with accessmode " 
       << Per::AsString(fAccessMode) << "."<<endl;
  }

  return ms;

}

---