Struct TcpStream 

pub struct TcpStream<B: RxBuf = NonBuffered> { /* private fields */ }

A Tcp Stream of bytes. This can be used with AsyncRead, AsyncBufRead and AsyncWrite

Implementations

impl TcpStream

pub async fn connect<A: ToSocketAddrs>(addr: A) -> Result<TcpStream, ()>

Creates a TCP connection to the specified address.

Examples

use glommio::{net::TcpStream, LocalExecutor};

let ex = LocalExecutor::default();
ex.run(async move {
    TcpStream::connect("127.0.0.1:10000").await.unwrap();
})

pub async fn connect_timeout<A: ToSocketAddrs>( addr: A, duration: Duration, ) -> Result<TcpStream, ()>

Creates a TCP connection to the specified address with a timeout.

It is an error to pass a zero Duration to this function.

Timeouts are implemented using io_uring’s IORING_OP_LINK_TIMEOUT.

Examples

use glommio::{net::TcpStream, LocalExecutor};

use std::time::Duration;

let ex = LocalExecutor::default();
ex.run(async move {
    TcpStream::connect_timeout("127.0.0.1:10000", Duration::from_secs(10))
        .await
        .unwrap();
})

pub fn buffered(self) -> TcpStream<Preallocated>

Creates a buffered TCP connection with default receive buffer.

pub fn buffered_with<B: Buffered>(self, buf: B) -> TcpStream<B>

Creates a buffered TCP connection with custom receive buffer.

impl<B: RxBuf> TcpStream<B>

pub fn set_read_timeout(&self, dur: Option<Duration>) -> Result<(), ()>

Sets the read timeout to the timeout specified.

If the value specified is None, then read calls will block indefinitely. An Err is returned if the zero Duration is passed to this method.

Examples

let stream = TcpStream::connect("127.0.0.1:10000").await.unwrap();
stream
    .set_read_timeout(Some(Duration::from_secs(1)))
    .unwrap();

pub fn set_write_timeout(&self, dur: Option<Duration>) -> Result<(), ()>

Sets the write timeout to the timeout specified.

If the value specified is None, then write calls will block indefinitely. An Err is returned if the zero Duration is passed to this method.

let stream = TcpStream::connect("127.0.0.1:10000").await.unwrap();
stream
    .set_write_timeout(Some(Duration::from_secs(1)))
    .unwrap();

pub fn read_timeout(&self) -> Option<Duration>

Returns the read timeout of this socket.

pub fn write_timeout(&self) -> Option<Duration>

Returns the write timeout of this socket.

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

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

pub fn set_nodelay(&self, value: bool) -> Result<(), ()>

Sets the value of the TCP_NODELAY option on this socket.

If set, this option disables the Nagle algorithm. This means that segments are always sent as soon as possible, even if there is only a small amount of data. When not set, data is buffered until there is a sufficient amount to send out, thereby avoiding the frequent sending of small packets.

Examples

use glommio::{net::TcpStream, LocalExecutor};

let ex = LocalExecutor::default();
ex.run(async move {
    let stream = TcpStream::connect("127.0.0.1:10000").await.unwrap();
    stream.set_nodelay(true).expect("set_nodelay call failed");
});

pub fn nodelay(&self) -> Result<bool, ()>

Gets the TCP_NODELAY option on this socket.

For more information about this option, see TcpStream::set_nodelay.

Examples

use glommio::{net::TcpStream, LocalExecutor};

let ex = LocalExecutor::default();
ex.run(async move {
    let stream = TcpStream::connect("127.0.0.1:10000").await.unwrap();
    stream.set_nodelay(true).expect("set_nodelay call failed");
    assert_eq!(stream.nodelay().unwrap(), true);
});

pub fn ttl(&self) -> Result<u32, ()>

Gets the value of the IP_TTL option for this socket.

This option configures the time-to-live field that is used in every packet sent from this socket.

Examples

use glommio::{net::TcpStream, LocalExecutor};

let ex = LocalExecutor::default();
ex.run(async move {
    let stream = TcpStream::connect("127.0.0.1:10000").await.unwrap();
    stream.set_ttl(100).expect("could not set TTL");
    assert_eq!(stream.ttl().unwrap(), 100);
});

pub fn set_ttl(&self, ttl: u32) -> Result<(), ()>

Sets the value of the IP_TTL option for this socket.

This option configures the time-to-live field that is used in every packet sent from this socket.

Examples

use glommio::{net::TcpStream, LocalExecutor};

let ex = LocalExecutor::default();
ex.run(async move {
    let stream = TcpStream::connect("127.0.0.1:10000").await.unwrap();
    stream.set_ttl(100).expect("could not set TTL");
    assert_eq!(stream.ttl().unwrap(), 100);
});

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

Receives data on the socket from the remote address to which it is connected, without removing that data from the queue.

On success, returns the number of bytes peeked. Successive calls return the same data. This is accomplished by passing MSG_PEEK as a flag to the underlying recv system call.

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

Returns the socket address of the remote peer of this TCP connection.

Examples

use glommio::{net::TcpStream, LocalExecutor};

let ex = LocalExecutor::default();
ex.run(async move {
    let stream = TcpStream::connect("127.0.0.1:10000").await.unwrap();
    println!("My peer: {:?}", stream.peer_addr());
})

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

Returns the socket address of the local half of this TCP connection.

Examples

use glommio::{net::TcpStream, LocalExecutor};

let ex = LocalExecutor::default();
ex.run(async move {
    let stream = TcpStream::connect("127.0.0.1:10000").await.unwrap();
    println!("My peer: {:?}", stream.local_addr());
})

Trait Implementations

impl<B: RxBuf> AsRawFd for TcpStream<B>

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl<B: Buffered + Unpin> AsyncBufRead for TcpStream<B>

fn poll_fill_buf<'a>( self: Pin<&'a mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<&'a [u8]>>

Attempt to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read.

impl<B: RxBuf + Unpin> AsyncRead for TcpStream<B>

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, Error>>

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

impl<B: RxBuf + Unpin> AsyncWrite for TcpStream<B>

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, Error>>

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

impl<B: Debug + RxBuf> Debug for TcpStream<B>

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

Formats the value using the given formatter.

impl From<Socket> for TcpStream

fn from(socket: Socket) -> TcpStream

Converts to this type from the input type.

impl FromRawFd for TcpStream

unsafe fn from_raw_fd(fd: RawFd) -> Self

Constructs a new instance of Self from the given raw file descriptor.

impl<'__pin, B: RxBuf> Unpin for TcpStream<B>

where PinnedFieldsOf<__Origin<'__pin, B>>: Unpin,