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

CHAPTER 18 ■ RPC
linecount = proxy.root.line_counter(fileobj, noisy)
print 'The number of lines in the file was', linecount
At first the client might look like a rather standard program using an RPC service. After all, it calls a
generically-named connect() function with a network address, and then accesses methods of the
returned proxy object as though the calls were being performed locally. However, if you look closer, you
will see some startling differences! The first argument to the RPC function is actually a live file object that
does not necessarily exist on the server. And the other argument is a function, another live object instead
of the kind of inert data structure that RPC mechanisms usually support.
The server exposes a single method that takes the proffered file object and callable function. It uses
these exactly as you would in a normal Python program that was happening inside a single process. It
calls the file object’s readlines() and expects the return value to be an iterator over which a for loop can
repeat. Finally, the server calls the function object that has been passed in without any regard for where
the function actually lives (namely, in the client). Note that RPyC’s new security model dictates that,
absent any special permission, it will only allow clients to call methods that start with the special prefix,
exposed_.
Listing 18–8. An RPyC Server
#!/usr/bin/env python
# Foundations of Python Network Programming - Chapter 18 - rpyc_server.py
# RPyC server
import rpyc
class MyService(rpyc.Service):
» def exposed_line_counter(self, fileobj, function):
» » for linenum, line in enumerate(fileobj.readlines()):
» » » function(line)
» » return linenum + 1
from rpyc.utils.server import ThreadedServer
t = ThreadedServer(MyService, port = 18861)
t.start()
It is especially instructive to look at the output generated by running the client, assuming that a
small testfile.txt indeed exists in the current directory and that it has a few words of wisdom inside:
$ python rpyc_client.py
Noisy: 'Simple\n'
Noisy: 'is\n'
Noisy: 'better\n'
Noisy: 'than\n'
Noisy: 'complex.\n'
The number of lines in the file was 5
Equally startling here are two facts. First, the server was able to iterate over multiple results from
readlines(), even though this required the repeated invocation of file-object logic that lived on the
client. Second, the server didn’t somehow copy the noisy() function’s code object so it could run the
function directly; instead, it repeatedly invoked the function, with the correct argument each time, on
the client side of the connection!
How is this happening? Quite simply, RPyC takes exactly the opposite approach from the other RPC
mechanisms we have looked at. Whereas all of the other techniques try to serialize and send as much
information across the network as possible, and then leave the remote code to either succeed or fail with
no further information from the client, the RPyC scheme only serializes completely immutable items
318