l4/pkg/python/contrib/Demo/pdist/cvslock.py

   1 """CVS locking algorithm.
   2
   3 CVS locking strategy
   4 ====================
   5
   6 As reverse engineered from the CVS 1.3 sources (file lock.c):
   7
   8 - Locking is done on a per repository basis (but a process can hold
   9 write locks for multiple directories); all lock files are placed in
  10 the repository and have names beginning with "#cvs.".
  11
  12 - Before even attempting to lock, a file "#cvs.tfl.<pid>" is created
  13 (and removed again), to test that we can write the repository.  [The
  14 algorithm can still be fooled (1) if the repository's mode is changed
  15 while attempting to lock; (2) if this file exists and is writable but
  16 the directory is not.]
  17
  18 - While creating the actual read/write lock files (which may exist for
  19 a long time), a "meta-lock" is held.  The meta-lock is a directory
  20 named "#cvs.lock" in the repository.  The meta-lock is also held while
  21 a write lock is held.
  22
  23 - To set a read lock:
  24
  25         - acquire the meta-lock
  26         - create the file "#cvs.rfl.<pid>"
  27         - release the meta-lock
  28
  29 - To set a write lock:
  30
  31         - acquire the meta-lock
  32         - check that there are no files called "#cvs.rfl.*"
  33                 - if there are, release the meta-lock, sleep, try again
  34         - create the file "#cvs.wfl.<pid>"
  35
  36 - To release a write lock:
  37
  38         - remove the file "#cvs.wfl.<pid>"
  39         - rmdir the meta-lock
  40
  41 - To release a read lock:
  42
  43         - remove the file "#cvs.rfl.<pid>"
  44
  45
  46 Additional notes
  47 ----------------
  48
  49 - A process should read-lock at most one repository at a time.
  50
  51 - A process may write-lock as many repositories as it wishes (to avoid
  52 deadlocks, I presume it should always lock them top-down in the
  53 directory hierarchy).
  54
  55 - A process should make sure it removes all its lock files and
  56 directories when it crashes.
  57
  58 - Limitation: one user id should not be committing files into the same
  59 repository at the same time.
  60
  61
  62 Turn this into Python code
  63 --------------------------
  64
  65 rl = ReadLock(repository, waittime)
  66
  67 wl = WriteLock(repository, waittime)
  68
  69 list = MultipleWriteLock([repository1, repository2, ...], waittime)
  70
  71 """
  72
  73
  74 import os
  75 import time
  76 import stat
  77 import pwd
  78
  79
  80 # Default wait time
  81 DELAY = 10
  82
  83
  84 # XXX This should be the same on all Unix versions
  85 EEXIST = 17
  86
  87
  88 # Files used for locking (must match cvs.h in the CVS sources)
  89 CVSLCK = "#cvs.lck"
  90 CVSRFL = "#cvs.rfl."
  91 CVSWFL = "#cvs.wfl."
  92
  93
  94 class Error:
  95
  96     def __init__(self, msg):
  97         self.msg = msg
  98
  99     def __repr__(self):
 100         return repr(self.msg)
 101
 102     def __str__(self):
 103         return str(self.msg)
 104
 105
 106 class Locked(Error):
 107     pass
 108
 109
 110 class Lock:
 111
 112     def __init__(self, repository = ".", delay = DELAY):
 113         self.repository = repository
 114         self.delay = delay
 115         self.lockdir = None
 116         self.lockfile = None
 117         pid = repr(os.getpid())
 118         self.cvslck = self.join(CVSLCK)
 119         self.cvsrfl = self.join(CVSRFL + pid)
 120         self.cvswfl = self.join(CVSWFL + pid)
 121
 122     def __del__(self):
 123         print "__del__"
 124         self.unlock()
 125
 126     def setlockdir(self):
 127         while 1:
 128             try:
 129                 self.lockdir = self.cvslck
 130                 os.mkdir(self.cvslck, 0777)
 131                 return
 132             except os.error, msg:
 133                 self.lockdir = None
 134                 if msg[0] == EEXIST:
 135                     try:
 136                         st = os.stat(self.cvslck)
 137                     except os.error:
 138                         continue
 139                     self.sleep(st)
 140                     continue
 141                 raise Error("failed to lock %s: %s" % (
 142                         self.repository, msg))
 143
 144     def unlock(self):
 145         self.unlockfile()
 146         self.unlockdir()
 147
 148     def unlockfile(self):
 149         if self.lockfile:
 150             print "unlink", self.lockfile
 151             try:
 152                 os.unlink(self.lockfile)
 153             except os.error:
 154                 pass
 155             self.lockfile = None
 156
 157     def unlockdir(self):
 158         if self.lockdir:
 159             print "rmdir", self.lockdir
 160             try:
 161                 os.rmdir(self.lockdir)
 162             except os.error:
 163                 pass
 164             self.lockdir = None
 165
 166     def sleep(self, st):
 167         sleep(st, self.repository, self.delay)
 168
 169     def join(self, name):
 170         return os.path.join(self.repository, name)
 171
 172
 173 def sleep(st, repository, delay):
 174     if delay <= 0:
 175         raise Locked(st)
 176     uid = st[stat.ST_UID]
 177     try:
 178         pwent = pwd.getpwuid(uid)
 179         user = pwent[0]
 180     except KeyError:
 181         user = "uid %d" % uid
 182     print "[%s]" % time.ctime(time.time())[11:19],
 183     print "Waiting for %s's lock in" % user, repository
 184     time.sleep(delay)
 185
 186
 187 class ReadLock(Lock):
 188
 189     def __init__(self, repository, delay = DELAY):
 190         Lock.__init__(self, repository, delay)
 191         ok = 0
 192         try:
 193             self.setlockdir()
 194             self.lockfile = self.cvsrfl
 195             fp = open(self.lockfile, 'w')
 196             fp.close()
 197             ok = 1
 198         finally:
 199             if not ok:
 200                 self.unlockfile()
 201             self.unlockdir()
 202
 203
 204 class WriteLock(Lock):
 205
 206     def __init__(self, repository, delay = DELAY):
 207         Lock.__init__(self, repository, delay)
 208         self.setlockdir()
 209         while 1:
 210             uid = self.readers_exist()
 211             if not uid:
 212                 break
 213             self.unlockdir()
 214             self.sleep(uid)
 215         self.lockfile = self.cvswfl
 216         fp = open(self.lockfile, 'w')
 217         fp.close()
 218
 219     def readers_exist(self):
 220         n = len(CVSRFL)
 221         for name in os.listdir(self.repository):
 222             if name[:n] == CVSRFL:
 223                 try:
 224                     st = os.stat(self.join(name))
 225                 except os.error:
 226                     continue
 227                 return st
 228         return None
 229
 230
 231 def MultipleWriteLock(repositories, delay = DELAY):
 232     while 1:
 233         locks = []
 234         for r in repositories:
 235             try:
 236                 locks.append(WriteLock(r, 0))
 237             except Locked, instance:
 238                 del locks
 239                 break
 240         else:
 241             break
 242         sleep(instance.msg, r, delay)
 243     return list
 244
 245
 246 def test():
 247     import sys
 248     if sys.argv[1:]:
 249         repository = sys.argv[1]
 250     else:
 251         repository = "."
 252     rl = None
 253     wl = None
 254     try:
 255         print "attempting write lock ..."
 256         wl = WriteLock(repository)
 257         print "got it."
 258         wl.unlock()
 259         print "attempting read lock ..."
 260         rl = ReadLock(repository)
 261         print "got it."
 262         rl.unlock()
 263     finally:
 264         print [1]
 265         sys.exc_traceback = None
 266         print [2]
 267         if rl:
 268             rl.unlock()
 269         print [3]
 270         if wl:
 271             wl.unlock()
 272         print [4]
 273         rl = None
 274         print [5]
 275         wl = None
 276         print [6]
 277
 278
 279 if __name__ == '__main__':
 280     test()