FM / pdist

/usr/lib64/python2.6/Demo/pdist

Name	Size	Mode	Actions
client.py	4708	0644	edit dl rm
client.pyc	6769	0644	edit dl rm
client.pyo	6769	0644	edit dl rm
cmdfw.py	4641	0644	edit dl rm
cmdfw.pyc	5276	0644	edit dl rm
cmdfw.pyo	5276	0644	edit dl rm
cmptree.py	5778	0644	edit dl rm
cmptree.pyc	6189	0644	edit dl rm
cmptree.pyo	6189	0644	edit dl rm
cvslib.py	10175	0644	edit dl rm
cvslib.pyc	13240	0644	edit dl rm
cvslib.pyo	13240	0644	edit dl rm
cvslock.py	6771	0644	edit dl rm
cvslock.pyc	8597	0644	edit dl rm
cvslock.pyo	8597	0644	edit dl rm
FSProxy.py	8469	0644	edit dl rm
FSProxy.pyc	13360	0644	edit dl rm
FSProxy.pyo	13360	0644	edit dl rm
mac.py	352	0644	edit dl rm
mac.pyc	603	0644	edit dl rm
mac.pyo	603	0644	edit dl rm
makechangelog.py	2992	0755	edit dl rm
makechangelog.pyc	3156	0644	edit dl rm
makechangelog.pyo	3156	0644	edit dl rm
rcsbump	742	0755	edit dl rm
rcsclient.py	1803	0644	edit dl rm
rcsclient.pyc	2128	0644	edit dl rm
rcsclient.pyo	2128	0644	edit dl rm
rcslib.py	10318	0644	edit dl rm
rcslib.pyc	11613	0644	edit dl rm
rcslib.pyo	11613	0644	edit dl rm
RCSProxy.py	4727	0755	edit dl rm
RCSProxy.pyc	7786	0644	edit dl rm
RCSProxy.pyo	7786	0644	edit dl rm
rcvs	114	0755	edit dl rm
rcvs.py	13648	0755	edit dl rm
rcvs.pyc	14581	0644	edit dl rm
rcvs.pyo	14581	0644	edit dl rm
README	4264	0644	edit dl rm
rrcs	114	0755	edit dl rm
rrcs.py	3996	0755	edit dl rm
rrcs.pyc	5670	0644	edit dl rm
rrcs.pyo	5670	0644	edit dl rm
security.py	1092	0644	edit dl rm
security.pyc	1693	0644	edit dl rm
security.pyo	1693	0644	edit dl rm
server.py	4581	0644	edit dl rm
server.pyc	6033	0644	edit dl rm
server.pyo	6033	0644	edit dl rm
sumtree.py	518	0644	edit dl rm
sumtree.pyc	905	0644	edit dl rm
sumtree.pyo	905	0644	edit dl rm

Edit: /usr/lib64/python2.6/Demo/pdist/cvslock.py (6771B)

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

cmd: