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