zerorpc

zerorpc is a flexible RPC implementation based on zeromq and messagepack.

Service APIs exposed with zerorpc are called "zeroservices".

zerorpc comes with a convenient script, "zerorpc-client", allowing to:

* expose Python modules without modifying a single line of code,

* call those modules remotely through the command line.

Create a server with a one-liner

Let's see zerorpc in action with a simple example. In a first terminal,

we will expose the Python "time" module::

.. note::

The bind address uses the zeromq address format. You are not limited

to TCP transport: you could as well specify ipc:///tmp/time to use

host-local sockets, for instance. "tcp://0:1234" is a short-hand to

"tcp://0.0.0.0:1234" and means "listen on TCP port 1234, accepting

connections on all IP addresses".

Call the server from the command-line

Now, in another terminal, call the exposed module::

Since the client usecase is the most common one, "--client" is the default

parameter, and you can remove it safely::

Moreover, since the most common usecase is to *connect* (as opposed to *bind*)

you can also omit "--connect"::

See remote service documentation

You can introspect the remote service; it happens automatically if you don't

specify the name of the function you want to call::

Specifying non-string arguments

Now, see what happens if we try to call a function expecting a non-string

argument::

That's because all command-line arguments are handled as strings. Don't worry,

we can specify any kind of argument using JSON encoding::

zeroworkers: reversing bind and connect

Sometimes, you don't want your client to connect to the server; you want

your server to act as a kind of worker, and connect to a hub or queue which

will dispatch requests. You can achieve this by swapping "--bind" and

"--connect"::

We now have "something" wanting to call the "localtime" function, and waiting

for a worker to connect to it. Let's start the worker::

The worker will connect to the listening client and ask him "what should I

do?"; the client will send the "localtime" function call; the worker will

execute it and return the result. The first program will display the

local time and exit. The worker will remain running.

Listening on multiple addresses

What if you want to run the same server on multiple addresses? Just repeat

the "--bind" option::

You can then connect to it using either "zerorpc-client tcp://0:1234" or

"zerorpc-client ipc:///tmp/time".

Wait, there is more! You can even mix "--bind" and "--connect". That means

that your server will wait for requests on a given address, *and* connect

as a worker on another. Likewise, you can specify "--connect" multiple times,

so your worker will connect to multiple queues. If a queue is not running,

it won't affect the worker (that's the magic of zeromq).

.. warning:: A client should probably not connect to multiple addresses!

Almost all other scenarios will work; but if you ask a client to connect

to multiple addresses, and at least one of them has no server at the end,

the client will ultimately block. A client can, however, bind multiple

addresses, and will dispatch requests to available workers. If you want

to connect to multiple remote servers for high availability purposes,

you insert something like HAProxy in the middle.