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/FSProxy.py (8469B)

"""File System Proxy.

Provide an OS-neutral view on a file system, locally or remotely.
The functionality is geared towards implementing some sort of
rdist-like utility between a Mac and a UNIX system.

The module defines three classes:

FSProxyLocal  -- used for local access
FSProxyServer -- used on the server side of remote access
FSProxyClient -- used on the client side of remote access

The remote classes are instantiated with an IP address and an optional
verbosity flag.
"""

import server
import client
import md5
import os
import fnmatch
from stat import *
import time
import fnmatch

if os.name == 'mac':
    import macfs
    maxnamelen = 31
else:
    macfs = None
    maxnamelen = 255

skipnames = (os.curdir, os.pardir)

class FSProxyLocal:

def __init__(self):
        self._dirstack = []
        self._ignore = ['*.pyc'] + self._readignore()

def _close(self):
        while self._dirstack:
            self.back()

def _readignore(self):
        file = self._hide('ignore')
        try:
            f = open(file)
        except IOError:
            file = self._hide('synctree.ignorefiles')
            try:
                f = open(file)
            except IOError:
                return []
        ignore = []
        while 1:
            line = f.readline()
            if not line: break
            if line[-1] == '\n': line = line[:-1]
            ignore.append(line)
        f.close()
        return ignore

def _hidden(self, name):
        if os.name == 'mac':
            return name[0] == '(' and name[-1] == ')'
        else:
            return name[0] == '.'

def _hide(self, name):
        if os.name == 'mac':
            return '(%s)' % name
        else:
            return '.%s' % name

def visible(self, name):
        if len(name) > maxnamelen: return 0
        if name[-1] == '~': return 0
        if name in skipnames: return 0
        if self._hidden(name): return 0
        head, tail = os.path.split(name)
        if head or not tail: return 0
        if macfs:
            if os.path.exists(name) and not os.path.isdir(name):
                try:
                    fs = macfs.FSSpec(name)
                    c, t = fs.GetCreatorType()
                    if t != 'TEXT': return 0
                except macfs.error, msg:
                    print "***", name, msg
                    return 0
        else:
            if os.path.islink(name): return 0
            if '\0' in open(name, 'rb').read(512): return 0
        for ign in self._ignore:
            if fnmatch.fnmatch(name, ign): return 0
        return 1

def check(self, name):
        if not self.visible(name):
            raise os.error, "protected name %s" % repr(name)

def checkfile(self, name):
        self.check(name)
        if not os.path.isfile(name):
            raise os.error, "not a plain file %s" % repr(name)

def pwd(self):
        return os.getcwd()

def cd(self, name):
        self.check(name)
        save = os.getcwd(), self._ignore
        os.chdir(name)
        self._dirstack.append(save)
        self._ignore = self._ignore + self._readignore()

def back(self):
        if not self._dirstack:
            raise os.error, "empty directory stack"
        dir, ignore = self._dirstack[-1]
        os.chdir(dir)
        del self._dirstack[-1]
        self._ignore = ignore

def _filter(self, files, pat = None):
        if pat:
            def keep(name, pat = pat):
                return fnmatch.fnmatch(name, pat)
            files = filter(keep, files)
        files = filter(self.visible, files)
        files.sort()
        return files

def list(self, pat = None):
        files = os.listdir(os.curdir)
        return self._filter(files, pat)

def listfiles(self, pat = None):
        files = os.listdir(os.curdir)
        files = filter(os.path.isfile, files)
        return self._filter(files, pat)

def listsubdirs(self, pat = None):
        files = os.listdir(os.curdir)
        files = filter(os.path.isdir, files)
        return self._filter(files, pat)

def exists(self, name):
        return self.visible(name) and os.path.exists(name)

def isdir(self, name):
        return self.visible(name) and os.path.isdir(name)

def islink(self, name):
        return self.visible(name) and os.path.islink(name)

def isfile(self, name):
        return self.visible(name) and os.path.isfile(name)

def sum(self, name):
        self.checkfile(name)
        BUFFERSIZE = 1024*8
        f = open(name)
        sum = md5.new()
        while 1:
            buffer = f.read(BUFFERSIZE)
            if not buffer:
                break
            sum.update(buffer)
        return sum.digest()

def size(self, name):
        self.checkfile(name)
        return os.stat(name)[ST_SIZE]

def mtime(self, name):
        self.checkfile(name)
        return time.localtime(os.stat(name)[ST_MTIME])

def stat(self, name):
        self.checkfile(name)
        size = os.stat(name)[ST_SIZE]
        mtime = time.localtime(os.stat(name)[ST_MTIME])
        return size, mtime

def info(self, name):
        sum = self.sum(name)
        size = os.stat(name)[ST_SIZE]
        mtime = time.localtime(os.stat(name)[ST_MTIME])
        return sum, size, mtime

def _list(self, function, list):
        if list is None:
            list = self.listfiles()
        res = []
        for name in list:
            try:
                res.append((name, function(name)))
            except (os.error, IOError):
                res.append((name, None))
        return res

def sumlist(self, list = None):
        return self._list(self.sum, list)

def statlist(self, list = None):
        return self._list(self.stat, list)

def mtimelist(self, list = None):
        return self._list(self.mtime, list)

def sizelist(self, list = None):
        return self._list(self.size, list)

def infolist(self, list = None):
        return self._list(self.info, list)

def _dict(self, function, list):
        if list is None:
            list = self.listfiles()
        dict = {}
        for name in list:
            try:
                dict[name] = function(name)
            except (os.error, IOError):
                pass
        return dict

def sumdict(self, list = None):
        return self.dict(self.sum, list)

def sizedict(self, list = None):
        return self.dict(self.size, list)

def mtimedict(self, list = None):
        return self.dict(self.mtime, list)

def statdict(self, list = None):
        return self.dict(self.stat, list)

def infodict(self, list = None):
        return self._dict(self.info, list)

def read(self, name, offset = 0, length = -1):
        self.checkfile(name)
        f = open(name)
        f.seek(offset)
        if length == 0:
            data = ''
        elif length < 0:
            data = f.read()
        else:
            data = f.read(length)
        f.close()
        return data

def create(self, name):
        self.check(name)
        if os.path.exists(name):
            self.checkfile(name)
            bname = name + '~'
            try:
                os.unlink(bname)
            except os.error:
                pass
            os.rename(name, bname)
        f = open(name, 'w')
        f.close()

def write(self, name, data, offset = 0):
        self.checkfile(name)
        f = open(name, 'r+')
        f.seek(offset)
        f.write(data)
        f.close()

def mkdir(self, name):
        self.check(name)
        os.mkdir(name, 0777)

def rmdir(self, name):
        self.check(name)
        os.rmdir(name)

class FSProxyServer(FSProxyLocal, server.Server):

def __init__(self, address, verbose = server.VERBOSE):
        FSProxyLocal.__init__(self)
        server.Server.__init__(self, address, verbose)

def _close(self):
        server.Server._close(self)
        FSProxyLocal._close(self)

def _serve(self):
        server.Server._serve(self)
        # Retreat into start directory
        while self._dirstack: self.back()

class FSProxyClient(client.Client):

def __init__(self, address, verbose = client.VERBOSE):
        client.Client.__init__(self, address, verbose)

def test():
    import string
    import sys
    if sys.argv[1:]:
        port = string.atoi(sys.argv[1])
    else:
        port = 4127
    proxy = FSProxyServer(('', port))
    proxy._serverloop()

if __name__ == '__main__':
    test()

cmd: