Edit File: cvslock.py
"""CVS locking algorithm. CVS locking strategy ==================== As reverse engineered from the CVS 1.3 sources (file lock.c): - Locking is done on a per repository basis (but a process can hold write locks for multiple directories); all lock files are placed in the repository and have names beginning with "#cvs.". - Before even attempting to lock, a file "#cvs.tfl.<pid>" is created (and removed again), to test that we can write the repository. [The algorithm can still be fooled (1) if the repository's mode is changed while attempting to lock; (2) if this file exists and is writable but the directory is not.] - While creating the actual read/write lock files (which may exist for a long time), a "meta-lock" is held. The meta-lock is a directory named "#cvs.lock" in the repository. The meta-lock is also held while a write lock is held. - To set a read lock: - acquire the meta-lock - create the file "#cvs.rfl.<pid>" - release the meta-lock - To set a write lock: - acquire the meta-lock - check that there are no files called "#cvs.rfl.*" - if there are, release the meta-lock, sleep, try again - create the file "#cvs.wfl.<pid>" - To release a write lock: - remove the file "#cvs.wfl.<pid>" - rmdir the meta-lock - To release a read lock: - remove the file "#cvs.rfl.<pid>" Additional notes ---------------- - A process should read-lock at most one repository at a time. - A process may write-lock as many repositories as it wishes (to avoid deadlocks, I presume it should always lock them top-down in the directory hierarchy). - A process should make sure it removes all its lock files and directories when it crashes. - Limitation: one user id should not be committing files into the same repository at the same time. Turn this into Python code -------------------------- rl = ReadLock(repository, waittime) wl = WriteLock(repository, waittime) list = MultipleWriteLock([repository1, repository2, ...], waittime) """ import os import time import stat import pwd # Default wait time DELAY = 10 # XXX This should be the same on all Unix versions EEXIST = 17 # Files used for locking (must match cvs.h in the CVS sources) CVSLCK = "#cvs.lck" CVSRFL = "#cvs.rfl." CVSWFL = "#cvs.wfl." class Error: def __init__(self, msg): self.msg = msg def __repr__(self): return repr(self.msg) def __str__(self): return str(self.msg) class Locked(Error): pass class Lock: def __init__(self, repository = ".", delay = DELAY): self.repository = repository self.delay = delay self.lockdir = None self.lockfile = None pid = repr(os.getpid()) self.cvslck = self.join(CVSLCK) self.cvsrfl = self.join(CVSRFL + pid) self.cvswfl = self.join(CVSWFL + pid) def __del__(self): print "__del__" self.unlock() def setlockdir(self): while 1: try: self.lockdir = self.cvslck os.mkdir(self.cvslck, 0777) return except os.error, msg: self.lockdir = None if msg[0] == EEXIST: try: st = os.stat(self.cvslck) except os.error: continue self.sleep(st) continue raise Error("failed to lock %s: %s" % ( self.repository, msg)) def unlock(self): self.unlockfile() self.unlockdir() def unlockfile(self): if self.lockfile: print "unlink", self.lockfile try: os.unlink(self.lockfile) except os.error: pass self.lockfile = None def unlockdir(self): if self.lockdir: print "rmdir", self.lockdir try: os.rmdir(self.lockdir) except os.error: pass self.lockdir = None def sleep(self, st): sleep(st, self.repository, self.delay) def join(self, name): return os.path.join(self.repository, name) def sleep(st, repository, delay): if delay <= 0: raise Locked(st) uid = st[stat.ST_UID] try: pwent = pwd.getpwuid(uid) user = pwent[0] except KeyError: user = "uid %d" % uid print "[%s]" % time.ctime(time.time())[11:19], print "Waiting for %s's lock in" % user, repository time.sleep(delay) class ReadLock(Lock): def __init__(self, repository, delay = DELAY): Lock.__init__(self, repository, delay) ok = 0 try: self.setlockdir() self.lockfile = self.cvsrfl fp = open(self.lockfile, 'w') fp.close() ok = 1 finally: if not ok: self.unlockfile() self.unlockdir() class WriteLock(Lock): def __init__(self, repository, delay = DELAY): Lock.__init__(self, repository, delay) self.setlockdir() while 1: uid = self.readers_exist() if not uid: break self.unlockdir() self.sleep(uid) self.lockfile = self.cvswfl fp = open(self.lockfile, 'w') fp.close() def readers_exist(self): n = len(CVSRFL) for name in os.listdir(self.repository): if name[:n] == CVSRFL: try: st = os.stat(self.join(name)) except os.error: continue return st return None def MultipleWriteLock(repositories, delay = DELAY): while 1: locks = [] for r in repositories: try: locks.append(WriteLock(r, 0)) except Locked, instance: del locks break else: break sleep(instance.msg, r, delay) return list def test(): import sys if sys.argv[1:]: repository = sys.argv[1] else: repository = "." rl = None wl = None try: print "attempting write lock ..." wl = WriteLock(repository) print "got it." wl.unlock() print "attempting read lock ..." rl = ReadLock(repository) print "got it." rl.unlock() finally: print [1] sys.exc_traceback = None print [2] if rl: rl.unlock() print [3] if wl: wl.unlock() print [4] rl = None print [5] wl = None print [6] if __name__ == '__main__': test()