.zugiart » python

Generic Python XML-RPC CLI Client (With apache extension support)

zen — Tue, 25 Oct 2011 05:10:16 +0000

This code snippet is a generic python xml-rpc client that supports custom extensions. This is tested with pytnon 2.6 – usage is as follow:

Interactive mode

# run the client like so:
python client.py --url=http://serverUrl:port/path/to/serverPoint
 
# in interactive mode, you see the CLI interface like so: 
[timestamp] http://serverUrl:port/path/to/serverPoint
xmlrpc >> helloWorld("hello zen")
hello zen #<- this is the response from the server

Oneliner mode

You can invoke the client as a one-liner, by passing the xmlrpc function to be called using the –cmd option. Like so:

python client.py --url=http://serverUrl:port/path/to/serverPoint --cmd='helloWorld("hello zen")'

Which is quite powerful, because now we can include this as part of shell scripts that can invoke/leverage existing xml-rpc service.

client.py script

The CustomXmlRpcExtensionTransport is what allows xml-rpc extensions to be parsed properly via the client. Here, (limited) support for Apache xml-rpc extension data types is added. Specifically – ex:nil as None; ex:i2, ex:i4, ex:i8 as numbers/int. This approach does not override original xmlrpclib implementation, but rather extends it.

 
from xmlrpclib import Transport, ServerProxy
import readline
import cmd
import traceback
import pprint
import datetime
from optparse import OptionParser
import sys
 
 
class CustomXmlRpcExtensionTransport(Transport):
    """
    This Transport allows for the parser's dispatch object to be modified to cater for additional 
    extension tags. In case the client need to be extend to interoperate with other provider, 
    such as apache xml-rpc service points. 
    see also http://bugs.python.org/issue8792
    """
    def getparser(self):
        parser, unmarshaller = Transport.getparser(self)
        dispatch = unmarshaller.dispatch.copy()
        unmarshaller.dispatch = dispatch
        # Now we can add custom types
        dispatch["ex:nil"] = dispatch["nil"]
        dispatch["ex:i2"]  = dispatch["int"]
        dispatch["ex:i4"]  = dispatch["int"]
        dispatch["ex:i8"]  = dispatch["int"]
 
        return parser, unmarshaller                                                                                                                                                                                                                                                                                                                              
 
class XmlRpcClientConsole(cmd.Cmd): 
    """
    Generic xml rpc client console. Allows for seamlessly working with compatible xml-rpc server.
    """
    def __init__(self, url):
        cmd.Cmd.__init__(self)
        self.url = url;
        self.server = ServerProxy(url, transport=CustomXmlRpcExtensionTransport(use_datetime=True)) #verbose=True,)
        self.pp = pprint.PrettyPrinter(indent=2)
        self.updatePrompt()
 
    def updatePrompt(self):
        self.prompt = "\n[%s] %s\nxmlrpc >> " % (datetime.datetime.now().strftime("%Y.%m.%d %H:%M:%S"),self.url)
 
    def default(self, line):
        try:
            result=None
            exec("result=self.server.%s" % (line))
            self.pp.pprint(result) # default formatter: pretty print the resultant data
        except Exception, ex:
            traceback.print_exc(ex)
        print; self.updatePrompt()
 
    def do_help(self,line):
        print
        print "-------------------------------------"
        print "GENERIC XML RPC CLIENT CONSOLE - HELP"
        print "-------------------------------------"
        print
        print "Simply type in the function name on the xml-rpc service end, like you would"
        print "on any good ol' python program. For example, if the other side has a method"
        print "called helloWorld(strparam), you can invoke it like so:"
        print
        print "... xmlrpc >> helloWorld('hello zen')"
        print
        print "the client is therefore completely transparent and exposes the full capabilities"
        print "of the server end. have fun." # -zen
        print 
 
def main():
    parser = OptionParser("""Generic XML RPC Client console""")
    parser.add_option("--url", dest="url", help="The XML RPC service URL to connect")
    parser.add_option("--cmd", dest="cmd", help="A one-off command to execute")
    (options, args) = parser.parse_args()
 
    if options.url == None :
        parser.print_help()
        sys.exit(1)
 
    console = XmlRpcClientConsole(options.url)
    if options.cmd != None :
        # run the cmd and bomb out
        console.default(options.cmd)
        sys.exit(0)
    else:
        print "for help using the console, type 'help'"
        # enter into cmd loop for interactive session
        console.cmdloop()
 
if __name__ == "__main__":
    main()

Enjoy!

zroundup, a demo

zen — Mon, 31 Aug 2009 22:33:38 +0000

I would like to introduce a small project that I am working on atm – started this on Sunday, took me almost 4 hours to get it to this stage. I’ve just managed to capture it properly via recordMyDesktop and mencoder, before I can upload this to YouTube.

Roundup, as you may already know is a Python issue tracking system. zroundup stands for zero configuration roundup – I’m aiming to make an issue tracking system that you can just download and run. Preferrably I would also like to be able to put this into a thumbdrive and then carry it around with me – a portable issue tracking system, on a stick!

I actually thought that this sort of thing would be perfect for freelancers / contractors who are usually on the move and have a huge list of issues / tasks on multiple projects that need to be managed.

Note: Probably you’ll have to see this in full screen, I haven’t figure out how to take a screenshot of only the region within my desktop, and keep in mind that this is still a work in progress – when it’s finished, the use case would likely be:

Download and install on a USB stick
You can run / stop the issue tracker from the USB stick
If you disconnect the USB stick the tracker will stop, but preserving all data
If you connect the USB stick on a windows machine, the tracker will run (automatically, if autoplay is enabled).

Python docstring

zen — Thu, 13 Aug 2009 00:49:21 +0000

Python’s docstring are really the equivalent of Java’s javadocs. However, the neat thing about docstring is that it is actually a fully qualified Python object. Check out the example below.

PyHelloWorld – DocString style

class TestClass:
   """
   Documentation for this test class...
   """
 
   def helloWorld(self):
      """
      HELLO WORLD DOCSTRING
      """
      func=getattr(self,'helloWorld')
      docstr=func.__doc__ #<--- notice this?
      print docstr
 
# 'quickie' main block
test=TestClass()
test.helloWorld()

Running the example below should print: “HELLO WORLD DOCSTRING”.

Note: I’ve also added this to my python programming notes.

Python XML-RPC

zen — Wed, 12 Aug 2009 02:10:35 +0000

I’ve added this snippets into my python notes. Here they are for convenience.

Dynamic Xml-Rpc server

This server code will use python “reflection” to publish all methods whose name are prefixed with PREFIX. In this case, the prefix is xmlrpc_, so all methods within this server such as xmlrpc_hello, will get published. The code already uses options, so it can be easily started like so:

python server.py –host=$HOSTNAME –port=portNum

Server skeleton code

import sys
from optparse import OptionParser
from SimpleXMLRPCServer import SimpleXMLRPCServer
 
class DynamicXMLRPCServer(SimpleXMLRPCServer):
    """
    An XMLRPC server that will register all function whose name are prefixed with PREFIX via xml-rpc
    Zen Sugiarto - 2011
    """
 
    # this is the prefix used by this sever to decide whether a given method should be published over xml-rpc or not.
    PREFIX="xmlrpc_"
 
    # constructor
    def __init__(self, params):
        self.params=params
        self.host=params['host']
        self.port=params['port']
        SimpleXMLRPCServer.__init__(self,(self.host, self.port))
        # register all xmlrpc_ functions over xml-rpc
        for name in dir(self):
            if name[:len(DynamicXMLRPCServer.PREFIX)] == DynamicXMLRPCServer.PREFIX:
                function=getattr(self,name)
                print "registering function: %s as %s " % ( name, name[len(DynamicXMLRPCServer.PREFIX):] )
                self.register_function(function, name[len(DynamicXMLRPCServer.PREFIX):])
 
    # note: xmlrpc_ prefix is used by this server to mark that this function will be published
    def xmlrpc_hello(self,msg):
        """
        A simple hello function used for simple ping check. 
        @param msg - msg to pass to hello
        @return dictionary {"hello":msg}
        """
        return {"hello":msg}
 
    def xmlrpc_describe(self):
        """
        Retrieves the description/documentation of available functions within this service.
        by the grace of python's .__doc__ object.
        @return dictionary of the following format
        { 
            'function_name' : 'documentation/description of that function '} 
        } 
        """
        metaDescription={}
        for name in dir(self):
            if name[:len(DynamicXMLRPCServer.PREFIX)] == DynamicXMLRPCServer.PREFIX:
                function=getattr(self,name)
                metaDescription[name[len(DynamicXMLRPCServer.PREFIX):]]=function.__doc__
        return metaDescription;
 
    def xmlrpc_yourFunction(self):
        """
        Put in more function here!~
        """
        print "IMPLEMENT ME"
 
def main():
    """ main method """
    parser = OptionParser(""" 
        Template service object - please put your comment in here
        """)
    parser.add_option("--host", dest="host", help="hostname to publish the service against")
    parser.add_option("--port", dest="port", help="port number to use")
    (options, args) = parser.parse_args()
 
    if( options.host == None or options.port == None ):
        print "insufficient options provided. try --help"
        sys.exit(1);
 
    server = DynamicXMLRPCServer({'host':options.host,'port':int(options.port)})
    server.serve_forever()
 
if __name__ == "__main__":
    main()

Dynamic XML-RPC Client

This will invoke Hello world function via xml-rpc, this is as simple as it gets

import xmlrpclib
print xmlrpclib.ServerProxy("http://localhost:8000/").hello("zen")

But this is even better: this is a client that will allow you to connect to any xml-rpc service (yes, even java ones in xml-rpc) and call any function as long as you know its signature.

import xmlrpclib
import readline
import cmd
import traceback
import pprint
import datetime
from optparse import OptionParser
import sys
 
class XmlRpcClientConsole(cmd.Cmd): 
    """
    Generic xml rpc client console, works with any xml rpc service
    """
    def __init__(self, url):
        cmd.Cmd.__init__(self)
        self.url = url;
        self.server = xmlrpclib.ServerProxy(url)
        self.pp = pprint.PrettyPrinter(indent=2)
        self.updatePrompt()
 
    def updatePrompt(self):
        self.prompt = "\n[%s] %s\nxmlrpc >> " % (datetime.datetime.now().strftime("%Y.%m.%d %H:%M:%S"),self.url)
 
    def default(self, line):
        try:
            result=None
            exec("result=self.server.%s" % (line))
            self.pp.pprint(result) # default formatter: pretty print the resultant data
        except Exception, ex:
            traceback.print_exc(ex)
        print; self.updatePrompt()
 
    def do_help(self,line):
        print
        print "-------------------------------------"
        print "GENERIC XML RPC CLIENT CONSOLE - HELP"
        print "-------------------------------------"
        print
        print "Simply type in the function name on the xml-rpc service end, like you would"
        print "on any good ol' python program. For example, if the other side has a method"
        print "called helloWorld(strparam), you can invoke it like so:"
        print
        print "... xmlrpc >> helloWorld('hello zen')"
        print
        print "the client is therefore completely transparent and exposes the full capabilities"
        print "of the server end. have fun." # -zen
        print 
 
def main():
    parser = OptionParser("""Generic XML RPC Client console""")
    parser.add_option("--url", dest="url", help="The XML RPC service URL to connect")
    parser.add_option("--cmd", dest="cmd", help="A one-off command to execute")
    (options, args) = parser.parse_args()
 
    if options.url == None :
        parser.print_help()
        sys.exit(1)
 
    console = XmlRpcClientConsole(options.url)
    if options.cmd != None :
        # run the cmd and bomb out
        console.default(options.cmd)
        sys.exit(0)
    else:
        print "for help using the console, type 'help'"
        # enter into cmd loop for interactive session
        console.cmdloop()
 
if __name__ == "__main__":
    main()

Example

Starting the server:

python server.py --host=localhost --port=6666

Starting the client in console mode:

python client.py --url=http://localhost:6666

Within the console:

[2011.06.22 11:31:25] http://localhost:6666
xmlrpc >> hello("zen")
{ 'hello': 'zen'}