Crate asyncio

The asyncio is Asynchronous Input/Output library, that made based on boost::asio c++ library.

Usage

This crate is on github and can be used by adding asyncio to the dependencies in your project's Cargo.toml.

[dependencies]
rust_asio = "*"

And this in your crate root:

extern crate asyncio;

For example, TCP asynchronous connection code:

use asyncio::*;
use asyncio::ip::*;
use asyncio::socket_base::*;
use std::io;
use std::sync::Arc;

fn on_accept(sv: Arc<TcpListener>, res: io::Result<(TcpSocket, TcpEndpoint)>) {
  match res {
    Ok((soc, ep)) => { /* do something */ },
    Err(err) => panic!("{}", err),
  }
}

fn on_connect(cl: Arc<TcpSocket>, res: io::Result<()>) {
  match res {
    Ok(_) => { /* do something */ },
    Err(err) => panic!("{}", err),
  }
}

fn main() {
  let io = &IoService::new();

  let ep = TcpEndpoint::new(Tcp::v4(), 12345);
  let sv = Arc::new(TcpListener::new(io, ep.protocol()).unwrap());
  sv.set_option(ReuseAddr::new(true)).unwrap();
  sv.bind(&ep).unwrap();
  sv.listen().unwrap();
  sv.async_accept(wrap(on_accept, &sv));

  let cl = Arc::new(TcpSocket::new(io, ep.protocol()).unwrap());
  cl.async_connect(&ep, wrap(on_connect, &cl));

  io.run();
}

For example, TCP connection with coroutine code:

use asyncio::*;
use asyncio::ip::*;
use asyncio::socket_base::*;

fn main() {
  let io = &IoService::new();

  let ep = TcpEndpoint::new(Tcp::v4(), 12345);
  let sv = TcpListener::new(io, ep.protocol()).unwrap();
  sv.set_option(ReuseAddr::new(true)).unwrap();
  sv.bind(&ep).unwrap();
  sv.listen().unwrap();

  IoService::spawn(io, move |co| {
    let (soc, ep): (TcpSocket, TcpEndpoint) = sv.async_accept(co.wrap()).unwrap();
    /* do something */
  });

  IoService::spawn(io, move |co| {
    let cl = TcpSocket::new(co.io_service(), ep.protocol()).unwrap();
    cl.async_connect(&ep, co.wrap()).unwrap();
    /* do something */
  });

  io.run();
}

Modules

clock
generic
ip
local
posix
serial_port
socket_base

Structs

Coroutine	Context object that represents the currently executing coroutine.
DgramSocket	Provides a datagram-oriented socket.
IoService	Provides core I/O functionality.
IoServiceWork	The class to delaying until the stop of IoService is dropped.
RawSocket	Provides a raw-oriented socket.
SeqPacketSocket	Provides a sequenced packet socket.
SignalSet	Provides a signal handing.
SocketListener	Provides an ability to accept new connections.
Strand	Provides serialized data and handler execution.
StrandImmutable	Provides immutable data and handler execution.
StreamBuf	Automatically resizing buffer.
StreamSocket	Provides a stream-oriented socket.
WaitableTimer	Provides waitable timer functionality.

Enums

Shutdown	Possible values which can be passed to the shutdown method.
Signal	A list specifying POSIX categories of signal.

Traits

Endpoint
FromRawFd
GetSocketOption
Handler
IoControl
IoObject	Traits to the associated with IoService.
MatchCondition
Protocol
SetSocketOption
SockAddr
SocketOption
Stream

Functions

async_read_until
async_write_until
raise
read_until
wrap	Provides a Arc handler to asynchronous operation.
write_until

Type Definitions

SteadyTimer	The monotonic clock's timer.
SystemTimer	The system clock's timer.