summaryrefslogtreecommitdiffstats
path: root/Demo/pdist
diff options
context:
space:
mode:
authorGuido van Rossum <guido@python.org>1995-06-23 22:03:28 (GMT)
committerGuido van Rossum <guido@python.org>1995-06-23 22:03:28 (GMT)
commit8608ab65e3fd0017302cc831f16eb3d56af45fff (patch)
tree64556d93ac9d824c5754277ea49dae92d2930264 /Demo/pdist
parent72974f35fbe5986f50eeebcb4d958ddee01b036e (diff)
downloadcpython-8608ab65e3fd0017302cc831f16eb3d56af45fff.zip
cpython-8608ab65e3fd0017302cc831f16eb3d56af45fff.tar.gz
cpython-8608ab65e3fd0017302cc831f16eb3d56af45fff.tar.bz2
initial checkin
Diffstat (limited to 'Demo/pdist')
-rwxr-xr-xDemo/pdist/cvslock.py280
1 files changed, 280 insertions, 0 deletions
diff --git a/Demo/pdist/cvslock.py b/Demo/pdist/cvslock.py
new file mode 100755
index 0000000..a421e1a
--- /dev/null
+++ b/Demo/pdist/cvslock.py
@@ -0,0 +1,280 @@
+"""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 = `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()