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 Definitions

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.