From 00b0f8f7005ae2a588caa5ac4fb41ba58022dcca Mon Sep 17 00:00:00 2001 From: Andrew Scott Date: Fri, 29 Aug 2025 13:52:34 -0700 Subject: [PATCH] feat(actix-files): opt-in filesize threshold for faster synchronous reads (#3706) Co-authored-by: Rob Ede --- actix-files/CHANGES.md | 1 + actix-files/src/chunked.rs | 46 +++++++++++++++++++++++++------------- actix-files/src/files.rs | 16 +++++++++++++ actix-files/src/named.rs | 19 ++++++++++++++-- actix-files/src/service.rs | 17 +++++--------- 5 files changed, 70 insertions(+), 29 deletions(-) diff --git a/actix-files/CHANGES.md b/actix-files/CHANGES.md index afb2d5d20..b0b2dc5a3 100644 --- a/actix-files/CHANGES.md +++ b/actix-files/CHANGES.md @@ -2,6 +2,7 @@ ## Unreleased +- Opt-In filesize threshold for faster synchronus reads that allow for 20x better performance. - Minimum supported Rust version (MSRV) is now 1.75. ## 0.6.6 diff --git a/actix-files/src/chunked.rs b/actix-files/src/chunked.rs index c6c019038..8ca92f094 100644 --- a/actix-files/src/chunked.rs +++ b/actix-files/src/chunked.rs @@ -24,6 +24,7 @@ pin_project! { state: ChunkedReadFileState, counter: u64, callback: F, + read_sync: bool, } } @@ -57,6 +58,7 @@ pub(crate) fn new_chunked_read( size: u64, offset: u64, file: File, + size_threshold: u64, ) -> impl Stream> { ChunkedReadFile { size, @@ -69,31 +71,45 @@ pub(crate) fn new_chunked_read( }, counter: 0, callback: chunked_read_file_callback, + read_sync: size < size_threshold, } } #[cfg(not(feature = "experimental-io-uring"))] -async fn chunked_read_file_callback( +fn chunked_read_file_callback_sync( mut file: File, offset: u64, max_bytes: usize, -) -> Result<(File, Bytes), Error> { +) -> Result<(File, Bytes), io::Error> { use io::{Read as _, Seek as _}; - let res = actix_web::web::block(move || { - let mut buf = Vec::with_capacity(max_bytes); + let mut buf = Vec::with_capacity(max_bytes); - file.seek(io::SeekFrom::Start(offset))?; + file.seek(io::SeekFrom::Start(offset))?; - let n_bytes = file.by_ref().take(max_bytes as u64).read_to_end(&mut buf)?; + let n_bytes = file.by_ref().take(max_bytes as u64).read_to_end(&mut buf)?; - if n_bytes == 0 { - Err(io::Error::from(io::ErrorKind::UnexpectedEof)) - } else { - Ok((file, Bytes::from(buf))) - } - }) - .await??; + if n_bytes == 0 { + Err(io::Error::from(io::ErrorKind::UnexpectedEof)) + } else { + Ok((file, Bytes::from(buf))) + } +} + +#[cfg(not(feature = "experimental-io-uring"))] +#[inline] +async fn chunked_read_file_callback( + file: File, + offset: u64, + max_bytes: usize, + read_sync: bool, +) -> Result<(File, Bytes), Error> { + let res = if read_sync { + chunked_read_file_callback_sync(file, offset, max_bytes)? + } else { + actix_web::web::block(move || chunked_read_file_callback_sync(file, offset, max_bytes)) + .await?? + }; Ok(res) } @@ -171,7 +187,7 @@ where #[cfg(not(feature = "experimental-io-uring"))] impl Stream for ChunkedReadFile where - F: Fn(File, u64, usize) -> Fut, + F: Fn(File, u64, usize, bool) -> Fut, Fut: Future>, { type Item = Result; @@ -193,7 +209,7 @@ where .take() .expect("ChunkedReadFile polled after completion"); - let fut = (this.callback)(file, offset, max_bytes); + let fut = (this.callback)(file, offset, max_bytes, *this.read_sync); this.state .project_replace(ChunkedReadFileState::Future { fut }); diff --git a/actix-files/src/files.rs b/actix-files/src/files.rs index cfd3b9c22..76971463e 100644 --- a/actix-files/src/files.rs +++ b/actix-files/src/files.rs @@ -49,6 +49,7 @@ pub struct Files { use_guards: Option>, guards: Vec>, hidden_files: bool, + size_threshold: u64, } impl fmt::Debug for Files { @@ -73,6 +74,7 @@ impl Clone for Files { use_guards: self.use_guards.clone(), guards: self.guards.clone(), hidden_files: self.hidden_files, + size_threshold: self.size_threshold, } } } @@ -119,6 +121,7 @@ impl Files { use_guards: None, guards: Vec::new(), hidden_files: false, + size_threshold: 0, } } @@ -204,6 +207,18 @@ impl Files { self } + /// Sets the async file-size threshold. + /// + /// When a file is larger than the threshold, the reader + /// will switch from faster blocking file-reads to slower async reads + /// to avoid blocking the main-thread when processing large files. + /// + /// Default is 0, meaning all files are read asyncly. + pub fn set_size_threshold(mut self, size: u64) -> Self { + self.size_threshold = size; + self + } + /// Specifies whether to use ETag or not. /// /// Default is true. @@ -367,6 +382,7 @@ impl ServiceFactory for Files { file_flags: self.file_flags, guards: self.use_guards.clone(), hidden_files: self.hidden_files, + size_threshold: self.size_threshold, }; if let Some(ref default) = *self.default.borrow() { diff --git a/actix-files/src/named.rs b/actix-files/src/named.rs index 9e4a37737..edf159f1d 100644 --- a/actix-files/src/named.rs +++ b/actix-files/src/named.rs @@ -80,6 +80,7 @@ pub struct NamedFile { pub(crate) content_type: Mime, pub(crate) content_disposition: ContentDisposition, pub(crate) encoding: Option, + pub(crate) size_threshold: u64, } #[cfg(not(feature = "experimental-io-uring"))] @@ -200,6 +201,7 @@ impl NamedFile { encoding, status_code: StatusCode::OK, flags: Flags::default(), + size_threshold: 0, }) } @@ -353,6 +355,18 @@ impl NamedFile { self } + /// Sets the async file-size threshold. + /// + /// When a file is larger than the threshold, the reader + /// will switch from faster blocking file-reads to slower async reads + /// to avoid blocking the main-thread when processing large files. + /// + /// Default is 0, meaning all files are read asyncly. + pub fn set_size_threshold(mut self, size: u64) -> Self { + self.size_threshold = size; + self + } + /// Specifies whether to return `ETag` header in response. /// /// Default is true. @@ -440,7 +454,8 @@ impl NamedFile { res.insert_header((header::CONTENT_ENCODING, current_encoding.as_str())); } - let reader = chunked::new_chunked_read(self.md.len(), 0, self.file); + let reader = + chunked::new_chunked_read(self.md.len(), 0, self.file, self.size_threshold); return res.streaming(reader); } @@ -577,7 +592,7 @@ impl NamedFile { .map_into_boxed_body(); } - let reader = chunked::new_chunked_read(length, offset, self.file); + let reader = chunked::new_chunked_read(length, offset, self.file, self.size_threshold); if offset != 0 || length != self.md.len() { res.status(StatusCode::PARTIAL_CONTENT); diff --git a/actix-files/src/service.rs b/actix-files/src/service.rs index 393ad9244..a10d35881 100644 --- a/actix-files/src/service.rs +++ b/actix-files/src/service.rs @@ -39,6 +39,7 @@ pub struct FilesServiceInner { pub(crate) file_flags: named::Flags, pub(crate) guards: Option>, pub(crate) hidden_files: bool, + pub(crate) size_threshold: u64, } impl fmt::Debug for FilesServiceInner { @@ -70,7 +71,9 @@ impl FilesService { named_file.flags = self.file_flags; let (req, _) = req.into_parts(); - let res = named_file.into_response(&req); + let res = named_file + .set_size_threshold(self.size_threshold) + .into_response(&req); ServiceResponse::new(req, res) } @@ -169,17 +172,7 @@ impl Service for FilesService { } } else { match NamedFile::open_async(&path).await { - Ok(mut named_file) => { - if let Some(ref mime_override) = this.mime_override { - let new_disposition = mime_override(&named_file.content_type.type_()); - named_file.content_disposition.disposition = new_disposition; - } - named_file.flags = this.file_flags; - - let (req, _) = req.into_parts(); - let res = named_file.into_response(&req); - Ok(ServiceResponse::new(req, res)) - } + Ok(named_file) => Ok(this.serve_named_file(req, named_file)), Err(err) => this.handle_err(err, req).await, } }