Helper class for locking a file. More...

#include <FileSystem.h>

Public Member Functions
	Lock (const std::string &fileName, bool readonly=false)
	Construct a Lock object for the given file.

	~Lock ()
	Destructor.

bool	lock (int timeout=300, bool ignoreErrors=false)
	Try to lock the file.

Private Attributes
int	m_file
	File descriptor of file to be locked.

bool	m_readOnly
	if this is a read-only lock (multiple processes can hold one).

Detailed Description

Helper class for locking a file.

Definition at line 97 of file FileSystem.h.

Constructor & Destructor Documentation

◆ Lock()

Lock	(	const std::string &	fileName,
		bool	readonly = false )

explicit

Construct a Lock object for the given file.

Parameters

fileName	Name of the file to be locked (if it does not exist, it will be created)
readonly	create a read-only lock (multiple processes can hold one)

Definition at line 185 of file FileSystem.cc.

                                                             :
  m_readOnly(readonly)
{
  const int mode = readonly ? O_RDONLY : O_RDWR;
  m_file = open(fileName.c_str(), mode | O_CREAT, 0640);
}

◆ ~Lock()

~Lock ( )

Destructor.

Releases the lock

Definition at line 192 of file FileSystem.cc.

{
  if (m_file >= 0) close(m_file);
}

Member Function Documentation

◆ lock()

bool lock	(	int	timeout = 300,
		bool	ignoreErrors = false )

Try to lock the file.

Note: Locks are not exclusive inside the same process, i.e. lock() will succeed even if a lock is already held by the current process.

Parameters

timeout	Time in seconds to wait for a lock (default is rather high to deal with slow FS at KEKCC)
ignoreErrors	if true just return if locking was unsuccessful but don't print an error

Returns: True if the lock could be obtained, false if file could not be opened or timeout is reached

Definition at line 197 of file FileSystem.cc.

{
  if (m_file < 0) return false;
 
  auto const maxtime = std::chrono::steady_clock::now() + std::chrono::seconds(timeout);
  std::default_random_engine random;
  std::uniform_int_distribution<int> uniform(1, 100);
 
  /* Note:
   * Previously, this used flock(), which doesn't work with GPFS.
   * fcntl() does, and also should be more likely to work on NFS.
   * If you use the 'nolock' mount option to NFS, you are on your own.
   */
  struct flock fl;
  memset(&fl, '\0', sizeof(fl));
  fl.l_type = m_readOnly ? F_RDLCK : F_WRLCK;
  //lock entire file
  fl.l_whence = SEEK_SET;
  fl.l_start = 0;
  fl.l_len = 0;
 
  while (true) {
    int lock = fcntl(m_file, F_SETLK, &fl);
    if (lock == 0)
      return true;
    else if (std::chrono::steady_clock::now() > maxtime)
      break;
    if (errno != EAGAIN && errno != EACCES && errno != EINTR) break;
    usleep(uniform(random) * 1000);
  }
  if (!ignoreErrors) B2ERROR("Locking failed: " << strerror(errno));
  return false;
}

Member Data Documentation

◆ m_file

int m_file

private

File descriptor of file to be locked.

Definition at line 123 of file FileSystem.h.

◆ m_readOnly

bool m_readOnly

private

if this is a read-only lock (multiple processes can hold one).

Definition at line 124 of file FileSystem.h.

The documentation for this class was generated from the following files:

framework/utilities/include/FileSystem.h
framework/utilities/src/FileSystem.cc

Public Member Functions

Private Attributes