Crate fizyr_rpc

Rust implementation of the Fizyr RPC procotol.

The Fizyr RPC protocol is a request/response protocol, with bi-directional feedback as long as a request is open. Additionally, you can send individual stream messages that do not initiate a request.

Overview

Peer and PeerHandle

As a user of the library, you will mostly be using the PeerHandle object. The PeerHandle is used to interact with a remote peer. It is used to send and receive requests and stream messages. It can also be split in a PeerReadHandle and a PeerWriteHandle, to allow moving the handles into different tasks. The write handle can also be cloned and used in multiple tasks.

To obtain a PeerHandle, you can call Peer::connect(). This will connect to a remote server and spawn a background task to read and write messages over the connection. If you need full control over tasks, you can instead create a Peer object and call Peer::run() manually.

Server

The Server struct is used to accept incoming connections and gives you a PeerHandle for each incoming connection. You can then use the handle to process incoming messages and to send messages to the peer. Usually, you will want to spawn a task for each accepted connection that handles the communication.

Transports

Each peer internally uses a Transport. The transport is responsible for reading and writing raw messages. By abstracting away the message transport, the library can expose a single generic Peer and Server struct.

There are different transports for different socket types. Different transports may also use different types as message body. For example, the TcpTransport and UnixStreamTransport use messages with a StreamBody. This StreamBody body type contains raw bytes.

The UnixSeqpacketTransport has messages with a UnixBody, which allows you to embed file descriptors with each message.

Features

The library uses features to avoid unnecessarily large dependency trees. Each feature corresponds to a different transport type. None of the features are enabled by default. Currently, the library has these features:

• tcp: for the TcpTransport
• unix-stream: for the UnixStreamTransport
• unix-seqpacket: for the UnixSeqpacketTransport

Example

use fizyr_rpc::{TcpPeer, StreamConfig};

let mut peer = TcpPeer::connect("localhost:1337", StreamConfig::default()).await?;
let mut request = peer.send_request(1, &b"Hello World!"[..]).await?;

while let Some(update) = request.recv_update().await? {
    let body = std::str::from_utf8(&update.body)?;
    eprintln!("Received update: {}", body);
}

let response = request.recv_response().await?;
let body = std::str::from_utf8(&response.body)?;
eprintln!("Received response: {}", body);

Modules

error	Error types.
service_id	Well-known service IDs.
transport	Transport traits and concrete implementations.
util	Utility traits.

Structs

Message	A complete RPC message, including header and body.
MessageHeader	A message header.
Peer	Peer read/write loop.
PeerHandle	Handle to a peer.
PeerReadHandle	Handle to receive messages from a peer.
PeerWriteHandle	Handle to send messages to a peer.
ReceivedRequest	A handle for a received request.
SentRequest	A handle for a sent request.
Server	Server that spawns peers for all accepted connections.
StreamBody	The body of a stream message.
StreamConfig	Configuration for a byte-stream transport.
UnixBody	Body for the unix tranport.
UnixConfig	Configuration for Unix datagram transports.

Enums

Incoming	An incoming request or stream message.
MessageType	The type of a message.
Outgoing	An outgoing request or stream message.

Constants

HEADER_LEN	The encoded length of a message header.
MAX_PAYLOAD_LEN	The maximum length of a message body.

Traits

Body	Trait for types that can be used as message body.
ServerListener	Helper trait for Server.

Type Definitions

TcpPeer	Peer using the TCP transport.
TcpServer	Server for TCP sockets.
TcpTransport	Message transport for TCP.
UnixSeqpacketPeer	Peer using the Unix seqpacket transport.
UnixSeqpacketServer	Server for Unix seqpacket sockets.
UnixSeqpacketTransport	Message transport for Unix seqpacket sockets.
UnixStreamPeer	Peer using the Unix stream transport.
UnixStreamServer	Server for Unix stream sockets.
UnixStreamTransport	Message transport for Unix stream sockets.