Struct dusk_uds::UnixDomainSocket

pub struct UnixDomainSocket { /* fields omitted */ }

Boilerplate for UnixListener.

Will be converted from an implementation of ToString, or will receive a PathBuf via the constructor UnixDomainSocket::new.

Methods

impl UnixDomainSocket

pub fn new(path: PathBuf) -> Self

Default constructor. Receives a PathBuf and never fails, because no UnixListener::bind is performed.

pub fn get_state(&self) -> Result<State, IoError>

Returns the current State of the socket.

It's fallible in case the inner RwLock is poisoned.

Also, it's blocking, if there is a concurrent read/write for the state.

pub fn set_state(&self, state: State) -> Result<(), IoError>

Set the current State of the socket.

Same constraints as UnixDomainSocket::get_state

pub fn is_listening(&self) -> Result<bool, IoError>

Check if the current state is State::Listening.

Same constraints as UnixDomainSocket::get_state

pub fn receive_message(&self, message: Message) -> Result<(), IoError>

Will be called by the mpsc channel to process any incoming Message.

pub fn bind<F>(&self, handler: F) -> Result<(), IoError> where
    F: FnOnce(UnixStream, Sender<Message>),
    F: Send + 'static,
    F: Copy + 'static, 

Will remove the UnixDomainSocket::path, if it exists, so it cant bind properly to that location.

While the state is State::Listening, listen for incoming data.

Should it receive a Message with State::ShouldQuit, it will interrupt the loop only after the next iteration, because the message is handled asynchronously.

If the socket fails, the loop wont be interrupted, and the error will be reported to the log facade.

Minimal example:

use dusk_uds::UnixDomainSocket;

UnixDomainSocket::from("/dev/null").bind(move |_stream, _sender| {
    // Code goes here
}).unwrap_or(());

Trait Implementations

impl<T: ToString> From<T> for UnixDomainSocket

fn from(path: T) -> Self

Performs the conversion.