FM / pdist

/usr/lib64/python2.7/Demo/pdist

Name	Size	Mode	Actions
client.py	4708	0644	edit dl rm
client.pyc	6724	0644	edit dl rm
client.pyo	6724	0644	edit dl rm
cmdfw.py	4641	0644	edit dl rm
cmdfw.pyc	5239	0644	edit dl rm
cmdfw.pyo	5239	0644	edit dl rm
cmptree.py	5778	0644	edit dl rm
cmptree.pyc	6123	0644	edit dl rm
cmptree.pyo	6123	0644	edit dl rm
cvslib.py	10175	0644	edit dl rm
cvslib.pyc	13140	0644	edit dl rm
cvslib.pyo	13140	0644	edit dl rm
cvslock.py	6771	0644	edit dl rm
cvslock.pyc	8560	0644	edit dl rm
cvslock.pyo	8560	0644	edit dl rm
FSProxy.py	7828	0644	edit dl rm
FSProxy.pyc	12795	0644	edit dl rm
FSProxy.pyo	12795	0644	edit dl rm
mac.py	352	0644	edit dl rm
mac.pyc	598	0644	edit dl rm
mac.pyo	598	0644	edit dl rm
makechangelog.py	2988	0755	edit dl rm
makechangelog.pyc	3122	0644	edit dl rm
makechangelog.pyo	3122	0644	edit dl rm
rcsbump	745	0755	edit dl rm
rcsclient.py	1803	0644	edit dl rm
rcsclient.pyc	2100	0644	edit dl rm
rcsclient.pyo	2100	0644	edit dl rm
rcslib.py	10318	0644	edit dl rm
rcslib.pyc	11548	0644	edit dl rm
rcslib.pyo	11548	0644	edit dl rm
RCSProxy.py	4723	0755	edit dl rm
RCSProxy.pyc	7751	0644	edit dl rm
RCSProxy.pyo	7751	0644	edit dl rm
rcvs	117	0755	edit dl rm
rcvs.py	13644	0755	edit dl rm
rcvs.pyc	14417	0644	edit dl rm
rcvs.pyo	14417	0644	edit dl rm
README	4264	0644	edit dl rm
rrcs	117	0755	edit dl rm
rrcs.py	3992	0755	edit dl rm
rrcs.pyc	5629	0644	edit dl rm
rrcs.pyo	5629	0644	edit dl rm
security.py	1092	0644	edit dl rm
security.pyc	1681	0644	edit dl rm
security.pyo	1681	0644	edit dl rm
server.py	4581	0644	edit dl rm
server.pyc	5971	0644	edit dl rm
server.pyo	5971	0644	edit dl rm
sumtree.py	518	0644	edit dl rm
sumtree.pyc	903	0644	edit dl rm
sumtree.pyo	903	0644	edit dl rm

Edit: /usr/lib64/python2.7/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: