AsyncRead wrapper over sync read

Question

I met this problem while implementing AsyncRead over a synchronized read to adjust to the async world in Rust.

The sync read implementation I'm handling is a wrapper over a raw C sync implementation, much like the std::fs::File::read; therefore I would use std::io::Read for simplicity hereafter.

Here's the code:

use futures::{AsyncRead, Future};
use std::task::{Context, Poll};
use std::pin::Pin;
use tokio::task;
use std::fs::File;
use std::io::Read;
use std::io::Result;

struct FileAsyncRead {
    path: String
}

impl AsyncRead for FileAsyncRead {
    fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<Result<usize>> {
        let path = self.path.to_owned();
        let buf_len = buf.len();
        let mut handle = task::spawn_blocking(move || {
            let mut vec = vec![0u8; buf_len];
            let mut file = File::open(path).unwrap();
            let len = file.read(vec.as_mut_slice());
            (vec, len)
        });

        match Pin::new(&mut handle).poll(cx) {
            Poll::Ready(l) => {
                let v_l = l.unwrap();
                let _c_l = v_l.0.as_slice().read(buf);
                Poll::Ready(v_l.1)
            }
            Poll::Pending => Poll::Pending
        }
    }
}

The current implementation is creating a new vector of the same size with the outer buf: &mut [u8] each time because of :

`buf` has an anonymous lifetime `'_` but it needs to satisfy a `'static` lifetime requirement

 buf: &mut [u8],
    |                --------- this data with an anonymous lifetime `'_`...

My question is:

1. Is that possible to avoid the vector creation in spwan_blocking and mutate the buf in poll_read? To avoid vector allocation as well as copying?
2. Is there a better way to express this "wrapper" logic instead of spawn_blocking as well as Pin::new(&mut handle).poll(cx)? What's the more idiomatic way to do this in Rust?

Answer 1

Something is odd about this code:

1. If this code is called once, it will likely return Poll::Pending, because spawn_blocking takes time to even start a task.
2. If this is called multiple times, then it creates multiple unrelated tasks reading the same part of the file and potentially ignoring the result due to (1), which is probably not what you want.

What you could do to fix this is to remember the task inside the FileAsyncRead struct first time you create it, and then on the next call only start a new task if needed, and poll the existing task.

With this API you have it doesn't seem possible to avoid double buffering, because since your API is blocking, and the ReadBuf buffer is not shared, you need to do a blocking read into some other buffer, and then copy the data over when a new non-blocking call poll_read() arrives.