split up files lib (#1685)

actix-files/src/chunked.rs

@@ -0,0 +1,94 @@
+use std::{
+    cmp, fmt,
+    fs::File,
+    future::Future,
+    io::{self, Read, Seek},
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use actix_web::{
+    error::{BlockingError, Error},
+    web,
+};
+use bytes::Bytes;
+use futures_core::{ready, Stream};
+use futures_util::future::{FutureExt, LocalBoxFuture};
+
+use crate::handle_error;
+
+type ChunkedBoxFuture =
+    LocalBoxFuture<'static, Result<(File, Bytes), BlockingError<io::Error>>>;
+
+#[doc(hidden)]
+/// A helper created from a `std::fs::File` which reads the file
+/// chunk-by-chunk on a `ThreadPool`.
+pub struct ChunkedReadFile {
+    pub(crate) size: u64,
+    pub(crate) offset: u64,
+    pub(crate) file: Option<File>,
+    pub(crate) fut: Option<ChunkedBoxFuture>,
+    pub(crate) counter: u64,
+}
+
+impl fmt::Debug for ChunkedReadFile {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("ChunkedReadFile")
+    }
+}
+
+impl Stream for ChunkedReadFile {
+    type Item = Result<Bytes, Error>;
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        if let Some(ref mut fut) = self.fut {
+            return match ready!(Pin::new(fut).poll(cx)) {
+                Ok((file, bytes)) => {
+                    self.fut.take();
+                    self.file = Some(file);
+
+                    self.offset += bytes.len() as u64;
+                    self.counter += bytes.len() as u64;
+
+                    Poll::Ready(Some(Ok(bytes)))
+                }
+                Err(e) => Poll::Ready(Some(Err(handle_error(e)))),
+            };
+        }
+
+        let size = self.size;
+        let offset = self.offset;
+        let counter = self.counter;
+
+        if size == counter {
+            Poll::Ready(None)
+        } else {
+            let mut file = self.file.take().expect("Use after completion");
+
+            self.fut = Some(
+                web::block(move || {
+                    let max_bytes =
+                        cmp::min(size.saturating_sub(counter), 65_536) as usize;
+
+                    let mut buf = Vec::with_capacity(max_bytes);
+                    file.seek(io::SeekFrom::Start(offset))?;
+
+                    let n_bytes =
+                        file.by_ref().take(max_bytes as u64).read_to_end(&mut buf)?;
+
+                    if n_bytes == 0 {
+                        return Err(io::ErrorKind::UnexpectedEof.into());
+                    }
+
+                    Ok((file, Bytes::from(buf)))
+                })
+                .boxed_local(),
+            );
+
+            self.poll_next(cx)
+        }
+    }
+}