created_at2021-10-01 09:24:05.690612
updated_at2024-04-03 19:00:22.254226
description🦑 Remote multiplexed objects, channels, observable collections and RPC making remote interactions seamless. Provides multiple remote channels and RPC over TCP, TLS or any other transport.
Sebastian Urban



# Remoc 🦑 — remote multiplexed objects and channels Remoc makes remote interaction between Rust programs seamless and smooth. Over a [single underlying transport], such as TCP or TLS, it provides: * [multiple channels] of different types like [MPSC], [oneshot], [watch], etc., * [remote synchronization] primitives, * calling of [remote functions] and [trait methods on a remote object (RPC)], * [remotely observable collections]. Remoc is written in [100% safe Rust], builds upon [Tokio], works with any type and data format supported by [Serde] and does not depend on any particular transport type. [single underlying transport]: [multiple channels]: [MPSC]: [oneshot]: [watch]: [remote synchronization]: [remote functions]: [remotely observable collections]: [trait methods on a remote object (RPC)]: [100% safe Rust]: [Tokio]: [Serde]: [![ page](]( [![ page](]( [![Apache 2 license](]( [![codecov](]( ## Introduction A common pattern in Rust programs is to use channels to communicate between threads and async tasks. Setting up a channel is done in a single line and it largely avoids the need for shared state and the associated complexity. Remoc extends this programming model to distributed systems by providing channels that work seamlessly over remote connections. For that it uses Serde to serialize and deserialize data as it gets transmitted over an underlying transport, which might be a TCP network connection, a WebSocket, UNIX pipe, or even a serial link. Opening a new channel is straightforward, just send the sender or receiver half of the new channel over an existing channel, like you would do between local threads and tasks. All channels are multiplexed over the same remote connection, with data being transmitted in chunks to avoid one channel blocking another if a large message is transmitted. Building upon its remote channels, Remoc allows calling of remote functions and closures. Furthermore, a trait can be made remotely callable with automatically generated client and server implementations, resembling a classical remote procedure calling (RPC) model. ## Forward and backward compatibility Distributed systems often require that endpoints running different software versions interact. By utilizing a self-describing data format like JSON for encoding of your data for transport, you can ensure a high level of backward and forward compatibility. It is always possible to add new fields to enums and struct and utilize the `#[serde(default)]` attribute to provide default values for that field if it was sent by an older client that has no knowledge of it. Likewise additional, unknown fields are silently ignored when received, allowing you to extend the data format without disturbing legacy endpoints. Check the documentation of the employed data format for details. ## Crate features Most functionality of Remoc is gated by crate features. The following features are available: * `serde` enables the `codec` module and implements serialize and deserialize for all configuration and error types. * `rch` enables remote channels provided by the `rch` module. * `rfn` enables remote function calling provided by the `rfn` module. * `robj` enables remote object utilities provided by the `robj` module. * `robs` enables remotely observable collections provided by the `robs` module. * `rtc` enables remote trait calling provided by the `rtc` module. The meta-feature `full` enables all features from above but no codecs. The following features enable data formats for transmission: * `codec-bincode` provides the Bincode format. * `codec-ciborium` provides the CBOR format. * `codec-json` provides the JSON format. * `codec-message-pack` provides the MessagePack format. The feature `default-codec-*` selects the respective codec as default. At most one of this must be selected and this should only be used by applications, not libraries. The feature `full-codecs` enables all codecs. By default all features are enabled and the JSON codec is used as default. ## Supported Rust versions Remoc is built against the latest stable release. The minimum supported Rust version (MSRV) is 1.72. ## Example This is a short example; for a fully worked remote trait calling (RTC) example see the [examples directory]( In the following example the server listens on TCP port 9870 and the client connects to it. Then both ends establish a Remoc connection using `Connect::io()` over the TCP connection. The connection dispatchers are spawned onto new tasks and the `client()` and `server()` functions are called with the established base channel. Then, the client creates a new remote MPSC channel and sends it inside a count request to the server. The server receives the count request and counts on the provided channel. The client receives each counted number over the new channel. ```rust use std::net::Ipv4Addr; use tokio::net::{TcpStream, TcpListener}; use remoc::prelude::*; #[tokio::main] async fn main() { // For demonstration we run both client and server in // the same process. In real life connect_client() and // connect_server() would run on different machines. futures::join!(connect_client(), connect_server()); } // This would be run on the client. // It establishes a Remoc connection over TCP to the server. async fn connect_client() { // Wait for server to be ready. tokio::time::sleep(std::time::Duration::from_secs(1)).await; // Establish TCP connection. let socket = TcpStream::connect((Ipv4Addr::LOCALHOST, 9870)).await.unwrap(); let (socket_rx, socket_tx) = socket.into_split(); // Establish Remoc connection over TCP. // The connection is always bidirectional, but we can just drop // the unneeded receiver. let (conn, tx, _rx): (_, _, rch::base::Receiver<()>) = remoc::Connect::io(remoc::Cfg::default(), socket_rx, socket_tx) .await.unwrap(); tokio::spawn(conn); // Run client. client(tx).await; } // This would be run on the server. // It accepts a Remoc connection over TCP from the client. async fn connect_server() { // Listen for incoming TCP connection. let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 9870)).await.unwrap(); let (socket, _) = listener.accept().await.unwrap(); let (socket_rx, socket_tx) = socket.into_split(); // Establish Remoc connection over TCP. // The connection is always bidirectional, but we can just drop // the unneeded sender. let (conn, _tx, rx): (_, rch::base::Sender<()>, _) = remoc::Connect::io(remoc::Cfg::default(), socket_rx, socket_tx) .await.unwrap(); tokio::spawn(conn); // Run server. server(rx).await; } // User-defined data structures needs to implement Serialize // and Deserialize. #[derive(Debug, serde::Serialize, serde::Deserialize)] struct CountReq { up_to: u32, // Most Remoc types like channels can be included in serializable // data structures for transmission to remote endpoints. seq_tx: rch::mpsc::Sender, } // This would be run on the client. // It sends a count request to the server and receives each number // as it is counted over a newly established MPSC channel. async fn client(mut tx: rch::base::Sender) { // By sending seq_tx over an existing remote channel, a new remote // channel is automatically created and connected to the server. // This all happens inside the existing TCP connection. let (seq_tx, mut seq_rx) = rch::mpsc::channel(1); tx.send(CountReq { up_to: 4, seq_tx }).await.unwrap(); // Receive counted numbers over new channel. assert_eq!(seq_rx.recv().await.unwrap(), Some(0)); assert_eq!(seq_rx.recv().await.unwrap(), Some(1)); assert_eq!(seq_rx.recv().await.unwrap(), Some(2)); assert_eq!(seq_rx.recv().await.unwrap(), Some(3)); assert_eq!(seq_rx.recv().await.unwrap(), None); } // This would be run on the server. // It receives a count request from the client and sends each number // as it is counted over the MPSC channel sender provided by the client. async fn server(mut rx: rch::base::Receiver) { // Receive count request and channel sender to use for counting. while let Some(CountReq {up_to, seq_tx}) = rx.recv().await.unwrap() { for i in 0..up_to { // Send each counted number over provided channel. seq_tx.send(i).await.unwrap(); } } } ``` ## Sponsors Development of Remoc is partially sponsored by [ENQT GmbH]( [![ENQT Logo](]( ## License Remoc is licensed under the [Apache 2.0 license]. [Apache 2.0 license]: ### Contribution Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Remoc by you, shall be licensed as Apache 2.0, without any additional terms or conditions.
Commit count: 366

cargo fmt