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 = `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()