transport

transport

The transport module is the abstract transport layer used by Shape’s distributed-execution primitives (state capture/serialize + remote function calls). It exposes one-shot request/response, persistent connections, and built-in TCP / QUIC factories.

Import

use std::core::transport

Types

Transport

pub type Transport {
    name: string,
}

Created via transport::tcp() or transport::quic().

Connection

pub type Connection {
    destination: string,
    is_open: bool,
}

Returned by transport::connect. Has destination (the remote address) and is_open (current connection state).

One-Shot Request

transport::send(transport, destination, payload) -> Result<Vec<int>, string>

Send a payload and await a single response.

use std::core::transport

let tcp = transport::tcp()
match transport::send(tcp, "127.0.0.1:9527", request_bytes) {
    Ok(response) => print(f"got {response.length} bytes"),
    Err(e) => print(f"failed: {e}"),
}

Persistent Connections

transport::connect(transport, destination) -> Result<Connection, string>

Open a persistent connection.

transport::connection_send(conn, payload) -> Result<(), string>

Send data over an open connection.

transport::connection_recv(conn, timeout?) -> Result<Vec<int>, string>

Receive data. timeout is in milliseconds; None waits indefinitely.

transport::connection_close(conn) -> Result<(), string>

Close an open connection.

use std::core::transport

let tcp = transport::tcp()
let conn = transport::connect(tcp, "10.0.0.5:9527")?
transport::connection_send(conn, payload)?
let reply = transport::connection_recv(conn, 5000)?
transport::connection_close(conn)?

Transport Factories

transport::tcp() -> Transport

Plain TCP transport.

transport::quic() -> Transport

Multiplexed, encrypted QUIC transport.

See Also

• state — state::serialize produces the byte payloads transport carries
• remote — @remote annotation built on top of transport
• Wire Protocol — frame format, compression, blob negotiation