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