# 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

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

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

import org.apache.ws.commons.util.NamespaceContextImpl;
import org.apache.xmlrpc.common.TypeFactoryImpl;
import org.apache.xmlrpc.common.XmlRpcController;
import org.apache.xmlrpc.common.XmlRpcStreamConfig;
import org.apache.xmlrpc.parser.NullParser;
import org.apache.xmlrpc.parser.TypeParser;
import org.apache.xmlrpc.serializer.NullSerializer;
import org.apache.xmlrpc.serializer.TypeSerializer;
import org.xml.sax.SAXException;
 
/**
 * This class extends Type Factory Impl to provide concrete type factory for handling
 * Null values. In this case the tag comparison uses NullSerializer.NIL_TAG as opposed
 * to EX_NIL_TAG
 *
 * @author zsugiart
 *
 */
public class XmlRpcTypeNil extends TypeFactoryImpl {
 
	public XmlRpcTypeNil(XmlRpcController pController) {
		super(pController);
	}
 
	public TypeParser getParser(XmlRpcStreamConfig pConfig, NamespaceContextImpl pContext, String pURI, String pLocalName) {
		if (NullSerializer.NIL_TAG.equals(pLocalName) || NullSerializer.EX_NIL_TAG.equals(pLocalName) )return new NullParser();
		else return super.getParser(pConfig, pContext, pURI, pLocalName);
	}
 
	public TypeSerializer getSerializer(XmlRpcStreamConfig pConfig, Object pObject) throws SAXException {
		if (pObject instanceof XmlRpcTypeNil) return new NullSerializer();
		else return super.getSerializer(pConfig, pObject);
	}
}

XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
config.setServerURL("http://xmlrpc.url");
 
XmlRpcClient client = new XmlRpcClient();
client.setTypeFactory(new XmlRpcTypeNil(client)); // yes it's this easy!
client.setConfig(config);
 
// client.execute(...)

XmlRpcServer xmlRpcServer = this.webServer.getXmlRpcServer(); // or however it is setup
xmlRpcServer.setTypeFactory(new XmlRpcTypeNil(this.xmlRpcServer));

<%@ LANGUAGE=VBScript %>
<%
'# ==========================================================================================================
'#
'# JSON-RPC Proxy ASP [classic asp]
'#
'# This asp page/component will forward the json-rpc request to an existing json-rpc service 
'# and transparently forward the result back to the caller via the HTTP response. 
'# 
'# @author Zen Sugiarto
'# ==========================================================================================================
 
'# configuration
'# -------------
 
'# This URl points to the json-rpc service point. 
'# if your system uses a different configuration mechanism, please adjust it accordingly
'#
Dim servicePointUrl
servicePointUrl = "http://url-to-json-rpc/point"
 
'# main body of execution
'# ----------------------
 
'# this function allows for msg to be logged into a log file so we can trace / analyze the traffic.
Sub logInfo (message)
	logFile = Server.MapPath("event.log")
    Const ForWriting   = 2
    Const ForAppending = 8
    Set fs = CreateObject("Scripting.FileSystemObject")
    If fs.FileExists(logFile) Then
        Set logFile = fs.OpenTextFile(logFile, ForAppending)
    Else
        Set logFile = fs.CreateTextFile(logFile, True)
    End If    
    logFile.WriteLine(Now() & vbTab & message)
    logFile.Close
    Set logFile = nothing
    Set fs = nothing
End Sub
 
' we read all of the POST data, json-rpc supports get, but this component only does POST for now.
' the safe array read from .BinaryRead is then converted into string, which is then sent into the 
' forwarding HTTP request object to the bus.
dim safeArray, totalBytes
totalBytes=Request.TotalBytes
safeArray=Request.BinaryRead(totalBytes)
jsonBody = ""
For n = 1 To LenB(safeArray)
  jsonBody = jsonBody & Chr(AscB(MidB(safeArray,n,1)))
Next
 
' create the HTTP request object to be forwarded into the service bus, 
' inject the json body in.
Dim httpreq
Set httpreq = Server.CreateObject("MSXML2.XMLHTTP")
httpreq.open "POST",servicePointUrl, False
httpreq.setRequestHeader "Content-Type","application/json-rpc"
'httpreq.setRequestHeader "Cookie",Request.Cookies
 
' Send out the request
On Error Resume Next
httpreq.send jsonBody
logInfo("REQUEST={ queryString=" & Request.QueryString & ", cookies="& Request.Cookies &", totalBytes=" & Request.TotalBytes & ", jsonBody="&jsonBody)
 
' TODO: implement error handling
 
' get response text, set mime type to application/json-rpc and write the bus response to the response stream
Response.ContentType="application/json-rpc"
Response.Write(httpreq.responseText)
%>

// initiates the command line using args
// as specified in... void main(string[] args){...
 
// --port=<portNum>, hasArgs, mandatory
// --serviceName=<name>, hasArgs, mandatory
// --optional (no args), optional
 
SimpleGNUCommandLine cli = new SimpleGNUCommandLine(args);
cli.addOption("port", "xml-rpc port", true, true);
cli.addOption("serviceName", "xml-rpc service point name", true, true);
cli.addOption("optional", "xml-rpc service point name", false, false);
 
// as you can guess, signature for addOption is: 
// .addOption('name','description',hasArgs, isMandatory);
 
System.out.print(cli.getInteger("port"));
System.out.print(cli.getString("serviceName"));
if( cli.hasOption("optional")) System.out.println("--optional is provided");

package zsugiart.util;
 
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
 
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.GnuParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.MissingOptionException;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
 
/**
 * This simple utility provides a very simple wrapper class to help use the
 * apache commons CLI. The SimpleGNUCommandLine provides the command line
 * parser-wrapper for GNU-style options. It provides basic parsing ability
 * with built in support for printing help into system.out.
 * See example usage in main method
 *
 * @author zsugiart
 */
public class SimpleGNUCommandLine
{
/* attribute */
 
	private Options options = new Options();
	private String[] cmdlineArgs=null;
	private CommandLine cmdLine=null;
	private boolean isParsed=false;
 
/* init & destroy */
 
	// constructor
	public SimpleGNUCommandLine(String cmdLineArgs[])
	{
		this.cmdlineArgs=cmdLineArgs;
		this.addOption("help", "when specified, will override and print this help message", false, false);
	}
 
/* option services */
 
	/**
	 * Adds an option into the command line parser
	 * @param optionName - the option name
	 * @param description - option descriptiuon
	 * @param hasValue - if set to true, --option=value, otherwise, --option is a boolean
	 * @param isMandatory - if set to true, the option must be provided.
	 */
	@SuppressWarnings("static-access")
	public void addOption(String optionName, String description, boolean hasValue, boolean isMandatory )
	{
		OptionBuilder opt = OptionBuilder.withLongOpt(optionName);
		opt = opt.withDescription(description);
		if( hasValue ) opt = opt.hasArg();
		if( isMandatory ) opt = opt.isRequired();
		options.addOption(opt.create());
	}
 
	// this method is implicitly called by accessor methods
	// and will only be called on first instance.
	private void parse()
	throws Exception
	{
		CommandLineParser parser = new GnuParser();
		try { this.cmdLine = parser.parse(this.options, this.cmdlineArgs); }
		catch(MissingOptionException moe){printUsage();}
		this.isParsed=true;
		if( this.cmdLine.hasOption("help")) printUsage();
	}
 
/* accessors & utilities */
 
	public void printUsage()
	{
		HelpFormatter formatter = new HelpFormatter();
		formatter.printHelp("available options as follow:", options );
		System.exit(1);
	}
	public String getString(String optionname) throws Exception { if(!this.isParsed) this.parse(); return this.cmdLine.getOptionValue(optionname); }
	public Integer getInteger(String optionname) throws Exception { return Integer.parseInt(this.getString(optionname));   }
	public Double getDouble(String optionname) throws Exception { return Double.parseDouble(this.getString(optionname)); }
	public List<String> getList(String optionname, String delimiter) throws Exception
	{
		List<String> arrayList = new ArrayList<String>();
		StringTokenizer tkn = new StringTokenizer(this.getString(optionname),delimiter);
		while (tkn.hasMoreTokens()) arrayList.add(tkn.nextToken());
		return arrayList;
	}
	public boolean hasOption(String optionName) throws Exception { if( !this.isParsed) this.parse(); return this.cmdLine.hasOption(optionName); }
 
	/**
	 * Example, to run this class, must
	 * @param args
	 */
	public static void main(String[] args)
	throws Exception
	{
		SimpleGNUCommandLine cli = new SimpleGNUCommandLine(args);
		cli.addOption("port", "xml-rpc port", true, true);
		cli.addOption("serviceName", "xml-rpc service point name", true, true);
		cli.addOption("optional", "xml-rpc service point name", true, false);
 
		System.out.print(cli.getInteger("port"));
		System.out.print(cli.getString("serviceName"));
		if( cli.hasOption("optional")) System.out.println("--optional is provided");
	}
}

sudo gainroot
apt-get install -y kernel-power-flasher
apt-get remove kernel-flasher-maemo
apt-get install --reinstall -y kernel-power kernel-power-flasher

import org.apache.xmlrpc.server.PropertyHandlerMapping;
import org.apache.xmlrpc.server.XmlRpcServer;
import org.apache.xmlrpc.server.XmlRpcServerConfigImpl;
import org.apache.xmlrpc.webserver.WebServer;
 
/**
 * A simple implementation of XML-RPC server for apache ws-xmlrpc
 * Version 1.2 - support single instance handler object, but not yet multi-threaded
 * Zen Sugiarto
 */
public class SimpleXmlRpcServer
{
	/* ======================================== runtime attr ========================================== */
 
	private int port;
	private WebServer webServer = null;
	private PropertyHandlerMapping phm = null;
	private SimpleXmlRpcRequestHandlerFactory handler = null;
	private XmlRpcServer xmlRpcServer = null;
 
	/* ======================================== init/destroy ========================================== */
 
	/**
	 * Creates an instance of xml rpc server, using :handler as the class that
	 * will handle all request. Note that a new instance of :handler will be
	 * created at every xml-rpc request.
	 *
	 * @param name
	 * @param port
	 * @param handler
	 * @throws Exception
	 */
	public SimpleXmlRpcServer(int port) throws Exception
	{
		this.port = port;
		// bind
		this.webServer = new WebServer(this.port);
		this.xmlRpcServer = this.webServer.getXmlRpcServer();
		this.handler = new SimpleXmlRpcRequestHandlerFactory();
 
		this.phm = new PropertyHandlerMapping();
		this.phm.setRequestProcessorFactoryFactory(this.handler);
 
	}
 
	/* ======================================== services ========================================== */
 
	/**
	 * Adds a handler instance (which CAN be stateful) for each request. Note that
	 * every public method in this object will be callable via xml-rpc client
	 *
	 * @param name - handler name
	 * @param requestHandler - handler obj instance
	 * @throws Exception
	 */
	public void addHandler(String name, Object requestHandler)
	throws Exception
	{
		this.handler.setHandler(name, requestHandler);
		this.phm.addHandler(name, requestHandler.getClass());
	}
 
	/**
	 * Start the xml-rpc server forever. In the rare case of fatal exception, the
	 * web server will be restarted automagically. This is a blocking call (not
	 * thread-based).
	 */
	public void serve_forever() throws Exception
	{
		// init
		this.xmlRpcServer.setHandlerMapping(phm);
		XmlRpcServerConfigImpl serverConfig = (XmlRpcServerConfigImpl) xmlRpcServer.getConfig();
		serverConfig.setEnabledForExtensions(true);
		this.webServer.start();
	}
 
	/* ====================================== getter/setter ======================================== */
 
	public int getPort() { return port; }
	public void setPort(int port) { this.port = port; }
	public WebServer getWebServer() { return webServer; }
	public void setWebServer(WebServer webServer) { this.webServer = webServer; }
	public PropertyHandlerMapping getPhm() { return phm; }
	public void setPhm(PropertyHandlerMapping phm) { this.phm = phm; }
	public SimpleXmlRpcRequestHandlerFactory getHandler() { return handler; }
	public void setHandler(SimpleXmlRpcRequestHandlerFactory handler) { this.handler = handler; }
	public XmlRpcServer getXmlRpcServer() { return xmlRpcServer; }
	public void setXmlRpcServer(XmlRpcServer xmlRpcServer) { this.xmlRpcServer = xmlRpcServer; } 
 
}

/**
 * Simple XMLRPC request handler factory - this little magic class allows
 * for a request INSTANCE to be set as the handler for the xml rpc server
 * Ideally, a client shouldn't even NEED to know what this is doing.
 */
public class SimpleXmlRpcRequestHandlerFactory
implements RequestProcessorFactoryFactory,RequestProcessorFactory
{
	private Map handlerMap = new HashMap();
	public void setHandler(String name, Object handler) { this.handlerMap.put(name, handler); }
	public Object getHandler(String name) { return this.handlerMap.get(name); }
 
	public RequestProcessorFactory getRequestProcessorFactory(Class arg0)
	throws XmlRpcException { return this; }
	public Object getRequestProcessor(XmlRpcRequest request) throws XmlRpcException
	{
		String handlerName = request.getMethodName().substring(0,request.getMethodName().lastIndexOf("."));
		if( !handlerMap.containsKey(handlerName)) throw new XmlRpcException("Unknown handler: "+handlerName);
		return handlerMap.get(handlerName);
	}
}

public class SimpleXMLRpcTest
{
	public String hello()
	{
		return "hello world";
	}
 
	public static void main(String[] args) throws Exception
	{
		SimpleXmlRpcServer server = new SimpleXmlRpcServer(7777);
		server.addHandler("zen", new SimpleXMLRpcTest());
		server.serve_forever();
 
		while (true)
		{
			System.out.println("");
			Thread.sleep(60 * 60 * 60);
		}
	}
}

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