fibers_transport
=================

[![Crates.io: fibers_transport](https://img.shields.io/crates/v/fibers_transport.svg)](https://crates.io/crates/fibers_transport)
[![Documentation](https://docs.rs/fibers_transport/badge.svg)](https://docs.rs/fibers_transport)
[![Actions Status](https://github.com/sile/fibers_transport/workflows/CI/badge.svg)](https://github.com/sile/fibers_transport/actions)
[![Coverage Status](https://coveralls.io/repos/github/sile/fibers_transport/badge.svg?branch=master)](https://coveralls.io/github/sile/fibers_transport?branch=master)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

Transport layer abstraction built on top of [`fibers`] crate.

[Documentation](https://docs.rs/fibers_transport)

[`fibers`]: https://github.com/dwango/fibers-rs


Examples
--------

UDP peers.

```rust
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.

```rust
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);
```