Struct romio::uds::UnixListener

pub struct UnixListener { /* fields omitted */ }

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

Examples

use romio::uds::{UnixListener, UnixStream};
use futures::prelude::*;

async fn say_hello(mut stream: UnixStream) {
    stream.write_all(b"Shall I hear more, or shall I speak at this?!").await;
}

async fn listen() -> Result<(), Box<dyn std::error::Error + 'static>> {
    let listener = UnixListener::bind("/tmp/sock")?;
    let mut incoming = listener.incoming();

    // accept connections and process them serially
    while let Some(stream) = incoming.next().await {
        say_hello(stream?).await;
    }
    Ok(())
}

Methods

impl UnixListener

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

Creates a new UnixListener bound to the specified path.

Examples

Create a Unix Domain Socket on /tmp/sock.

use romio::uds::UnixListener;

let socket = UnixListener::bind("/tmp/sock")?;

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

Returns the local socket address of this listener.

Examples

use romio::uds::UnixListener;

let socket = UnixListener::bind("/tmp/sock")?;
let addr = socket.local_addr()?;

pub fn incoming(self) -> Incoming

Consumes this listener, returning a stream of the sockets this listener accepts.

This method returns an implementation of the Stream trait which resolves to the sockets the are accepted on this listener.

Examples

use romio::uds::UnixListener;
use futures::prelude::*;

let listener = UnixListener::bind("/tmp/sock")?;
let mut incoming = listener.incoming();

// accept connections and process them serially
while let Some(stream) = incoming.next().await {
    match stream {
        Ok(stream) => {
            println!("new client!");
        },
        Err(e) => { /* connection failed */ }
    }
}

Trait Implementations

impl Debug for UnixListener

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

Formats the value using the given formatter.

impl AsRawFd for UnixListener

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl AsyncReady for UnixListener

type Ok = (UnixStream, SocketAddr)

The type of successful values yielded by this trait.

type Err = Error

The type of failures yielded by this trait.

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

Check if the stream can be read from.

fn poll_ready_unpin(
    &mut self,
    cx: &mut Context
) -> Poll<Result<Self::Ok, Self::Err>> where
    Self: Unpin, 

A convenience for calling AsyncReady::poll_ready on Unpin types.

impl TakeError for UnixListener

type Ok = Error

The type of successful values yielded by this trait.

type Err = Error

The type of failures yielded by this trait.

fn take_error(&self) -> Result<Option<Self::Ok>, Self::Err>

Returns the value of the SO_ERROR option.

Examples

use romio::uds::UnixListener;
use romio::raw::TakeError;

let listener = UnixListener::bind("/tmp/sock")?;
if let Ok(Some(err)) = listener.take_error() {
    println!("Got error: {:?}", err);
}