Struct glommio::net::UnixStream

pub struct UnixStream { /* fields omitted */ }

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

Implementations

impl UnixStream

pub fn pair() -> Result<(UnixStream, UnixStream), ()>

Creates an unnamed pair of connected Unix stream sockets.

Examples

use futures_lite::io::{AsyncReadExt, AsyncWriteExt};
use glommio::{net::UnixStream, LocalExecutor};

let ex = LocalExecutor::default();
ex.run(async move {
    let (mut p1, mut p2) = UnixStream::pair().unwrap();
    let sz = p1.write(&[65u8; 1]).await.unwrap();
    let mut buf = [0u8; 1];
    let sz = p2.read(&mut buf).await.unwrap();
})

pub async fn connect<A: AsRef<Path>>(addr: A) -> Result<UnixStream, ()>

Creates a Unix connection to the specified endpoint.

Examples

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

let ex = LocalExecutor::default();
ex.run(async move {
    UnixStream::connect("/tmp/named").await.unwrap();
})

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

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

pub fn set_buffer_size(&mut self, buffer_size: usize)

Sets the buffer size used on the receive path

pub fn buffer_size(&mut self) -> usize

gets the buffer size used

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 Unix connection.

Examples

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

let ex = LocalExecutor::default();
ex.run(async move {
    let stream = UnixStream::connect("/tmp/named").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 Unix connection.

Examples

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

let ex = LocalExecutor::default();
ex.run(async move {
    let stream = UnixStream::connect("/tmp/named").await.unwrap();
    println!("My peer: {:?}", stream.local_addr());
})

Trait Implementations

impl AsyncBufRead for UnixStream

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 AsyncRead for UnixStream

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 AsyncWrite for UnixStream

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 Debug for UnixStream

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

Formats the value using the given formatter.

impl<'__pin> Unpin for UnixStream where
    __Origin<'__pin>: Unpin,