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