Foundations of Python Network Programming 978-1-4302-3004-5

CHAPTER 18 ■ RPC
dispatcher = lovely.jsonrpc.dispatcher.JSONRPCDispatcher()
dispatcher.register_method(lengths)
app = lovely.jsonrpc.wsgi.WSGIJSONRPCApplication({'': dispatcher})
server = make_server('localhost', 7002, app)
print "Starting server"
while True:
» server.handle_request()
You can see that the Lovely Systems package — which was written recently using modern Python
technology — offers a WSGI wrapper around its JSON-RPC dispatcher, making it easy to incorporate into
modern Python web application stacks, or to deploy stand-alone using the Standard Library’s wsgiref
package.
The server code is quite simple, as an RPC mechanism should be. As with XML-RPC, we merely need
to name the functions that we want offered over the network, and they become available for queries.
(You can also pass an object, and its methods will be registered with the server all at once.)
Listing 18–6. JSON-RPC Client
#!/usr/bin/env python
# Foundations of Python Network Programming - Chapter 18 - jsonrpc_client.py
# JSON-RPC client
from lovely.jsonrpc import proxy
proxy = proxy.ServerProxy('http://localhost:7002')
print proxy.lengths((1,2,3), 27, {'Sirius': -1.46, 'Rigel': 0.12})
Writing client code is also quite simple. Sending several objects whose lengths we want measured —
and having those data structures sent right back by the server — enables us to see several details about
this particular protocol.
First, note that the protocol allowed us to send as many arguments as we wanted; it was not
bothered by the fact that it could not introspect a static method signature from our function. This is
similar to XML-RPC, but it is very different from XML-RPC mechanisms built for traditional, staticallytyped
languages.
Second, note that the None value in the server’s reply passes back to us unhindered. This is because
this value is supported natively by the protocol itself, without our having to activate any non-standard
extensions:
$ python jsonrpc_server.py
Starting server
[In another command window:]
$ python jsonrpc_client.py
[[3, [1, 2, 3]], [None, 27], [2, {'Rigel': 0.12, 'Sirius': -1.46}]]
Third, note that there is only one kind of sequence supported by JSON-RPC, which means that the
tuple sent by our client had to be coerced to a list to make it across.
Of course, the biggest difference between JSON-RPC and XML-RPC — that the data payload in this
case is a small, sleek JSON message that knows natively how to represent each of our data types — is not
even visible here. This is because both mechanisms do such a good job of hiding the network from our
code. Running Wireshark on my localhost interface while running this example client and server, I can
see that the actual messages being passed are as follows:
{"version": "1.1",
"params": [[1, 2, 3], 27, {"Rigel": 0.12, "Sirius": -1.46}],
"method": "lengths"}
{"result": [[3, [1, 2, 3]], [null, 27],
[2, {"Rigel": 0.12, "Sirius": -1.46}]]}
314