Struct compio_fs::pipe::Sender

pub struct Sender { /* private fields */ }

Available on Unix only.

Writing end of a Unix pipe.

It can be constructed from a FIFO file with OpenOptions::open_sender.

Opening a named pipe for writing involves a few steps. Call to OpenOptions::open_sender might fail with an error indicating different things:

• io::ErrorKind::NotFound - There is no file at the specified path.
• io::ErrorKind::InvalidInput - The file exists, but it is not a FIFO.
• ENXIO - The file is a FIFO, but no process has it open for reading. Sleep for a while and try again.
• Other OS errors not specific to opening FIFO files.

Opening a Sender from a FIFO file should look like this:

use std::time::Duration;

use compio_fs::pipe;
use compio_runtime::time;

const FIFO_NAME: &str = "path/to/a/fifo";

// Wait for a reader to open the file.
let tx = loop {
    match pipe::OpenOptions::new().open_sender(FIFO_NAME).await {
        Ok(tx) => break tx,
        Err(e) if e.raw_os_error() == Some(libc::ENXIO) => {}
        Err(e) => return Err(e.into()),
    }

    time::sleep(Duration::from_millis(50)).await;
};

On Linux, it is possible to create a Sender without waiting in a sleeping loop. This is done by opening a named pipe in read-write access mode with OpenOptions::read_write. This way, a Sender can at the same time hold both a writing end and a reading end, and the latter allows to open a FIFO without ENXIO error since the pipe is open for reading as well.

Sender cannot be used to read from a pipe, so in practice the read access is only used when a FIFO is opened. However, using a Sender in read-write mode may lead to lost data, because written data will be dropped by the system as soon as all pipe ends are closed. To avoid lost data you have to make sure that a reading end has been opened before dropping a Sender.

Note that using read-write access mode with FIFO files is not defined by the POSIX standard and it is only guaranteed to work on Linux.

use compio_fs::pipe;
use compio_io::AsyncWriteExt;

const FIFO_NAME: &str = "path/to/a/fifo";

let mut tx = pipe::OpenOptions::new()
    .read_write(true)
    .open_sender(FIFO_NAME)
    .unwrap();

// Asynchronously write to the pipe before a reader.
tx.write_all("hello world").await.unwrap();

Implementations

impl Sender

pub fn close(self) -> impl Future<Output = Result<()>>

Close the pipe. If the returned future is dropped before polling, the pipe won’t be closed.

Trait Implementations

impl AsRawFd for Sender

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl AsyncWrite for &Sender

async fn write<T: IoBuf>(&mut self, buffer: T) -> BufResult<usize, T>

Write some bytes from the buffer into this source and return a BufResult, consisting of the buffer and a usize indicating how many bytes were written.

async fn write_vectored<T: IoVectoredBuf>( &mut self, buffer: T, ) -> BufResult<usize, T>

Like write, except that it write bytes from a buffer implements IoVectoredBuf into the source.

async fn flush(&mut self) -> Result<()>

Attempts to flush the object, ensuring that any buffered data reach their destination.

async fn shutdown(&mut self) -> Result<()>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

impl AsyncWrite for Sender

async fn write<T: IoBuf>(&mut self, buf: T) -> BufResult<usize, T>

Write some bytes from the buffer into this source and return a BufResult, consisting of the buffer and a usize indicating how many bytes were written.

async fn write_vectored<T: IoVectoredBuf>( &mut self, buf: T, ) -> BufResult<usize, T>

Like write, except that it write bytes from a buffer implements IoVectoredBuf into the source.

async fn flush(&mut self) -> Result<()>

Attempts to flush the object, ensuring that any buffered data reach their destination.

async fn shutdown(&mut self) -> Result<()>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

impl Clone for Sender

fn clone(&self) -> Sender

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Sender

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

Formats the value using the given formatter.

impl FromRawFd for Sender

unsafe fn from_raw_fd(fd: RawFd) -> Self

Constructs a new instance of Self from the given raw file descriptor.

impl ToSharedFd<File> for Sender

fn to_shared_fd(&self) -> SharedFd<File>

Return a cloned SharedFd.