Recipe15.4.Enabling an XML-RPC Server to Be Terminated Remotely

Recipe 15.4. Enabling an XML-RPC Server to Be Terminated Remotely

Credit: Christoph Dietze, Brian Quinlan, Jeff Bauer

Problem

You are coding an XML-RPC server, using the Python Standard Library's SimpleXMLRPCServer module, and you want to make it possible for a remote client to cause the XML-RPC server to exit cleanly.

Solution

You have to use your own request-handling loop (instead of the serve_forever method of SimpleXMLRPCServer ) so that you can stop looping when appropriate. For example:

import SimpleXMLRPCServer
running = True
def finis( ):
    global running
    running = False
    return 1
server = SimpleXMLRPCServer.SimpleXMLRPCServer(('127.0.0.1', 8000))
server.register_function(finis)
while running:
    server.handle_request( )

Discussion

SimpleXMLRPCServer 's serve_forever method, as its name implies, attempts to keep serving "forever"that is, it keeps serving until the whole server process is killed . Sometimes, it's useful to allow remote clients to request a clean termination of a service by remotely calling a server-exposed function, and this recipe demonstrates the simplest way to allow this functionality.

The finis function (which gets exposed to remote clients via the register_function call) sets the global variable running to False (and then returns something that is not None because the XML-RPC protocol cannot deal with the None object). Using the while running loop, instead of a serve_forever call, then ensures that the server stops serving and terminates when the variable running becomes false.

If you prefer to subclass SimpleXMLRPCServer , you can obtain a similar effect by overriding the serve_forever method: that is, instead of placing the simple while running: server.handle_request loop inline, you can code, for example (with the same function finis as in the recipe's Solution):

class MyServer(SimpleXMLRPCServer.SimpleXMLRPCServer):
    def serve_forever(self):
        while running:
            self.handle_request( )
server = MyServer(('127.0.0.1', 8000))
server.register_function(finis)
server.serve_forever( )

However, this alternative approach offers no special advantage (unless you have a fetish for being object oriented for no particular purpose), and, since this alternative approach is telling a little white lie (by using the name serve_forever for a method that does not keep serving "forever"!), the simpler approach in the recipe's Solution can definitely be recommended.

Recipe 15.5. Implementing SimpleXMLRPCServer Niceties

Credit: Rune Hansen

Problem

You are coding XML-RPC servers with the Python Standard Library SimpleXMLRPCServer class and want to ensure you're using the simple but useful idioms that can ease your coding, or give your servers more flexibility at no substantial cost to you.

Solution

Here are a few tweaks I generally use, to enhance my servers' usability, when I'm developing servers based on SimpleXMLRPCServer :

# give the base class a short, readable nickname
from SimpleXMLRPCServer import SimpleXMLRPCServer as BaseServer
class Server(BaseServer):
    def _ _init_ _(self, host, port):
        # accept separate hostname and portnumber and group them
        BaseServer._ _init_ _(self, (host, port))
    def server_bind(self):
        # allow fast restart of the server after it's killed
        import socket
        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        BaseServer.server_bind(self)
    allowedClientHosts = '127.0.0.1', '192.168.0.15',
    def verify_request(self, request, client_address):
        # forbid requests except from specific client hosts
        return client_address[0] in self.allowedClientHosts

Discussion

The recipe begins with a statement of the form from module import name as nickname , a Python idiom that is often handy for importing something under a short and usable nickname. It's certainly miles better than having to repeatedly write SimpleXMLRPCServer.SimpleXMLRPCServer after a simple import statement, or using the ill-advised construct from module import *, which mixes up all the namespaces and can often cause subtle and hard-to-find bugs .

The sole purpose of the _ _init_ _ statement of class Server is to accept host and port as separate parameters and group them into the required tuple. I find myself often writing such statements with the many Python functions and classes that require this address tuple grouping (your tastes, of course, may be different).

By default, a server socket belonging to a process that dies is kept busy for quite a while. Particularly during development, it is handy to kill such a process, edit the script, and restart immediately. For such an immediate restart to work, you must ensure the code of your server sets the SO_REUSEADDR option on the relevant socket, as the recipe's code does in its overridden method server_bind .

Last but not least, the recipe overrides verify_request in order to apply a simple check that refuses service except to requests coming from client hosts on a predefined list. This approach doesn't provide rock-solid security, but nevertheless, it is potentially useful. Again, it's particularly useful during development, to help avoid those cases where some other developer on the same LAN accidentally connects his client to the server I'm just developing, and we both experience puzzling problems until we figure out what's happened !