TLockFile.cxx

Go to the documentation of this file.

// @(#)root/io:$Id$
// Author: Jan Fiete Grosse-Oetringhaus, 04.06.07

/*************************************************************************
 * Copyright (C) 1995-2007, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

/**
\class TLockFile
\ingroup IO

A scoped lock based on files.

The RAAI idiom is used: the constructor blocks until lock is obtained.
Lock is released in the destructor.
Use it in scope-blocks like:
~~~{.cpp}
{
   TLockFile lock("path.to.lock.file");
   // do something you need the lock for
} // lock is automatically released
~~~
*/

#include "TLockFile.h"
#include "TSystem.h"
#include "TFile.h"
#include <time.h>

ClassImp(TLockFile);

////////////////////////////////////////////////////////////////////////////////
/// Default constructor.
///
/// Blocks until lock is obtained.
/// If a lock exists that is older than the given time limit,
/// the file is removed. If timeLimit <= 0, wait for ever.

TLockFile::TLockFile(const char *path, Int_t timeLimit) : fPath(path)
{
   while (1) {
      if (Lock(fPath, timeLimit))
         break;

      if (gDebug > 0)
         Info("TLockFile", "did not aquire lock %s, sleeping...", fPath.Data());
      gSystem->Sleep(1000);
   }
}

////////////////////////////////////////////////////////////////////////////////
/// Destructor. Releases the lock.

TLockFile::~TLockFile()
{
   if (gDebug > 0)
      Info("~TLockFile", "releasing lock %s", fPath.Data());

   gSystem->Unlink(fPath);
}

////////////////////////////////////////////////////////////////////////////////
/// Internal function that locks with the given path.

Bool_t TLockFile::Lock(const char *path, Int_t timeLimit)
{
   Long_t modTime = 0;
   if (gSystem->GetPathInfo(path, 0, (Long_t*) 0, 0, &modTime) == 0) {
      if (timeLimit > 0) {
         if (gDebug > 0)
            Info("Lock", "%s modification time %ld, %ld seconds ago", path, modTime, time(0) - modTime);
         if (time(0) - modTime > timeLimit){
            gSystem->Unlink(path);
            if (gDebug > 0)
               Info("Lock", "time expired, removed %s", path);
         } else
            return kFALSE;
      } else
         return kFALSE;
   }

   TString spath = path;
   spath += "?filetype=raw";
   TFile *file = TFile::Open(spath, "CREATE");
   if (!file)
      return kFALSE;

   file->Close();
   delete file;

   // chance access to 666, so if the lock is expired, other users can remove it
   // (attention, currently only supported for local files systems)
   gSystem->Chmod(path, 0666);

   if (gDebug > 0)
      Info("Lock", "obtained lock %s", path);

   return kTRUE;
}