Struct async_io::Async [−][src]
pub struct Async<T> { /* fields omitted */ }
Expand description
Async adapter for I/O types.
This type puts an I/O handle into non-blocking mode, registers it in epoll/kqueue/event ports/wepoll, and then provides an async interface for it.
Caveats
Async
is a low-level primitive, and as such it comes with some caveats.
For higher-level primitives built on top of Async
, look into async-net
or
async-process
(on Unix).
Supported types
Async
supports all networking types, as well as some OS-specific file descriptors like
timerfd and inotify.
However, do not use Async
with types like File
,
Stdin
, Stdout
, or Stderr
because all operating systems have issues with them when put in non-blocking mode.
Concurrent I/O
Note that &Async<T>
implements [AsyncRead
] and [AsyncWrite
] if &T
implements those traits, which means tasks can concurrently read and write using shared
references.
But there is a catch: only one task can read a time, and only one task can write at a time. It is okay to have two tasks where one is reading and the other is writing at the same time, but it is not okay to have two tasks reading at the same time or writing at the same time. If you try to do that, conflicting tasks will just keep waking each other in turn, thus wasting CPU time.
Besides [AsyncRead
] and [AsyncWrite
], this caveat also applies to
poll_readable()
and
poll_writable()
.
However, any number of tasks can be concurrently calling other methods like
readable()
or read_with()
.
Closing
Closing the write side of Async
with close()
simply flushes. If you want to shutdown a TCP or Unix socket, use
Shutdown
.
Examples
Connect to a server and echo incoming messages back to the server:
use async_io::Async; use futures_lite::io; use std::net::TcpStream; // Connect to a local server. let stream = Async::<TcpStream>::connect(([127, 0, 0, 1], 8000)).await?; // Echo all messages from the read side of the stream into the write side. io::copy(&stream, &stream).await?;
You can use either predefined async methods or wrap blocking I/O operations in
Async::read_with()
, Async::read_with_mut()
, Async::write_with()
, and
Async::write_with_mut()
:
use async_io::Async; use std::net::TcpListener; let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?; // These two lines are equivalent: let (stream, addr) = listener.accept().await?; let (stream, addr) = listener.read_with(|inner| inner.accept()).await?;
Implementations
Creates an async I/O handle.
This method will put the handle in non-blocking mode and register it in epoll/kqueue/event ports/wepoll.
On Unix systems, the handle must implement AsRawFd
, while on Windows it must implement
AsRawSocket
.
Examples
use async_io::Async; use std::net::{SocketAddr, TcpListener}; let listener = TcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0)))?; let listener = Async::new(listener)?;
Gets a reference to the inner I/O handle.
Examples
use async_io::Async; use std::net::TcpListener; let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?; let inner = listener.get_ref();
Gets a mutable reference to the inner I/O handle.
Examples
use async_io::Async; use std::net::TcpListener; let mut listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?; let inner = listener.get_mut();
Unwraps the inner I/O handle.
This method will not put the I/O handle back into blocking mode.
Examples
use async_io::Async; use std::net::TcpListener; let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?; let inner = listener.into_inner()?; // Put the listener back into blocking mode. inner.set_nonblocking(false)?;
Waits until the I/O handle is readable.
This method completes when a read operation on this I/O handle wouldn’t block.
Examples
use async_io::Async; use std::net::TcpListener; let mut listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?; // Wait until a client can be accepted. listener.readable().await?;
pub fn readable_owned(self: Arc<Self>) -> ReadableOwned<T>ⓘNotable traits for ReadableOwned<T>
impl<T> Future for ReadableOwned<T> type Output = Result<()>;
pub fn readable_owned(self: Arc<Self>) -> ReadableOwned<T>ⓘNotable traits for ReadableOwned<T>
impl<T> Future for ReadableOwned<T> type Output = Result<()>;
Waits until the I/O handle is readable.
This method completes when a read operation on this I/O handle wouldn’t block.
Waits until the I/O handle is writable.
This method completes when a write operation on this I/O handle wouldn’t block.
Examples
use async_io::Async; use std::net::{TcpStream, ToSocketAddrs}; let addr = "example.com:80".to_socket_addrs()?.next().unwrap(); let stream = Async::<TcpStream>::connect(addr).await?; // Wait until the stream is writable. stream.writable().await?;
pub fn writable_owned(self: Arc<Self>) -> WritableOwned<T>ⓘNotable traits for WritableOwned<T>
impl<T> Future for WritableOwned<T> type Output = Result<()>;
pub fn writable_owned(self: Arc<Self>) -> WritableOwned<T>ⓘNotable traits for WritableOwned<T>
impl<T> Future for WritableOwned<T> type Output = Result<()>;
Waits until the I/O handle is writable.
This method completes when a write operation on this I/O handle wouldn’t block.
Polls the I/O handle for readability.
When this method returns Poll::Ready
, that means the OS has delivered an event
indicating readability since the last time this task has called the method and received
Poll::Pending
.
Caveats
Two different tasks should not call this method concurrently. Otherwise, conflicting tasks will just keep waking each other in turn, thus wasting CPU time.
Note that the [AsyncRead
] implementation for Async
also uses this method.
Examples
use async_io::Async; use futures_lite::future; use std::net::TcpListener; let mut listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?; // Wait until a client can be accepted. future::poll_fn(|cx| listener.poll_readable(cx)).await?;
Polls the I/O handle for writability.
When this method returns Poll::Ready
, that means the OS has delivered an event
indicating writability since the last time this task has called the method and received
Poll::Pending
.
Caveats
Two different tasks should not call this method concurrently. Otherwise, conflicting tasks will just keep waking each other in turn, thus wasting CPU time.
Note that the [AsyncWrite
] implementation for Async
also uses this method.
Examples
use async_io::Async; use futures_lite::future; use std::net::{TcpStream, ToSocketAddrs}; let addr = "example.com:80".to_socket_addrs()?.next().unwrap(); let stream = Async::<TcpStream>::connect(addr).await?; // Wait until the stream is writable. future::poll_fn(|cx| stream.poll_writable(cx)).await?;
Performs a read operation asynchronously.
The I/O handle is registered in the reactor and put in non-blocking mode. This method
invokes the op
closure in a loop until it succeeds or returns an error other than
io::ErrorKind::WouldBlock
. In between iterations of the loop, it waits until the OS
sends a notification that the I/O handle is readable.
The closure receives a shared reference to the I/O handle.
Examples
use async_io::Async; use std::net::TcpListener; let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?; // Accept a new client asynchronously. let (stream, addr) = listener.read_with(|l| l.accept()).await?;
Performs a read operation asynchronously.
The I/O handle is registered in the reactor and put in non-blocking mode. This method
invokes the op
closure in a loop until it succeeds or returns an error other than
io::ErrorKind::WouldBlock
. In between iterations of the loop, it waits until the OS
sends a notification that the I/O handle is readable.
The closure receives a mutable reference to the I/O handle.
Examples
use async_io::Async; use std::net::TcpListener; let mut listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?; // Accept a new client asynchronously. let (stream, addr) = listener.read_with_mut(|l| l.accept()).await?;
Performs a write operation asynchronously.
The I/O handle is registered in the reactor and put in non-blocking mode. This method
invokes the op
closure in a loop until it succeeds or returns an error other than
io::ErrorKind::WouldBlock
. In between iterations of the loop, it waits until the OS
sends a notification that the I/O handle is writable.
The closure receives a shared reference to the I/O handle.
Examples
use async_io::Async; use std::net::UdpSocket; let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 8000))?; socket.get_ref().connect("127.0.0.1:9000")?; let msg = b"hello"; let len = socket.write_with(|s| s.send(msg)).await?;
Performs a write operation asynchronously.
The I/O handle is registered in the reactor and put in non-blocking mode. This method
invokes the op
closure in a loop until it succeeds or returns an error other than
io::ErrorKind::WouldBlock
. In between iterations of the loop, it waits until the OS
sends a notification that the I/O handle is writable.
The closure receives a mutable reference to the I/O handle.
Examples
use async_io::Async; use std::net::UdpSocket; let mut socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 8000))?; socket.get_ref().connect("127.0.0.1:9000")?; let msg = b"hello"; let len = socket.write_with_mut(|s| s.send(msg)).await?;
Creates a TCP listener bound to the specified address.
Binding with port number 0 will request an available port from the OS.
Examples
use async_io::Async; use std::net::TcpListener; let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?; println!("Listening on {}", listener.get_ref().local_addr()?);
Accepts a new incoming TCP connection.
When a connection is established, it will be returned as a TCP stream together with its remote address.
Examples
use async_io::Async; use std::net::TcpListener; let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 8000))?; let (stream, addr) = listener.accept().await?; println!("Accepted client: {}", addr);
Returns a stream of incoming TCP connections.
The stream is infinite, i.e. it never stops with a None
.
Examples
use async_io::Async; use futures_lite::{pin, stream::StreamExt}; use std::net::TcpListener; let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 8000))?; let incoming = listener.incoming(); pin!(incoming); while let Some(stream) = incoming.next().await { let stream = stream?; println!("Accepted client: {}", stream.get_ref().peer_addr()?); }
Creates a TCP connection to the specified address.
Examples
use async_io::Async; use std::net::{TcpStream, ToSocketAddrs}; let addr = "example.com:80".to_socket_addrs()?.next().unwrap(); let stream = Async::<TcpStream>::connect(addr).await?;
Reads data from the stream without removing it from the buffer.
Returns the number of bytes read. Successive calls of this method read the same data.
Examples
use async_io::Async; use futures_lite::{io::AsyncWriteExt, stream::StreamExt}; use std::net::{TcpStream, ToSocketAddrs}; let addr = "example.com:80".to_socket_addrs()?.next().unwrap(); let mut stream = Async::<TcpStream>::connect(addr).await?; stream .write_all(b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n") .await?; let mut buf = [0u8; 1024]; let len = stream.peek(&mut buf).await?;
Creates a UDP socket bound to the specified address.
Binding with port number 0 will request an available port from the OS.
Examples
use async_io::Async; use std::net::UdpSocket; let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 0))?; println!("Bound to {}", socket.get_ref().local_addr()?);
Receives a single datagram message.
Returns the number of bytes read and the address the message came from.
This method must be called with a valid byte slice of sufficient size to hold the message. If the message is too long to fit, excess bytes may get discarded.
Examples
use async_io::Async; use std::net::UdpSocket; let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 8000))?; let mut buf = [0u8; 1024]; let (len, addr) = socket.recv_from(&mut buf).await?;
Receives a single datagram message without removing it from the queue.
Returns the number of bytes read and the address the message came from.
This method must be called with a valid byte slice of sufficient size to hold the message. If the message is too long to fit, excess bytes may get discarded.
Examples
use async_io::Async; use std::net::UdpSocket; let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 8000))?; let mut buf = [0u8; 1024]; let (len, addr) = socket.peek_from(&mut buf).await?;
Sends data to the specified address.
Returns the number of bytes writen.
Examples
use async_io::Async; use std::net::UdpSocket; let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 0))?; let addr = socket.get_ref().local_addr()?; let msg = b"hello"; let len = socket.send_to(msg, addr).await?;
Receives a single datagram message from the connected peer.
Returns the number of bytes read.
This method must be called with a valid byte slice of sufficient size to hold the message. If the message is too long to fit, excess bytes may get discarded.
The connect
method connects this socket to a remote address.
This method will fail if the socket is not connected.
Examples
use async_io::Async; use std::net::UdpSocket; let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 8000))?; socket.get_ref().connect("127.0.0.1:9000")?; let mut buf = [0u8; 1024]; let len = socket.recv(&mut buf).await?;
Receives a single datagram message from the connected peer without removing it from the queue.
Returns the number of bytes read and the address the message came from.
This method must be called with a valid byte slice of sufficient size to hold the message. If the message is too long to fit, excess bytes may get discarded.
The connect
method connects this socket to a remote address.
This method will fail if the socket is not connected.
Examples
use async_io::Async; use std::net::UdpSocket; let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 8000))?; socket.get_ref().connect("127.0.0.1:9000")?; let mut buf = [0u8; 1024]; let len = socket.peek(&mut buf).await?;
Sends data to the connected peer.
Returns the number of bytes written.
The connect
method connects this socket to a remote address.
This method will fail if the socket is not connected.
Examples
use async_io::Async; use std::net::UdpSocket; let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 8000))?; socket.get_ref().connect("127.0.0.1:9000")?; let msg = b"hello"; let len = socket.send(msg).await?;
Creates a UDS listener bound to the specified path.
Examples
use async_io::Async; use std::os::unix::net::UnixListener; let listener = Async::<UnixListener>::bind("/tmp/socket")?; println!("Listening on {:?}", listener.get_ref().local_addr()?);
Accepts a new incoming UDS stream connection.
When a connection is established, it will be returned as a stream together with its remote address.
Examples
use async_io::Async; use std::os::unix::net::UnixListener; let listener = Async::<UnixListener>::bind("/tmp/socket")?; let (stream, addr) = listener.accept().await?; println!("Accepted client: {:?}", addr);
Returns a stream of incoming UDS connections.
The stream is infinite, i.e. it never stops with a None
item.
Examples
use async_io::Async; use futures_lite::{pin, stream::StreamExt}; use std::os::unix::net::UnixListener; let listener = Async::<UnixListener>::bind("/tmp/socket")?; let incoming = listener.incoming(); pin!(incoming); while let Some(stream) = incoming.next().await { let stream = stream?; println!("Accepted client: {:?}", stream.get_ref().peer_addr()?); }
Creates a UDS stream connected to the specified path.
Examples
use async_io::Async; use std::os::unix::net::UnixStream; let stream = Async::<UnixStream>::connect("/tmp/socket").await?;
Creates an unnamed pair of connected UDS stream sockets.
Examples
use async_io::Async; use std::os::unix::net::UnixStream; let (stream1, stream2) = Async::<UnixStream>::pair()?;
Creates a UDS datagram socket bound to the specified path.
Examples
use async_io::Async; use std::os::unix::net::UnixDatagram; let socket = Async::<UnixDatagram>::bind("/tmp/socket")?;
Creates a UDS datagram socket not bound to any address.
Examples
use async_io::Async; use std::os::unix::net::UnixDatagram; let socket = Async::<UnixDatagram>::unbound()?;
Creates an unnamed pair of connected Unix datagram sockets.
Examples
use async_io::Async; use std::os::unix::net::UnixDatagram; let (socket1, socket2) = Async::<UnixDatagram>::pair()?;
Receives data from the socket.
Returns the number of bytes read and the address the message came from.
Examples
use async_io::Async; use std::os::unix::net::UnixDatagram; let socket = Async::<UnixDatagram>::bind("/tmp/socket")?; let mut buf = [0u8; 1024]; let (len, addr) = socket.recv_from(&mut buf).await?;
Sends data to the specified address.
Returns the number of bytes written.
Examples
use async_io::Async; use std::os::unix::net::UnixDatagram; let socket = Async::<UnixDatagram>::unbound()?; let msg = b"hello"; let addr = "/tmp/socket"; let len = socket.send_to(msg, addr).await?;
Receives data from the connected peer.
Returns the number of bytes read and the address the message came from.
The connect
method connects this socket to a remote address.
This method will fail if the socket is not connected.
Examples
use async_io::Async; use std::os::unix::net::UnixDatagram; let socket = Async::<UnixDatagram>::bind("/tmp/socket1")?; socket.get_ref().connect("/tmp/socket2")?; let mut buf = [0u8; 1024]; let len = socket.recv(&mut buf).await?;
Sends data to the connected peer.
Returns the number of bytes written.
The connect
method connects this socket to a remote address.
This method will fail if the socket is not connected.
Examples
use async_io::Async; use std::os::unix::net::UnixDatagram; let socket = Async::<UnixDatagram>::bind("/tmp/socket1")?; socket.get_ref().connect("/tmp/socket2")?; let msg = b"hello"; let len = socket.send(msg).await?;
Trait Implementations
Attempt to read from the AsyncRead
into buf
. Read more
Attempt to read from the AsyncRead
into buf
. Read more
Auto Trait Implementations
impl<T> RefUnwindSafe for Async<T> where
T: RefUnwindSafe,
impl<T> UnwindSafe for Async<T> where
T: UnwindSafe,
Blanket Implementations
Reads some bytes from the byte stream. Read more
fn read_vectored(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self> where
Self: Unpin,
fn read_vectored(
&'a mut self,
bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self> where
Self: Unpin,
fn read_to_end(
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEndFuture<'a, Self> where
Self: Unpin,
fn read_to_end(
&'a mut self,
buf: &'a mut Vec<u8, Global>
) -> ReadToEndFuture<'a, Self> where
Self: Unpin,
fn read_to_string(
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self> where
Self: Unpin,
fn read_to_string(
&'a mut self,
buf: &'a mut String
) -> ReadToStringFuture<'a, Self> where
Self: Unpin,
Reads the exact number of bytes required to fill buf
. Read more
Creates an adapter which will read at most limit
bytes from it. Read more
Creates an adapter which will chain this stream with another. Read more
Writes some bytes into the byte stream. Read more
fn write_vectored(
&'a mut self,
bufs: &'a [IoSlice<'a>]
) -> WriteVectoredFuture<'a, Self> where
Self: Unpin,
fn write_vectored(
&'a mut self,
bufs: &'a [IoSlice<'a>]
) -> WriteVectoredFuture<'a, Self> where
Self: Unpin,
Writes an entire buffer into the byte stream. Read more
Flushes the stream to ensure that all buffered contents reach their destination. Read more
Closes the writer. Read more
Mutably borrows from an owned value. Read more