Gecko [ www.corporacionhdm.com.pe ]

Name	Size	Permission	Date
FSProxy.py	7.64 KB	-rw-r--r--	2020-04-19 21:13
FSProxy.pyc	12.5 KB	-rw-r--r--	2024-04-10 04:58
FSProxy.pyo	12.5 KB	-rw-r--r--	2024-04-10 04:58
RCSProxy.py	4.61 KB	-rwxr-xr-x	2024-04-10 04:57
RCSProxy.pyc	7.57 KB	-rw-r--r--	2024-04-10 04:58
RCSProxy.pyo	7.57 KB	-rw-r--r--	2024-04-10 04:58
README	4.16 KB	-rw-r--r--	2020-04-19 21:13
client.py	4.6 KB	-rw-r--r--	2020-04-19 21:13
client.pyc	6.57 KB	-rw-r--r--	2024-04-10 04:58
client.pyo	6.57 KB	-rw-r--r--	2024-04-10 04:58
cmdfw.py	4.53 KB	-rw-r--r--	2020-04-19 21:13
cmdfw.pyc	5.12 KB	-rw-r--r--	2024-04-10 04:58
cmdfw.pyo	5.12 KB	-rw-r--r--	2024-04-10 04:58
cmptree.py	5.64 KB	-rw-r--r--	2020-04-19 21:13
cmptree.pyc	5.98 KB	-rw-r--r--	2024-04-10 04:58
cmptree.pyo	5.98 KB	-rw-r--r--	2024-04-10 04:58
cvslib.py	9.94 KB	-rw-r--r--	2020-04-19 21:13
cvslib.pyc	12.83 KB	-rw-r--r--	2024-04-10 04:58
cvslib.pyo	12.83 KB	-rw-r--r--	2024-04-10 04:58
cvslock.py	6.61 KB	-rw-r--r--	2020-04-19 21:13
cvslock.pyc	8.36 KB	-rw-r--r--	2024-04-10 04:58
cvslock.pyo	8.36 KB	-rw-r--r--	2024-04-10 04:58
mac.py	352 B	-rw-r--r--	2020-04-19 21:13
mac.pyc	598 B	-rw-r--r--	2024-04-10 04:58
mac.pyo	598 B	-rw-r--r--	2024-04-10 04:58
makechangelog.py	2.92 KB	-rwxr-xr-x	2024-04-10 04:57
makechangelog.pyc	3.05 KB	-rw-r--r--	2024-04-10 04:58
makechangelog.pyo	3.05 KB	-rw-r--r--	2024-04-10 04:58
rcsbump	745 B	-rwxr-xr-x	2024-04-10 04:57
rcsclient.py	1.76 KB	-rw-r--r--	2020-04-19 21:13
rcsclient.pyc	2.05 KB	-rw-r--r--	2024-04-10 04:58
rcsclient.pyo	2.05 KB	-rw-r--r--	2024-04-10 04:58
rcslib.py	10.08 KB	-rw-r--r--	2020-04-19 21:13
rcslib.pyc	11.28 KB	-rw-r--r--	2024-04-10 04:58
rcslib.pyo	11.28 KB	-rw-r--r--	2024-04-10 04:58
rcvs	117 B	-rwxr-xr-x	2024-04-10 04:57
rcvs.py	13.32 KB	-rwxr-xr-x	2024-04-10 04:57
rcvs.pyc	14.08 KB	-rw-r--r--	2024-04-10 04:58
rcvs.pyo	14.08 KB	-rw-r--r--	2024-04-10 04:58
rrcs	117 B	-rwxr-xr-x	2024-04-10 04:57
rrcs.py	3.9 KB	-rwxr-xr-x	2024-04-10 04:57
rrcs.pyc	5.5 KB	-rw-r--r--	2024-04-10 04:58
rrcs.pyo	5.5 KB	-rw-r--r--	2024-04-10 04:58
security.py	1.07 KB	-rw-r--r--	2020-04-19 21:13
security.pyc	1.64 KB	-rw-r--r--	2024-04-10 04:58
security.pyo	1.64 KB	-rw-r--r--	2024-04-10 04:58
server.py	4.47 KB	-rw-r--r--	2020-04-19 21:13
server.pyc	5.83 KB	-rw-r--r--	2024-04-10 04:58
server.pyo	5.83 KB	-rw-r--r--	2024-04-10 04:58
sumtree.py	518 B	-rw-r--r--	2020-04-19 21:13
sumtree.pyc	903 B	-rw-r--r--	2024-04-10 04:58
sumtree.pyo	903 B	-rw-r--r--	2024-04-10 04:58

Rename

"""RPC Client module."""

import sys
import socket
import pickle
import __builtin__
import os

# Default verbosity (0 = silent, 1 = print connections, 2 = print requests too)
VERBOSE = 1

class Client:

"""RPC Client class.  No need to derive a class -- it's fully generic."""

def __init__(self, address, verbose = VERBOSE):
        self._pre_init(address, verbose)
        self._post_init()

def _pre_init(self, address, verbose = VERBOSE):
        if type(address) == type(0):
            address = ('', address)
        self._address = address
        self._verbose = verbose
        if self._verbose: print "Connecting to %s ..." % repr(address)
        self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self._socket.connect(address)
        if self._verbose: print "Connected."
        self._lastid = 0 # Last id for which a reply has been received
        self._nextid = 1 # Id of next request
        self._replies = {} # Unprocessed replies
        self._rf = self._socket.makefile('r')
        self._wf = self._socket.makefile('w')

def _post_init(self):
        self._methods = self._call('.methods')

def __del__(self):
        self._close()

def _close(self):
        if self._rf: self._rf.close()
        self._rf = None
        if self._wf: self._wf.close()
        self._wf = None
        if self._socket: self._socket.close()
        self._socket = None

def __getattr__(self, name):
        if name in self._methods:
            method = _stub(self, name)
            setattr(self, name, method) # XXX circular reference
            return method
        raise AttributeError, name

def _setverbose(self, verbose):
        self._verbose = verbose

def _call(self, name, *args):
        return self._vcall(name, args)

def _vcall(self, name, args):
        return self._recv(self._vsend(name, args))

def _send(self, name, *args):
        return self._vsend(name, args)

def _send_noreply(self, name, *args):
        return self._vsend(name, args, 0)

def _vsend_noreply(self, name, args):
        return self._vsend(name, args, 0)

def _vsend(self, name, args, wantreply = 1):
        id = self._nextid
        self._nextid = id+1
        if not wantreply: id = -id
        request = (name, args, id)
        if self._verbose > 1: print "sending request: %s" % repr(request)
        wp = pickle.Pickler(self._wf)
        wp.dump(request)
        return id

def _recv(self, id):
        exception, value, rid = self._vrecv(id)
        if rid != id:
            raise RuntimeError, "request/reply id mismatch: %d/%d" % (id, rid)
        if exception is None:
            return value
        x = exception
        if hasattr(__builtin__, exception):
            x = getattr(__builtin__, exception)
        elif exception in ('posix.error', 'mac.error'):
            x = os.error
        if x == exception:
            exception = x
        raise exception, value

def _vrecv(self, id):
        self._flush()
        if self._replies.has_key(id):
            if self._verbose > 1: print "retrieving previous reply, id = %d" % id
            reply = self._replies[id]
            del self._replies[id]
            return reply
        aid = abs(id)
        while 1:
            if self._verbose > 1: print "waiting for reply, id = %d" % id
            rp = pickle.Unpickler(self._rf)
            reply = rp.load()
            del rp
            if self._verbose > 1: print "got reply: %s" % repr(reply)
            rid = reply[2]
            arid = abs(rid)
            if arid == aid:
                if self._verbose > 1: print "got it"
                return reply
            self._replies[rid] = reply
            if arid > aid:
                if self._verbose > 1: print "got higher id, assume all ok"
                return (None, None, id)

def _flush(self):
        self._wf.flush()

from security import Security

class SecureClient(Client, Security):

def __init__(self, *args):
        import string
        apply(self._pre_init, args)
        Security.__init__(self)
        self._wf.flush()
        line = self._rf.readline()
        challenge = string.atoi(string.strip(line))
        response = self._encode_challenge(challenge)
        line = repr(long(response))
        if line[-1] in 'Ll': line = line[:-1]
        self._wf.write(line + '\n')
        self._wf.flush()
        self._post_init()

class _stub:

"""Helper class for Client -- each instance serves as a method of the client."""

def __init__(self, client, name):
        self._client = client
        self._name = name

def __call__(self, *args):
        return self._client._vcall(self._name, args)