Struct glommio::net::UnixStream

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

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 fn buffered(self) -> UnixStream<Preallocated>

Creates a buffered Unix connection with default receive buffer.

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

Creates a buffered Unix connection with custom receive buffer.

impl<B: RxBuf> UnixStream<B>

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

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

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<B: Buffered + Unpin> AsyncBufRead for UnixStream<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 UnixStream<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 UnixStream<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 UnixStream<B>

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

Formats the value using the given formatter.

impl FromRawFd for UnixStream

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 UnixStream<B>

where __Origin<'__pin, B>: Unpin,