Crate capnp_rpc 

An implementation of the Cap’n Proto remote procedure call protocol. Includes all Level 1 features.

Example

# Cap'n Proto schema
interface Foo {
    identity @0 (x: UInt32) -> (y: UInt32);
}

// Rust server defining an implementation of Foo.
struct FooImpl;
impl foo::Server for FooImpl {
    async fn identity(
        self: Rc<Self>,
        params: foo::IdentityParams,
        mut results: foo::IdentityResults
    ) -> Result<(), ::capnp::Error> {
        let x = params.get()?.get_x();
        results.get().set_y(x);
        Ok(())
    }
}

// Rust client calling a remote implementation of Foo.
let mut request = foo_client.identity_request();
request.get().set_x(123);
let promise = request.send().promise.and_then(|response| {
    println!("results = {}", response.get()?.get_y());
    Ok(())
});

For a more complete example, see https://github.com/capnproto/capnproto-rust/tree/master/capnp-rpc/examples/calculator

Modules

rpc_capnp

Code generated from rpc.capnp.

rpc_twoparty_capnp

Code generated from rpc-twoparty.capnp.

twoparty

An implementation of VatNetwork for the common case of a client-server connection.

Macros

pry

Like try!(), but for functions that return a Promise<T, E> rather than a Result<T, E>.

Structs

CapabilityServerSet

Collection of unwrappable capabilities.

Disconnector

A Future that can be run to disconnect an RpcSystem’s ConnectionState and wait for it to be closed.

ImbuedMessageBuilder

RpcSystem

A portal to objects available on the network.

Traits

Connection

A two-way RPC connection.

FlowController

Tracks a particular RPC stream in order to implement a flow control algorithm.

IncomingMessage

A message received from a VatNetwork.

OutgoingMessage

A message to be sent by a VatNetwork.

SetTarget

Trait implemented by the reconnecting client to set new connection out-of-band.

VatNetwork

Network facility between vats, it determines how to form connections between vats.

Functions

auto_reconnect

Creates a new client that reconnects when getting ErrorKind::Disconnected errors.

lazy_auto_reconnect

Creates a new client that lazily connect and also reconnects when getting ErrorKind::Disconnected errors.

new_client

Creates a new local RPC client of type C out of an object that implements a server trait S.

new_client_from_rc

Variant of new_client that works on an Rc<S>.

new_future_client

Creates a Client from a future that resolves to a Client.