Add semi-functional rpc example

examples/calculator-client.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+
+from __future__ import print_function
+import argparse
+import socket
+import capnp
+
+import calculator_capnp
+import rpc_capnp
+
+class PowerFunction(calculator_capnp.Calculator.Function.Server):
+    '''An implementation of the Function interface wrapping pow().  Note that
+    we're implementing this on the client side and will pass a reference to
+    the server.  The server will then be able to make calls back to the client.'''
+
+    def call(self, params):
+      return pow(params[0], params[1])
+
+def parse_args():
+    parser = argparse.ArgumentParser('Connects to the Calculator server at the given address and does some RPCs')
+    parser.add_argument("host", help="HOST:PORT")
+
+    return parser.parse_args()
+
+def main():
+    host, port = parse_args().host.split(':')
+
+    sock = socket.create_connection((host, port))
+    client = capnp.RpcClient(sock)
+
+    ref = rpc_capnp.SturdyRef.new_message()
+    ref.objectId.set_as_text('calculator')
+    calculator = client.restore(ref.objectId).cast_as(calculator_capnp.Calculator)
+
+    '''Make a request that just evaluates the literal value 123.
+
+    What's interesting here is that evaluate() returns a "Value", which is
+    another interface and therefore points back to an object living on the
+    server.  We then have to call read() on that object to read it.
+    However, even though we are making two RPC's, this block executes in
+    *one* network round trip because of promise pipelining:  we do not wait
+    for the first call to complete before we send the second call to the
+    server.'''
+
+    print('Evaluating a literal... ', end="")
+
+    request = calculator.evaluate_request()
+    request.expression.literal = 123
+
+    eval_promise = request.send()
+    read_promise = eval_promise.value.read()
+    response = read_promise.wait()
+    assert response.value == 123
+
+    print("PASS")
+
+    '''Make a request to evaluate 123 + 45 - 67.
+    #     //
+    The Calculator interface requires that we first call getOperator() to
+    get the addition and subtraction functions, then call evaluate() to use
+    them.  But, once again, we can get both functions, call evaluate(), and
+    then read() the result -- four RPCs -- in the time of *one* network
+    round trip, because of promise pipelining.'''
+
+    print("Using add and subtract... ", end='')
+    add = calculator.getOperator(op='add').func
+    subtract = calculator.getOperator(op='subtract').func
+
+    request = calculator.evaluate_request()
+    subtract_call = request.expression.init('call')
+    subtract_call.function = subtract
+    params = subtract_call.init('params', 2)
+    params[1] = 67.0
+
+if __name__ == '__main__':
+    main()
+