Struct runtime::net::TcpStream

pub struct TcpStream { /* fields omitted */ }

A TCP stream between a local and a remote socket.

A TcpStream can either be created by connecting to an endpoint, via the connect method, or by accepting a connection from a listener. It can be read or written to using the AsyncRead, AsyncWrite, and related extension traits in futures::io.

The connection will be closed when the value is dropped. The reading and writing portions of the connection can also be shut down individually with the shutdown method.

Examples

use futures::prelude::*;
use runtime::net::TcpStream;

#[runtime::main]
async fn main() -> Result<(), failure::Error> {
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
    println!("Connected to {}", &stream.peer_addr()?);

    let msg = "hello world";
    println!("<- {}", msg);
    stream.write_all(msg.as_bytes()).await?;

    let mut buf = vec![0u8; 1024];
    stream.read(&mut buf).await?;
    println!("-> {}\n", std::str::from_utf8(&mut buf)?);

    Ok(())
}

Methods

impl TcpStream

Important traits for ConnectFuture

impl Future for ConnectFuture type Output = Result<TcpStream>;

pub fn connect<A: ToSocketAddrs>(addr: A) -> ConnectFuture

Create a new TCP stream connected to the specified address.

This function will create a new TCP socket and attempt to connect it to the addr provided. The returned future will be resolved once the stream has successfully connected, or it will return an error if one occurs.

Examples

use runtime::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:0").await?;

pub fn local_addr(&self) -> Result<SocketAddr>

Returns the local address that this stream is connected to.

Examples

use runtime::net::TcpStream;
use std::net::{IpAddr, Ipv4Addr};

let stream = TcpStream::connect("127.0.0.1:8080").await?;

let expected = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
assert_eq!(stream.local_addr()?.ip(), expected);

pub fn peer_addr(&self) -> Result<SocketAddr>

Returns the remote address that this stream is connected to.

Examples

use runtime::net::TcpStream;
use std::net::{IpAddr, Ipv4Addr};

let stream = TcpStream::connect("127.0.0.1:8080").await?;

let expected = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
assert_eq!(stream.peer_addr()?.ip(), expected);

pub fn shutdown(&self, how: Shutdown) -> Result<()>

Shuts down the read, write, or both halves of this connection.

This function will cause all pending and future I/O on the specified portions to return immediately with an appropriate value (see the documentation of Shutdown).

Examples

use std::net::Shutdown;
use runtime::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.shutdown(Shutdown::Both)?;

Trait Implementations

impl Debug for TcpStream

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl AsRawFd for TcpStream

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl AsyncWrite for TcpStream

fn poll_write(
    self: Pin<&mut Self>,
    cx: &mut Context,
    buf: &[u8]
) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<()>>

Attempt to flush the object, ensuring that any buffered data reach their destination.

fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<()>>

Attempt to close the object.

fn poll_write_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context,
    bufs: &[IoSlice]
) -> Poll<Result<usize>>

Attempt to write bytes from bufs into the object using vectored IO operations.

impl AsyncRead for TcpStream

fn poll_read(
    self: Pin<&mut Self>,
    cx: &mut Context,
    buf: &mut [u8]
) -> Poll<Result<usize>>

Attempt to read from the AsyncRead into buf.

fn poll_read_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context,
    bufs: &mut [IoSliceMut]
) -> Poll<Result<usize>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.

unsafe fn initializer(&self) -> Initializer

Determines if this AsyncReader can work with buffers of uninitialized memory.