Struct TcpSocket

Source

pub struct TcpSocket(/* private fields */);

Expand description

The TCP socket type for the STD network stack.

Implementations§

Source §

impl TcpSocket

Source

pub const fn new(socket: Async<TcpStream>) -> Self

Create a new TCP socket from the given async TCP stream.

§Arguments

socket: The async TCP stream to wrap.

Source

pub fn release(self) -> Async<TcpStream>

Release the underlying async TCP stream.

Methods from Deref<Target = Async<TcpStream>>§

Source

pub fn get_ref(&self) -> &T

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();

Source

pub fn readable(&self) -> Readable<'_, T> ⓘ

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?;

Source

pub fn readable_owned(self: Arc<Async<T>>) -> ReadableOwned<T> ⓘ

Waits until the I/O handle is readable.

This method completes when a read operation on this I/O handle wouldn’t block.

Source

pub fn writable(&self) -> Writable<'_, T> ⓘ

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?;

Source

pub fn writable_owned(self: Arc<Async<T>>) -> WritableOwned<T> ⓘ

Waits until the I/O handle is writable.

This method completes when a write operation on this I/O handle wouldn’t block.

Source

pub fn poll_readable(&self, cx: &mut Context<'_>) -> Poll<Result<(), Error>>

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 std::future::poll_fn;
use std::net::TcpListener;

let mut listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?;

// Wait until a client can be accepted.
poll_fn(|cx| listener.poll_readable(cx)).await?;

Source

pub fn poll_writable(&self, cx: &mut Context<'_>) -> Poll<Result<(), Error>>

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 std::future::poll_fn;
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.
poll_fn(|cx| stream.poll_writable(cx)).await?;

Source

pub async fn read_with<R>( &self, op: impl FnMut(&T) -> Result<R, Error>, ) -> Result<R, Error>

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?;

Source

pub async fn write_with<R>( &self, op: impl FnMut(&T) -> Result<R, Error>, ) -> Result<R, Error>

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?;

Source

pub async fn peek(&self, buf: &mut [u8]) -> Result<usize, Error>

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?;