Struct UnixStream

pub struct UnixStream { /* private fields */ }

A raw Unix byte stream connected to a file.

Implementations

impl UnixStream

pub fn connect<P: AsRef<Path>>(path: P, cx: &MainContext) -> UnixStreamConnect

Creates a new TCP stream that will connect to the specified address.

The returned TCP stream will be associated with the provided context. A future is returned representing the connected TCP stream.

Examples found in repository

examples/named.rs (line 99)

fn main() {
    futures_glib::init();

    let path = "/tmp/named.socket";

    let cx = MainContext::default(|cx| cx.clone());
    let lp = MainLoop::new(None);
    let ex = Executor::new();
    ex.attach(&cx);

    let remote = ex.remote();

    let (sender, receiver) = channel();

    let inner_path = path.clone();
    thread::spawn(move || {
        remote.spawn(move |ex: Executor| {
            let cx = MainContext::default(|cx| cx.clone());
            remove_file(inner_path).ok();
            let listener = UnixListener::bind(inner_path, &cx).unwrap();

            sender.send(true);

            let inner_ex = ex.clone();
            let incoming = listener.incoming()
                .for_each(move |(stream, _addr)| {
                    let frame = stream.framed(LineCodec);

                    inner_ex.spawn(frame.for_each(|value| {
                        println!("Received: {:?}", value);
                        Ok(())
                    }).map_err(|_| ()));
                    Ok(())
                })
            .map_err(|_| ());

            ex.spawn(incoming);
            Ok(())
        });
    });

    let send = receiver.then(move |_| {
            UnixStream::connect(path, &cx)
        })
        .and_then(|stream2| {
            Ok(stream2.framed(LineCodec))
        })
        .and_then(|frame2| {
            frame2.send("Hello".to_string())
        });
    // TODO: send too early? Should accept before?
    ex.spawn(send.map(|_| ())
             .map_err(|_| ()));

    lp.run();
    ex.destroy();
}

examples/named-splitted.rs (line 95)

fn main() {
    futures_glib::init();

    let path = "/tmp/named.socket";

    let cx = MainContext::default(|cx| cx.clone());
    let lp = MainLoop::new(None);
    let ex = Executor::new();
    ex.attach(&cx);

    remove_file(path).ok();
    let listener = UnixListener::bind(path, &cx).unwrap();

    let remote = ex.remote();

    let inner_ex = ex.clone();
    let incoming = listener.incoming()
        .for_each(move |(stream, _addr)| {
            let (reader, writer) = stream.split();
            let mut framed_writer = FramedWrite::new(writer, LineCodec);
            let framed_reader = FramedRead::new(reader, LineCodec);

            inner_ex.spawn(framed_reader.and_then(|value| {
                println!("Received: {:?}", value);
                Ok(())
            }).for_each(move |_| {
                if let Ok(AsyncSink::Ready) = framed_writer.start_send("Received".to_string()) {
                    framed_writer.poll_complete().unwrap();
                }
                Ok(())
            }).map_err(|_| ()));
            Ok(())
        })
        .map_err(|_| ());

    ex.spawn(incoming);

    thread::spawn(move || {
        remote.spawn(move |ex: Executor| {
            let connection = UnixStream::connect(path, &cx);
            let exe = ex.clone();
            let future = connection.and_then(move |stream| {
                let (reader, writer) = stream.split();
                let framed_writer = FramedWrite::new(writer, LineCodec);
                let framed_reader = FramedRead::new(reader, LineCodec);
                exe.spawn(framed_reader.for_each(|value| {
                    println!("Thread received: {:?}", value);
                    Ok(())
                }).map_err(|_| ()));
                exe.spawn(framed_writer.send("Hello".to_string())
                         .map(|_| ())
                         .map_err(|_| ()));
                Ok(())
            })
                .map_err(|_| ());
            ex.spawn(future);
            Ok(())
        });
    });

    lp.run();
    ex.destroy();
}

pub fn connect_abstract( name: &[u8], cx: &MainContext, ) -> Result<UnixStreamConnect>

Examples found in repository

examples/abstract.rs (line 93)

fn main() {
    futures_glib::init();

    let path = b"named-socket";

    let cx = MainContext::default(|cx| cx.clone());
    let lp = MainLoop::new(None);
    let ex = Executor::new();
    ex.attach(&cx);

    let listener = UnixListener::bind_abstract(path, &cx).unwrap();

    let remote = ex.remote();

    let inner_ex = ex.clone();
    let incoming = listener.incoming()
        .for_each(move |(stream, _addr)| {
            let (reader, writer) = stream.split();
            let mut framed_writer = FramedWrite::new(writer, LineCodec);
            let framed_reader = FramedRead::new(reader, LineCodec);

            inner_ex.spawn(framed_reader.and_then(|value| {
                println!("Received: {:?}", value);
                Ok(())
            }).for_each(move |_| {
                if let Ok(AsyncSink::Ready) = framed_writer.start_send("Received".to_string()) {
                    framed_writer.poll_complete().unwrap();
                }
                Ok(())
            }).map_err(|_| ()));
            Ok(())
        })
        .map_err(|_| ());

    ex.spawn(incoming);

    thread::spawn(move || {
        remote.spawn(move |ex: Executor| {
            let connection = UnixStream::connect_abstract(path, &cx).unwrap();
            let exe = ex.clone();
            let future = connection.and_then(move |stream| {
                let (reader, writer) = stream.split();
                let framed_writer = FramedWrite::new(writer, LineCodec);
                let framed_reader = FramedRead::new(reader, LineCodec);
                exe.spawn(framed_reader.for_each(|value| {
                    println!("Thread received: {:?}", value);
                    Ok(())
                }).map_err(|_| ()));
                exe.spawn(framed_writer.send("Hello".to_string())
                         .map(|_| ())
                         .map_err(|_| ()));
                Ok(())
            })
                .map_err(|_| ());
            ex.spawn(future);
            Ok(())
        });
    });

    lp.run();
    ex.destroy();
}

pub unsafe fn from_fd(fd: RawFd, cx: &MainContext) -> UnixStreamConnect

pub fn poll_read(&self) -> Async<()>

Test whether this socket is ready to be read or not.

If the socket is not readable then the current task is scheduled to get a notification when the socket does become readable. That is, this is only suitable for calling in a Future::poll method and will automatically handle ensuring a retry once the socket is readable again.

pub fn poll_write(&self) -> Async<()>

Tests to see if this source is ready to be written to or not.

If this stream is not ready for a write then NotReady will be returned and the current task will be scheduled to receive a notification when the stream is writable again. In other words, this method is only safe to call from within the context of a future’s task, typically done in a Future::poll method.

Trait Implementations

impl AsRawFd for UnixStream

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl AsyncRead for UnixStream

unsafe fn prepare_uninitialized_buffer(&self, _: &mut [u8]) -> bool

Prepares an uninitialized buffer to be safe to pass to read. Returns true if the supplied buffer was zeroed out.

fn read_buf<B: BufMut>(&mut self, buf: &mut B) -> Poll<usize, Error>

Pull some bytes from this source into the specified BufMut, returning how many bytes were read.

fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>

Attempt to read from the AsyncRead into buf.

fn framed<T>(self, codec: T) -> Framed<Self, T>

where T: Encoder + Decoder, Self: Sized + AsyncWrite,

👎Deprecated since 0.1.7: Use tokio_codec::Decoder::framed instead

Provides a Stream and Sink interface for reading and writing to this I/O object, using Decode and Encode to read and write the raw data.

fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>)

where Self: Sized + AsyncWrite,

Helper method for splitting this read/write object into two halves.

impl AsyncWrite for UnixStream

fn shutdown(&mut self) -> Poll<(), Error>

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

fn write_buf<B: Buf>(&mut self, buf: &mut B) -> Poll<usize, Error>

Write a Buf into this value, returning how many bytes were written.

fn poll_write(&mut self, buf: &[u8]) -> Result<Async<usize>, Error>

Attempt to write bytes from buf into the object.

fn poll_flush(&mut self) -> Result<Async<()>, Error>

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

impl<'a> Read for &'a UnixStream

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl Read for UnixStream

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl<'a> Write for &'a UnixStream

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

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

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.

impl Write for UnixStream

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

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

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.