File Manager

X7ROOT File Manager

Current Path: /lib64/python2.7/Demo/pdist

ðŸ“ ..
ðŸ“„ FSProxy.py(7.64 KB)
ðŸ“„ FSProxy.pyc(12.5 KB)
ðŸ“„ FSProxy.pyo(12.5 KB)
ðŸ“„ RCSProxy.py(4.61 KB)
ðŸ“„ RCSProxy.pyc(7.57 KB)
ðŸ“„ RCSProxy.pyo(7.57 KB)
ðŸ“„ README(4.16 KB)
ðŸ“„ client.py(4.6 KB)
ðŸ“„ client.pyc(6.57 KB)
ðŸ“„ client.pyo(6.57 KB)
ðŸ“„ cmdfw.py(4.53 KB)
ðŸ“„ cmdfw.pyc(5.12 KB)
ðŸ“„ cmdfw.pyo(5.12 KB)
ðŸ“„ cmptree.py(5.64 KB)
ðŸ“„ cmptree.pyc(5.98 KB)
ðŸ“„ cmptree.pyo(5.98 KB)
ðŸ“„ cvslib.py(9.94 KB)
ðŸ“„ cvslib.pyc(12.83 KB)
ðŸ“„ cvslib.pyo(12.83 KB)
ðŸ“„ cvslock.py(6.61 KB)
ðŸ“„ cvslock.pyc(8.36 KB)
ðŸ“„ cvslock.pyo(8.36 KB)
ðŸ“„ mac.py(352 B)
ðŸ“„ mac.pyc(598 B)
ðŸ“„ mac.pyo(598 B)
ðŸ“„ makechangelog.py(2.92 KB)
ðŸ“„ makechangelog.pyc(3.05 KB)
ðŸ“„ makechangelog.pyo(3.05 KB)
ðŸ“„ rcsbump(745 B)
ðŸ“„ rcsclient.py(1.76 KB)
ðŸ“„ rcsclient.pyc(2.05 KB)
ðŸ“„ rcsclient.pyo(2.05 KB)
ðŸ“„ rcslib.py(10.08 KB)
ðŸ“„ rcslib.pyc(11.28 KB)
ðŸ“„ rcslib.pyo(11.28 KB)
ðŸ“„ rcvs(117 B)
ðŸ“„ rcvs.py(13.32 KB)
ðŸ“„ rcvs.pyc(14.08 KB)
ðŸ“„ rcvs.pyo(14.08 KB)
ðŸ“„ rrcs(117 B)
ðŸ“„ rrcs.py(3.9 KB)
ðŸ“„ rrcs.pyc(5.5 KB)
ðŸ“„ rrcs.pyo(5.5 KB)
ðŸ“„ security.py(1.07 KB)
ðŸ“„ security.pyc(1.64 KB)
ðŸ“„ security.pyo(1.64 KB)
ðŸ“„ server.py(4.47 KB)
ðŸ“„ server.pyc(5.83 KB)
ðŸ“„ server.pyo(5.83 KB)
ðŸ“„ sumtree.py(518 B)
ðŸ“„ sumtree.pyc(903 B)
ðŸ“„ sumtree.pyo(903 B)

Editing: cvslock.py

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

X7ROOT File Manager

Editing: cvslock.py

Upload File

Create Folder