Struct UnixListener

Source

pub struct UnixListener { /* private fields */ }

Expand description

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(())
}

Implementations§

Source §

impl UnixListener

Source

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")?;

Source

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()?;

Source

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§

Source §

impl AsRawFd for UnixListener

Source §

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor. Read more

Source §

impl AsyncReady for UnixListener

Source §

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

Check if the stream can be read from.

Source §

type Ok = (UnixStream, SocketAddr)

The type of successful values yielded by this trait.

Source §

type Err = Error

The type of failures yielded by this trait.

Source §

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

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

Source §

impl Debug for UnixListener

Source §

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

Formats the value using the given formatter. Read more

Source §

impl TakeError for UnixListener

Source §

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);
}