Crate asyncio

Expand description

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, Mutex};

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

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

fn main() {
  let ctx = &IoContext::new().unwrap();

  let ep = TcpEndpoint::new(IpAddrV4::loopback(), 12345);
  let sv = TcpListener::new(ctx, ep.protocol()).unwrap();
  sv.set_option(ReuseAddr::new(true)).unwrap();
  sv.bind(&ep).unwrap();
  sv.listen().unwrap();
  let sv = Arc::new(Mutex::new(sv));
  sv.lock().unwrap().async_accept(wrap(on_accept, &sv));

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

  ctx.run();
}

For example, TCP connection with coroutine code:

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

fn main() {
  let ctx = &IoContext::new().unwrap();

  let ep = TcpEndpoint::new(IpAddrV4::loopback(), 12345);
  let mut sv = TcpListener::new(ctx, ep.protocol()).unwrap();
  sv.set_option(ReuseAddr::new(true)).unwrap();
  sv.bind(&ep).unwrap();
  sv.listen().unwrap();

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

  IoContext::spawn(ctx, move |co| {
    let mut cl = TcpSocket::new(co.as_ctx(), ep.protocol()).unwrap();
    cl.async_connect(&ep, co.wrap()).unwrap();
    /* do something */
  });

  ctx.run();
}

Modules§

clock
generic
ip
local
posix
socket_base

Structs§

Coroutine: Context object that represents the currently executing coroutine.
DgramSocket: Provides a datagram-oriented socket.
IoContext
IoContextWork: The class to delaying until the stop of IoContext 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§

Signal: A list specifying POSIX categories of signal.

Traits§

AsIoContext
AsRawFd: A trait to extract the raw file descriptor from an underlying object.
Endpoint
GetSocketOption
Handler
IoControl
MatchCondition
Protocol
SetSocketOption
SockAddr
Socket
SocketOption
Stream

Functions§

raise
wrap: Provides a Arc handler to asynchronous operation.

Type Aliases§

RawFd: Raw file descriptors.
SteadyTimer: The monotonic clock’s timer.
SystemTimer: The system clock’s timer.

Crate asyncioCopy item path