Struct UnixListener 

pub struct UnixListener { /* private fields */ }

A Unix socket which can accept connections from other Unix sockets.

You can accept a new connection by using the accept method. Alternatively UnixListener implements the Stream trait, which allows you to use the listener in places that want a stream. The stream will never return None and will also not yield the peer’s SocketAddr structure. Iterating over it is equivalent to calling accept in a loop.

Examples

use fd_queue::tokio::{UnixStream, UnixListener};
use futures_util::stream::StreamExt;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

// let path: Path = ...
let mut listener = UnixListener::bind(&path)?;

tokio::spawn(async move {
    let mut sock1 = UnixStream::connect(path).await?;
    sock1.write(b"Hello World!").await?;
});

let mut sock2 = listener.next().await.expect("Listener stream unexpectedly empty")?;

let mut buf = [0u8; 256];
sock2.read(&mut buf).await?;

assert!(buf.starts_with(b"Hello World!"));

Implementations

impl UnixListener

pub fn bind(path: impl AsRef<Path>) -> Result<UnixListener>

Creates a new UnixListener bound to the specified path.

This function will bind a UnixListener to the specified path and associate it with the default event loop’s handler.

Panics

This function panics if thread-local runtime is not set.

The runtime is usually set implicitly when this function is called from a future driven by a tokio runtime, otherwise runtime can be set explicitly with Handle::enter function.

Examples

use fd_queue::tokio::UnixListener;

// let path: Path = ...
let listener = UnixListener::bind(&path)?;

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

Returns the local socket address of this listener.

Examples

use fd_queue::tokio::UnixListener;

// let path: Path = ...
let listener = UnixListener::bind(&path)?;

let addr = listener.local_addr()?;

match addr.as_pathname() {
    Some(path) => println!("The local address is {}.", path.display()),
    None => println!("The local address does not have a pathname"),
}

pub fn take_error(&self) -> Result<Option<Error>>

Returns the value of the SO_ERROR option.

Examples

use fd_queue::tokio::UnixListener;

// let path: Path = ...
let listener = UnixListener::bind(&path)?;

let so_error = listener.take_error()?;

match so_error {
    Some(err) => println!("The SO_ERROR was {}.", err),
    None => println!("There was no SO_ERROR."),
}

pub async fn accept(&mut self) -> Result<(UnixStream, SocketAddr)>

Accepts a new incoming connection on this listener.

Panics

This function panics if thread-local runtime is not set.

The runtime is usually set implicitly when this function is called from a future driven by a tokio runtime, otherwise runtime can be set explicitly with Handle::enter function.

Examples

use fd_queue::tokio::UnixListener;

// let path: Path = ...
let mut listener = UnixListener::bind(&path)?;

let (sock, addr) = listener.accept().await?;

Trait Implementations

impl AsRawFd for UnixListener

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Debug for UnixListener

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

Formats the value using the given formatter.

impl From<UnixListener> for UnixListener

fn from(inner: TokioUnixListener) -> UnixListener

Converts to this type from the input type.

impl Stream for UnixListener

Produces a continuous stream of accepted connections.

This is the equivalent of calling accept() in a loop. It will never be ready with None.

Panics

Polling the stream panics if thread-local runtime is not set.

The runtime is usually set implicitly when this function is called from a future driven by a tokio runtime, otherwise runtime can be set explicitly with Handle::enter function.

Examples

use fd_queue::tokio::UnixListener;
use futures_util::stream::StreamExt;

// let path: Path = ...
let mut listener = UnixListener::bind(&path)?;

let sock = listener.next().await.expect("Listener stream unexpectedly empty");

type Item = Result<UnixStream, Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.