/usr/include/casacore/casa/IO/FileLocker.h is in casacore-dev 2.2.0-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 | //# FileLocker.h: Class to handle file locking
//# Copyright (C) 1997,1998,1999,2000
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//# Internet email: aips2-request@nrao.edu.
//# Postal address: AIPS++ Project Office
//# National Radio Astronomy Observatory
//# 520 Edgemont Road
//# Charlottesville, VA 22903-2475 USA
//#
//# $Id$
#ifndef CASA_FILELOCKER_H
#define CASA_FILELOCKER_H
//# Includes
#include <casacore/casa/aips.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
//# Forward Declarations
class String;
// <summary>
// Class to handle file locking.
// </summary>
// <use visibility=export>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="tLockFile" demos="">
// </reviewed>
// <prerequisite>
// <li> man page of fcntl
// </prerequisite>
// <synopsis>
// This class handles file locking by means of the fcntl SETLK function.
// Locking of files on NFS-mounted file systems works correctly
// as long as the NFS lockd and statd deamons are configured correctly.
// Otherwise lock requests may be granted incorrectly.
// <p>
// Acquiring a lock can be done for a read or a write lock.
// Multiple locks on a file can exist as long as they are all
// read locks. When a write lock is involved, no other lock can exist.
// It is possible to acquire a lock in 2 ways:
// <ul>
// <li>Wait until the lock request is granted; i.e. until the processes
// holding a lock on the file release their lock.
// <li>Do several attempts; between each attempt it sleeps 1 second.
// Note that nattempts=1 means it returns immediately when the
// lock request could not be granted.
// </ul>
// </synopsis>
// <example>
// <srcblock>
// int fd = open ("file.name");
// FileLocker lock(fd);
// if (lock.acquire()) {
// ... do something with the file ...
// lock.release();
// }else{
// cout << lock.lastMessage() << endl;
// }
// </srcblock>
// </example>
// <motivation>
// Make it possible to lock files in a standard way.
// </motivation>
class FileLocker
{
public:
// Define the possible lock types.
enum LockType {
// Acquire a read lock.
Read,
// Acquire a write lock.
Write
};
// Default constructor creates an invalid fd.
FileLocker();
// Construct the FileLocker object for the given file descriptor.
// This can be used to lock a segment of the given file.
// The segment is given by start and length. Length=0 means till the
// end of the file.
explicit FileLocker (int fd, uInt start=0, uInt length=0);
~FileLocker();
// Acquire a write or read lock.
// <src>nattempts</src> defines how often it tries to acquire the lock.
// A zero value indicates an infinite number of times (i.e. wait until
// the lock is acquired).
// A positive value means it waits 1 second between each attempt.
Bool acquire (LockType = Write, uInt nattempts = 0);
// Release a lock.
// The return status indicates if an error occurred.
Bool release();
// Test if the file can be locked for read or write.
// Optionally the PID of the process holding the lock is returned.
// <group>
Bool canLock (LockType = Write);
Bool canLock (uInt& pid, LockType = Write);
// </group>
// Test if the process has a lock for read or write on the file.
Bool hasLock (LockType = Write) const;
// Get the fd in use.
int fd() const;
// Get the last error.
int lastError() const;
// Get the message belonging to the last error.
String lastMessage() const;
private:
int itsFD;
int itsError;
int itsStart;
int itsLength;
Bool itsMsgShown; /// temporary for SUSE 6.1
Bool itsReadLocked;
Bool itsWriteLocked;
};
inline Bool FileLocker::hasLock (LockType type) const
{
return (type == Write ? itsWriteLocked : itsReadLocked);
}
inline int FileLocker::fd() const
{
return itsFD;
}
inline int FileLocker::lastError() const
{
return itsError;
}
} //# NAMESPACE CASACORE - END
#endif
|