Crate fibers_transport

Transport layer abstraction built on top of fibers crate.

Examples

UDP peers.

use bytecodec::bytes::{Utf8Decoder, Utf8Encoder};
use fibers_transport::{Transport, UdpTransport, UdpTransporter, wait_send, wait_recv};

type UdpPeer = UdpTransporter<Utf8Encoder, Utf8Decoder>;

// Binds peers.
let mut peer0 = fibers_global::execute(UdpPeer::bind("127.0.0.1:0".parse().unwrap()))?;
let peer1 = fibers_global::execute(UdpPeer::bind("127.0.0.1:0".parse().unwrap()))?;

// `peer0` sends a message to `peer1`.
peer0.start_send(peer1.local_addr(), "foo".to_owned())?;
let peer0 = fibers_global::execute(wait_send(peer0))?;

// `peer1` receives a message from `peer0`.
let (_, addr, item) = fibers_global::execute(wait_recv(peer1))?;
assert_eq!(addr, peer0.local_addr());
assert_eq!(item, "foo");

TCP server and client.

use bytecodec::fixnum::{U8Decoder, U8Encoder};
use factory::DefaultFactory;
use fibers_transport::{Transport, TcpListener, TcpTransport, TcpTransporter, wait_send, wait_recv};
use futures::Stream;

type TcpServer = TcpListener<DefaultFactory<U8Encoder>, DefaultFactory<U8Decoder>>;
type TcpClient = TcpTransporter<U8Encoder, U8Decoder>;

let server = fibers_global::execute(TcpServer::listen("127.0.0.1:0".parse().unwrap()))?;
let mut client = fibers_global::execute(TcpClient::connect(server.local_addr()))?;

// Sends a message to the server.
client.start_send((), 123)?;
let client = fibers_global::execute(wait_send(client))?;

// Receives the message from the client.
let (server, _) = fibers_global::execute(server.into_future()).map_err(|(e, _)| e)?;
let server = server.unwrap();
assert_eq!(server.peer_addr(), client.local_addr());

let (mut server, _, item) = fibers_global::execute(wait_recv(server))?;
assert_eq!(item, 123);

// Replies to the client.
server.start_send((), 9)?;
let _ = fibers_global::execute(wait_send(server))?;

// Receives the reply from the server.
let (_, _, item) = fibers_global::execute(wait_recv(client))?;
assert_eq!(item, 9);

Structs

Error

This crate specific Error type.

FixedPeerTransporter

An implementation of Transport used for communicating with a fixed peer.

RcTransporter

Shareable transporter.

TcpListener

TCP listener.

TcpListenerBuilder

TcpListener builder.

TcpTransporter

An implementation of Transport that uses TCP as the transport layer.

TcpTransporterBuilder

TcpTransporter builder.

UdpTransporter

An implementation of Transport that uses UDP as the transport layer.

UdpTransporterBuilder

UdpTransporter builder.

Enums

ErrorKind

Possible error kinds.

Traits

PeerAddr

Peer address.

TcpTransport

This trait indicates that the implementation implements TCP.

Transport

This trait allows for sending and receiving items between peers.

UdpTransport

This trait indicates that the implementation implements UDP.

Functions

wait_recv

Returns a future that waits until the given transporter receives an item from a peer.

wait_send

Returns a future that waits the transmission of the all outstanding items in the given transporter have been completed.

Type Aliases

PollRecv

The return type of the Transport::poll_recv method.

PollSend

The return type of the Transport::poll_send method.

Result

This crate specific Result type.