root/trunk/RBJabber/sandbox/ether/jabberRPC.py

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
##~ Copyright (C) 2002-2004  TechGame Networks, LLC.
##~ 
##~ This library is free software; you can redistribute it and/or
##~ modify it under the terms of the BSD style License as found in the 
##~ LICENSE file included with this distribution.
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#~ Imports 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

import sys
import xmlrpclib 
from RBJabber import Client
from RBFoundation.SmartSelect import SmartSelectList

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Constants / Variables / Etc. 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

nsXMLRPC = 'RBJabber.xmlrpc'

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Definitions 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class JabberXMLRPCServerProxy(object):
    """Derived from xmlrpclib.ServerProxy"""

    def __init__(self, jcHost, serverJID, encoding=None, verbose=False, allow_none=False):
        self.jcHost = jcHost
        self.serverJID = serverJID
        self.messageBody = 'XMLRPC over jabber'

        self._allow_none = allow_none

    def _request(self, methodname, params):
        request = xmlrpclib.dumps(params, methodname, allow_none=self._allow_none)
        # trim off the <?xml version=''?> because we are encapsulated
        request = request.split('\n', 1)[1] 
        request = '<xmlrpc xmlns="%s">\n%s\n</xmlrpc>'%(nsXMLRPC, request)

        self.jcHost.Message(self.serverJID, self.messageBody, xml=request)

    def __getattr__(self, name):
        return xmlrpclib._Method(self._request, name)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class JabberXMLRPC(Client.Client):
    remoteObject = None

    def hookMessages(self):
        self.stream.AddObserver('message', self.onMessage)

    def onMessage(self, subject, message):
        for each in message._iterElements(nsXMLRPC, 'xmlrpc'):
            self.onXMLRPCMessage(each)

    def onXMLRPCMessage(self, elem):
        results = []
        for xmlrpcElem in elem._iterAllElements():
            results.append(self._marshaled_dispatch(xmlrpcElem._toXML()))
        return results

    def getJID(self):
        return self.information.jid
    jid = property(getJID)

    def getRemoteObject(self):
        return self.remoteObject
    def setRemoteObject(self, value):
        self.remoteObject = value

    def _dispatch(self, method, params):
        return getattr(self.getRemoteObject(), method)(*params)

    def _marshaled_dispatch(self, data, dispatch_method = None):
        """from python2.3's SimpleXMLPRCServer"""
        data = '\n'+data
        params, method = xmlrpclib.loads(data)

        # generate response
        try:
            response = self._dispatch(method, params)
            response = xmlrpclib.dumps((response,), methodresponse=1)
        except xmlrpclib.Fault, fault:
            response = xmlrpclib.dumps(fault)
        except:
            # report exception back to server
            response = xmlrpclib.dumps(
                xmlrpclib.Fault(1, "%s:%s" % (sys.exc_type, sys.exc_value))
                )

        return response

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Testing
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class TestEventObject(object):
    rpcOther = None
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return "%s<%s>" % (self.__class__.__name__, self.name)

    def onEvent(self, msg):
        print "%r.onEvent(%r)" % (self, msg)
        self.rpcOther.onEventReply(msg, "I got it!")

    def onEventReply(self, msg, reply):
        print "%r.onEventReply(%r, %r)" % (self, msg, reply)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def test(loginInfos=[
            ('swh.test.1', 'ok2jab4test', 'xmlrpc'),
            ('swh.test.2', 'ok2jab4test', 'xmlrpc'),
            ],
        server='techgame.net',
        ):

    jcs = SmartSelectList([JabberXMLRPC(server) for each in loginInfos])
    for jc, info in zip(jcs, loginInfos):
        #jc._SetDebug(sys.stdout, sys.stdout)
        jc.hookMessages()
        jc.Authenticate(*info)
        jc.setRemoteObject(TestEventObject(info[0]))

    rpcs = []
    for i, jc in enumerate(jcs):
        jid = jcs[(i+1)%len(jcs)].getJID()
        rpc = JabberXMLRPCServerProxy(jc, jid)
        jc.getRemoteObject().rpcOther = rpc
        rpcs.append(rpc)

    jcs.ProcessPending(0.1)
    return jcs, rpcs

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Main 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if __name__=='__main__':
    jcs, rpcs = test()
    try:
        rpcs[0].onEvent('From client 0')
        jcs.ProcessPending(0.5)
        rpcs[1].onEvent('From client 1')
        jcs.ProcessPending(0.5)

    finally:
        for each in jcs:
            each.Shutdown()
        jcs.ProcessPending(0.5)