Changes between Version 31 and Version 32 of XML-RPC

07/18/2007 04:25:58 PM (8 years ago)

spam revert



    v31 v32  
     1= XML-RPC =
     4NOTE: All credit for this code goes to Crast in
     6This uses SimpleXMLRPCDispatcher which is part of the standard Python lib in 2.4 (And possibly earlier versions).
     9In discussing ways of handling XML-RPC for Django, I realised I really needed a way to do it without patching Django's code.  Crast in #django came up with a great solution, which I have modified and tweaked a bit.
     11I've included it here.  Feel free to fiddle with it and make it your own ... All this code is '''post-mr'''
     13Any crappy & garbage code is completely mine; I'm still learning Python so bear with me.  The hacks I added for self-documentation output are just that; any improvements to them would probably be a good thing.
     15First, setup your to map an XML-RPC service:
     20urlpatterns = patterns('',
     21    # XML-RPC
     22     (r'^xml_rpc_srv/', 'yourproject.yourapp.xmlrpc.rpc_handler'),
     27Then, in the appropriate place, create a file called
     32# Patchless XMLRPC Service for Django
     33# Kind of hacky, and stolen from Crast on
     34# Self documents as well, so if you call it from outside of an XML-RPC Client
     35# it tells you about itself and its methods
     37# Brendan W. McAdams <>
     39# SimpleXMLRPCDispatcher lets us register xml-rpc calls w/o
     40# running a full XMLRPC Server.  It's up to us to dispatch data
     42from SimpleXMLRPCServer import SimpleXMLRPCDispatcher
     43from django.http import HttpResponse
     45# Create a Dispatcher; this handles the calls and translates info to function maps
     46#dispatcher = SimpleXMLRPCDispatcher() # Python 2.4
     47dispatcher = SimpleXMLRPCDispatcher(allow_none=False, encoding=None) # Python 2.5
     51def rpc_handler(request):
     52        """
     53        the actual handler:
     54        if you setup your properly, all calls to the xml-rpc service
     55        should be routed through here.
     56        If post data is defined, it assumes it's XML-RPC and tries to process as such
     57        Empty post assumes you're viewing from a browser and tells you about the service.
     58        """
     60        response = HttpResponse()
     61        if len(request.POST):
     62                response.write(dispatcher._marshaled_dispatch(request.raw_post_data))
     63        else:
     64                response.write("<b>This is an XML-RPC Service.</b><br>")
     65                response.write("You need to invoke it using an XML-RPC Client!<br>")
     66                response.write("The following methods are available:<ul>")
     67                methods = dispatcher.system_listMethods()
     69                for method in methods:
     70                        # right now, my version of SimpleXMLRPCDispatcher always
     71                        # returns "signatures not supported"... :(
     72                        # but, in an ideal world it will tell users what args are expected
     73                        sig = dispatcher.system_methodSignature(method)
     75                        # this just reads your docblock, so fill it in!
     76                        help =  dispatcher.system_methodHelp(method)
     78                        response.write("<li><b>%s</b>: [%s] %s" % (method, sig, help))
     80                response.write("</ul>")
     81                response.write('<a href=""> <img src="" border="0" alt="Made with Django." title="Made with Django."></a>')
     83        response['Content-length'] = str(len(response.content))
     84        return response
     86def multiply(a, b):
     87        """
     88        Multiplication is fun!
     89        Takes two arguments, which are multiplied together.
     90        Returns the result of the multiplication!
     91        """
     92        return a*b
     94# you have to manually register all functions that are xml-rpc-able with the dispatcher
     95# the dispatcher then maps the args down.
     96# The first argument is the actual method, the second is what to call it from the XML-RPC side...
     97dispatcher.register_function(multiply, 'multiply')
     100That's it!
     102You can pretty much write a standard python function in there, just be sure to register it with the dispatcher when you're done. 
     104Here's a quick and dirty client example for testing:
     108import sys
     109import xmlrpclib
     110rpc_srv = xmlrpclib.ServerProxy("http://localhost:8000/xml_rpc_srv/")
     111result = rpc_srv.multiply( int(sys.argv[1]), int(sys.argv[2]))
     112print "%d * %d = %d" % (sys.argv[1], sys.argv[2], result)
     115Based on experience, I do recommend that you use Dictionaries for your args rather than long args, but I think that's personal preference (It allows named arguments, eliminates 'out of order' argument issues and it makes the code more self-documenting).
     117Have fun!
     119- [  Brendan W. McAdams <>]
     123I wrote up [ a modified version of the XML-RPC view] that uses a template for documentation. -- [ Adam Blinkinsop <>]
     127I've taken the basics of the SimpleXMLRPCDispatcher above and have turned it into a distributable Django app, [ django_xmlrpc]. -- [ Graham Binns]
Back to Top