-
Actix web
+
Actix Web
Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust
[](https://crates.io/crates/actix-web)
-[](https://docs.rs/actix-web/3.3.2)
+[](https://docs.rs/actix-web/4.0.0-beta.2)
[](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
-
-[](https://deps.rs/crate/actix-web/3.3.2)
+
+[](https://deps.rs/crate/actix-web/4.0.0-beta.2)
-[](https://travis-ci.org/actix/actix-web)
+[](https://github.com/actix/actix-web/actions)
[](https://codecov.io/gh/actix/actix-web)
-[](https://crates.io/crates/actix-web)
-[](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
[](https://discord.gg/NWpN5mmg3x)
@@ -32,8 +31,7 @@
* Static assets
* SSL support using OpenSSL or Rustls
* Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
-* Includes an async [HTTP client](https://actix.rs/actix-web/actix_web/client/index.html)
-* Supports [Actix actor framework](https://github.com/actix/actix)
+* Includes an async [HTTP client](https://docs.rs/actix-web/latest/actix_web/client/index.html)
* Runs on stable Rust 1.46+
## Documentation
@@ -99,13 +97,13 @@ One of the fastest web frameworks available according to the
This project is licensed under either of
* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
- [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
+ [http://www.apache.org/licenses/LICENSE-2.0])
* MIT license ([LICENSE-MIT](LICENSE-MIT) or
- [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
+ [http://opensource.org/licenses/MIT])
at your option.
## Code of Conduct
-Contribution to the actix-web crate is organized under the terms of the Contributor Covenant, the
-maintainers of Actix web, promises to intervene to uphold that code of conduct.
+Contribution to the actix-web repo is organized under the terms of the Contributor Covenant.
+The Actix team promises to intervene to uphold that code of conduct.
diff --git a/actix-files/CHANGES.md b/actix-files/CHANGES.md
index 49768419b..6e2a241ac 100644
--- a/actix-files/CHANGES.md
+++ b/actix-files/CHANGES.md
@@ -1,7 +1,21 @@
# Changes
-## Unreleased - 2020-xx-xx
+## Unreleased - 2021-xx-xx
+
+
+## 0.6.0-beta.2 - 2021-02-10
+* Fix If-Modified-Since and If-Unmodified-Since to not compare using sub-second timestamps. [#1887]
+* Replace `v_htmlescape` with `askama_escape`. [#1953]
+
+[#1887]: https://github.com/actix/actix-web/pull/1887
+[#1953]: https://github.com/actix/actix-web/pull/1953
+
+
+## 0.6.0-beta.1 - 2021-01-07
* `HttpRange::parse` now has its own error type.
+* Update `bytes` to `1.0`. [#1813]
+
+[#1813]: https://github.com/actix/actix-web/pull/1813
## 0.5.0 - 2020-12-26
diff --git a/actix-files/Cargo.toml b/actix-files/Cargo.toml
index b67abb1c1..08b7b36fc 100644
--- a/actix-files/Cargo.toml
+++ b/actix-files/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "actix-files"
-version = "0.5.0"
+version = "0.6.0-beta.2"
authors = ["Nikolay Kim
"]
description = "Static file serving for Actix Web"
readme = "README.md"
@@ -17,19 +17,21 @@ name = "actix_files"
path = "src/lib.rs"
[dependencies]
-actix-web = { version = "3.0.0", default-features = false }
-actix-service = "1.0.6"
+actix-web = { version = "4.0.0-beta.3", default-features = false }
+actix-service = "2.0.0-beta.4"
+
+askama_escape = "0.10"
bitflags = "1"
-bytes = "0.5.3"
+bytes = "1"
futures-core = { version = "0.3.7", default-features = false }
futures-util = { version = "0.3.7", default-features = false }
+http-range = "0.1.4"
derive_more = "0.99.5"
log = "0.4"
mime = "0.3"
mime_guess = "2.0.1"
percent-encoding = "2.1"
-v_htmlescape = "0.12"
[dev-dependencies]
-actix-rt = "1.0.0"
-actix-web = "3.0.0"
+actix-rt = "2"
+actix-web = "4.0.0-beta.3"
diff --git a/actix-files/src/chunked.rs b/actix-files/src/chunked.rs
index 580b06787..f639848c9 100644
--- a/actix-files/src/chunked.rs
+++ b/actix-files/src/chunked.rs
@@ -9,26 +9,35 @@ use std::{
use actix_web::{
error::{BlockingError, Error},
- web,
+ rt::task::{spawn_blocking, JoinHandle},
};
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>>;
#[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,
- pub(crate) fut: Option,
- pub(crate) counter: u64,
+ size: u64,
+ offset: u64,
+ state: ChunkedReadFileState,
+ counter: u64,
+}
+
+enum ChunkedReadFileState {
+ File(Option),
+ Future(JoinHandle>),
+}
+
+impl ChunkedReadFile {
+ pub(crate) fn new(size: u64, offset: u64, file: File) -> Self {
+ Self {
+ size,
+ offset,
+ state: ChunkedReadFileState::File(Some(file)),
+ counter: 0,
+ }
+ }
}
impl fmt::Debug for ChunkedReadFile {
@@ -40,55 +49,50 @@ impl fmt::Debug for ChunkedReadFile {
impl Stream for ChunkedReadFile {
type Item = Result;
- fn poll_next(
- mut self: Pin<&mut Self>,
- cx: &mut Context<'_>,
- ) -> Poll> {
- 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);
+ fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> {
+ let this = self.as_mut().get_mut();
+ match this.state {
+ ChunkedReadFileState::File(ref mut file) => {
+ let size = this.size;
+ let offset = this.offset;
+ let counter = this.counter;
- self.offset += bytes.len() as u64;
- self.counter += bytes.len() as u64;
+ if size == counter {
+ Poll::Ready(None)
+ } else {
+ let mut file = file
+ .take()
+ .expect("ChunkedReadFile polled after completion");
- Poll::Ready(Some(Ok(bytes)))
+ let fut = spawn_blocking(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)))
+ });
+ this.state = ChunkedReadFileState::Future(fut);
+ self.poll_next(cx)
}
- Err(e) => Poll::Ready(Some(Err(handle_error(e)))),
- };
- }
+ }
+ ChunkedReadFileState::Future(ref mut fut) => {
+ let (file, bytes) =
+ ready!(Pin::new(fut).poll(cx)).map_err(|_| BlockingError)??;
+ this.state = ChunkedReadFileState::File(Some(file));
- let size = self.size;
- let offset = self.offset;
- let counter = self.counter;
+ this.offset += bytes.len() as u64;
+ this.counter += bytes.len() as u64;
- 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)
+ Poll::Ready(Some(Ok(bytes)))
+ }
}
}
}
diff --git a/actix-files/src/directory.rs b/actix-files/src/directory.rs
index 3717985d3..80e0c98d0 100644
--- a/actix-files/src/directory.rs
+++ b/actix-files/src/directory.rs
@@ -1,8 +1,8 @@
use std::{fmt::Write, fs::DirEntry, io, path::Path, path::PathBuf};
use actix_web::{dev::ServiceResponse, HttpRequest, HttpResponse};
+use askama_escape::{escape as escape_html_entity, Html};
use percent_encoding::{utf8_percent_encode, CONTROLS};
-use v_htmlescape::escape as escape_html_entity;
/// A directory; responds with the generated directory listing.
#[derive(Debug)]
@@ -50,7 +50,7 @@ macro_rules! encode_file_url {
// " -- " & -- & ' -- ' < -- < > -- > / -- /
macro_rules! encode_file_name {
($entry:ident) => {
- escape_html_entity(&$entry.file_name().to_string_lossy())
+ escape_html_entity(&$entry.file_name().to_string_lossy(), Html)
};
}
@@ -66,9 +66,7 @@ pub(crate) fn directory_listing(
if dir.is_visible(&entry) {
let entry = entry.unwrap();
let p = match entry.path().strip_prefix(&dir.path) {
- Ok(p) if cfg!(windows) => {
- base.join(p).to_string_lossy().replace("\\", "/")
- }
+ Ok(p) if cfg!(windows) => base.join(p).to_string_lossy().replace("\\", "/"),
Ok(p) => base.join(p).to_string_lossy().into_owned(),
Err(_) => continue,
};
diff --git a/actix-files/src/files.rs b/actix-files/src/files.rs
index d0cac6aa4..6f8b28bbf 100644
--- a/actix-files/src/files.rs
+++ b/actix-files/src/files.rs
@@ -1,10 +1,8 @@
use std::{cell::RefCell, fmt, io, path::PathBuf, rc::Rc};
-use actix_service::{boxed, IntoServiceFactory, ServiceFactory};
+use actix_service::{boxed, IntoServiceFactory, ServiceFactory, ServiceFactoryExt};
use actix_web::{
- dev::{
- AppService, HttpServiceFactory, ResourceDef, ServiceRequest, ServiceResponse,
- },
+ dev::{AppService, HttpServiceFactory, ResourceDef, ServiceRequest, ServiceResponse},
error::Error,
guard::Guard,
http::header::DispositionType,
@@ -13,8 +11,8 @@ use actix_web::{
use futures_util::future::{ok, FutureExt, LocalBoxFuture};
use crate::{
- directory_listing, named, Directory, DirectoryRenderer, FilesService,
- HttpNewService, MimeOverride,
+ directory_listing, named, Directory, DirectoryRenderer, FilesService, HttpNewService,
+ MimeOverride,
};
/// Static files handling service.
@@ -82,8 +80,9 @@ impl Files {
/// be inaccessible. Register more specific handlers and services first.
///
/// `Files` uses a threadpool for blocking filesystem operations. By default, the pool uses a
- /// number of threads equal to 5x the number of available logical CPUs. Pool size can be changed
- /// by setting ACTIX_THREADPOOL environment variable.
+ /// max number of threads equal to `512 * HttpServer::worker`. Real time thread count are
+ /// adjusted with work load. More threads would spawn when need and threads goes idle for a
+ /// period of time would be de-spawned.
pub fn new>(mount_path: &str, serve_from: T) -> Files {
let orig_dir = serve_from.into();
let dir = match orig_dir.canonicalize() {
@@ -128,8 +127,8 @@ impl Files {
/// Set custom directory renderer
pub fn files_listing_renderer(mut self, f: F) -> Self
where
- for<'r, 's> F: Fn(&'r Directory, &'s HttpRequest) -> Result
- + 'static,
+ for<'r, 's> F:
+ Fn(&'r Directory, &'s HttpRequest) -> Result + 'static,
{
self.renderer = Rc::new(f);
self
@@ -201,10 +200,10 @@ impl Files {
/// Sets default handler which is used when no matched file could be found.
pub fn default_handler(mut self, f: F) -> Self
where
- F: IntoServiceFactory,
+ F: IntoServiceFactory,
U: ServiceFactory<
+ ServiceRequest,
Config = (),
- Request = ServiceRequest,
Response = ServiceResponse,
Error = Error,
> + 'static,
@@ -241,8 +240,7 @@ impl HttpServiceFactory for Files {
}
}
-impl ServiceFactory for Files {
- type Request = ServiceRequest;
+impl ServiceFactory for Files {
type Response = ServiceResponse;
type Error = Error;
type Config = ();
diff --git a/actix-files/src/lib.rs b/actix-files/src/lib.rs
index 6769d6d38..d26e55899 100644
--- a/actix-files/src/lib.rs
+++ b/actix-files/src/lib.rs
@@ -15,12 +15,10 @@
#![warn(missing_docs, missing_debug_implementations)]
#![clippy::msrv = "1.46"]
-use std::io;
-
use actix_service::boxed::{BoxService, BoxServiceFactory};
use actix_web::{
dev::{ServiceRequest, ServiceResponse},
- error::{BlockingError, Error, ErrorInternalServerError},
+ error::Error,
http::header::DispositionType,
};
use mime_guess::from_ext;
@@ -57,13 +55,6 @@ pub fn file_extension_to_mime(ext: &str) -> mime::Mime {
from_ext(ext).first_or_octet_stream()
}
-pub(crate) fn handle_error(err: BlockingError) -> Error {
- match err {
- BlockingError::Error(err) => err.into(),
- BlockingError::Canceled => ErrorInternalServerError("Unexpected error"),
- }
-}
-
type MimeOverride = dyn Fn(&mime::Name<'_>) -> DispositionType;
#[cfg(test)]
@@ -83,7 +74,8 @@ mod tests {
},
middleware::Compress,
test::{self, TestRequest},
- web, App, HttpResponse, Responder,
+ web::{self, Bytes},
+ App, HttpResponse, Responder,
};
use futures_util::future::ok;
@@ -107,11 +99,22 @@ mod tests {
#[actix_rt::test]
async fn test_if_modified_since_without_if_none_match() {
let file = NamedFile::open("Cargo.toml").unwrap();
- let since =
- header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
+ let since = header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
let req = TestRequest::default()
- .header(header::IF_MODIFIED_SINCE, since)
+ .insert_header((header::IF_MODIFIED_SINCE, since))
+ .to_http_request();
+ let resp = file.respond_to(&req).await.unwrap();
+ assert_eq!(resp.status(), StatusCode::NOT_MODIFIED);
+ }
+
+ #[actix_rt::test]
+ async fn test_if_modified_since_without_if_none_match_same() {
+ let file = NamedFile::open("Cargo.toml").unwrap();
+ let since = file.last_modified().unwrap();
+
+ let req = TestRequest::default()
+ .insert_header((header::IF_MODIFIED_SINCE, since))
.to_http_request();
let resp = file.respond_to(&req).await.unwrap();
assert_eq!(resp.status(), StatusCode::NOT_MODIFIED);
@@ -120,17 +123,40 @@ mod tests {
#[actix_rt::test]
async fn test_if_modified_since_with_if_none_match() {
let file = NamedFile::open("Cargo.toml").unwrap();
- let since =
- header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
+ let since = header::HttpDate::from(SystemTime::now().add(Duration::from_secs(60)));
let req = TestRequest::default()
- .header(header::IF_NONE_MATCH, "miss_etag")
- .header(header::IF_MODIFIED_SINCE, since)
+ .insert_header((header::IF_NONE_MATCH, "miss_etag"))
+ .insert_header((header::IF_MODIFIED_SINCE, since))
.to_http_request();
let resp = file.respond_to(&req).await.unwrap();
assert_ne!(resp.status(), StatusCode::NOT_MODIFIED);
}
+ #[actix_rt::test]
+ async fn test_if_unmodified_since() {
+ let file = NamedFile::open("Cargo.toml").unwrap();
+ let since = file.last_modified().unwrap();
+
+ let req = TestRequest::default()
+ .insert_header((header::IF_UNMODIFIED_SINCE, since))
+ .to_http_request();
+ let resp = file.respond_to(&req).await.unwrap();
+ assert_eq!(resp.status(), StatusCode::OK);
+ }
+
+ #[actix_rt::test]
+ async fn test_if_unmodified_since_failed() {
+ let file = NamedFile::open("Cargo.toml").unwrap();
+ let since = header::HttpDate::from(SystemTime::UNIX_EPOCH);
+
+ let req = TestRequest::default()
+ .insert_header((header::IF_UNMODIFIED_SINCE, since))
+ .to_http_request();
+ let resp = file.respond_to(&req).await.unwrap();
+ assert_eq!(resp.status(), StatusCode::PRECONDITION_FAILED);
+ }
+
#[actix_rt::test]
async fn test_named_file_text() {
assert!(NamedFile::open("test--").is_err());
@@ -185,8 +211,7 @@ mod tests {
#[actix_rt::test]
async fn test_named_file_non_ascii_file_name() {
let mut file =
- NamedFile::from_file(File::open("Cargo.toml").unwrap(), "貨物.toml")
- .unwrap();
+ NamedFile::from_file(File::open("Cargo.toml").unwrap(), "貨物.toml").unwrap();
{
file.file();
let _f: &File = &file;
@@ -339,7 +364,7 @@ mod tests {
DispositionType::Attachment
}
- let mut srv = test::init_service(
+ let srv = test::init_service(
App::new().service(
Files::new("/", ".")
.mime_override(all_attachment)
@@ -349,7 +374,7 @@ mod tests {
.await;
let request = TestRequest::get().uri("/").to_request();
- let response = test::call_service(&mut srv, request).await;
+ let response = test::call_service(&srv, request).await;
assert_eq!(response.status(), StatusCode::OK);
let content_disposition = response
@@ -364,7 +389,7 @@ mod tests {
#[actix_rt::test]
async fn test_named_file_ranges_status_code() {
- let mut srv = test::init_service(
+ let srv = test::init_service(
App::new().service(Files::new("/test", ".").index_file("Cargo.toml")),
)
.await;
@@ -372,17 +397,17 @@ mod tests {
// Valid range header
let request = TestRequest::get()
.uri("/t%65st/Cargo.toml")
- .header(header::RANGE, "bytes=10-20")
+ .insert_header((header::RANGE, "bytes=10-20"))
.to_request();
- let response = test::call_service(&mut srv, request).await;
+ let response = test::call_service(&srv, request).await;
assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
// Invalid range header
let request = TestRequest::get()
.uri("/t%65st/Cargo.toml")
- .header(header::RANGE, "bytes=1-0")
+ .insert_header((header::RANGE, "bytes=1-0"))
.to_request();
- let response = test::call_service(&mut srv, request).await;
+ let response = test::call_service(&srv, request).await;
assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE);
}
@@ -394,7 +419,7 @@ mod tests {
// Valid range header
let response = srv
.get("/tests/test.binary")
- .header(header::RANGE, "bytes=10-20")
+ .insert_header((header::RANGE, "bytes=10-20"))
.send()
.await
.unwrap();
@@ -404,7 +429,7 @@ mod tests {
// Invalid range header
let response = srv
.get("/tests/test.binary")
- .header(header::RANGE, "bytes=10-5")
+ .insert_header((header::RANGE, "bytes=10-5"))
.send()
.await
.unwrap();
@@ -419,7 +444,7 @@ mod tests {
// Valid range header
let response = srv
.get("/tests/test.binary")
- .header(header::RANGE, "bytes=10-20")
+ .insert_header((header::RANGE, "bytes=10-20"))
.send()
.await
.unwrap();
@@ -429,7 +454,7 @@ mod tests {
// Valid range header, starting from 0
let response = srv
.get("/tests/test.binary")
- .header(header::RANGE, "bytes=0-20")
+ .insert_header((header::RANGE, "bytes=0-20"))
.send()
.await
.unwrap();
@@ -469,14 +494,14 @@ mod tests {
#[actix_rt::test]
async fn test_static_files_with_spaces() {
- let mut srv = test::init_service(
+ let srv = test::init_service(
App::new().service(Files::new("/", ".").index_file("Cargo.toml")),
)
.await;
let request = TestRequest::get()
.uri("/tests/test%20space.binary")
.to_request();
- let response = test::call_service(&mut srv, request).await;
+ let response = test::call_service(&srv, request).await;
assert_eq!(response.status(), StatusCode::OK);
let bytes = test::read_body(response).await;
@@ -486,28 +511,28 @@ mod tests {
#[actix_rt::test]
async fn test_files_not_allowed() {
- let mut srv = test::init_service(App::new().service(Files::new("/", "."))).await;
+ let srv = test::init_service(App::new().service(Files::new("/", "."))).await;
let req = TestRequest::default()
.uri("/Cargo.toml")
.method(Method::POST)
.to_request();
- let resp = test::call_service(&mut srv, req).await;
+ let resp = test::call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
- let mut srv = test::init_service(App::new().service(Files::new("/", "."))).await;
+ let srv = test::init_service(App::new().service(Files::new("/", "."))).await;
let req = TestRequest::default()
.method(Method::PUT)
.uri("/Cargo.toml")
.to_request();
- let resp = test::call_service(&mut srv, req).await;
+ let resp = test::call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
}
#[actix_rt::test]
async fn test_files_guards() {
- let mut srv = test::init_service(
+ let srv = test::init_service(
App::new().service(Files::new("/", ".").use_guards(guard::Post())),
)
.await;
@@ -517,13 +542,13 @@ mod tests {
.method(Method::POST)
.to_request();
- let resp = test::call_service(&mut srv, req).await;
+ let resp = test::call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
}
#[actix_rt::test]
async fn test_named_file_content_encoding() {
- let mut srv = test::init_service(App::new().wrap(Compress::default()).service(
+ let srv = test::init_service(App::new().wrap(Compress::default()).service(
web::resource("/").to(|| async {
NamedFile::open("Cargo.toml")
.unwrap()
@@ -534,16 +559,16 @@ mod tests {
let request = TestRequest::get()
.uri("/")
- .header(header::ACCEPT_ENCODING, "gzip")
+ .insert_header((header::ACCEPT_ENCODING, "gzip"))
.to_request();
- let res = test::call_service(&mut srv, request).await;
+ let res = test::call_service(&srv, request).await;
assert_eq!(res.status(), StatusCode::OK);
assert!(!res.headers().contains_key(header::CONTENT_ENCODING));
}
#[actix_rt::test]
async fn test_named_file_content_encoding_gzip() {
- let mut srv = test::init_service(App::new().wrap(Compress::default()).service(
+ let srv = test::init_service(App::new().wrap(Compress::default()).service(
web::resource("/").to(|| async {
NamedFile::open("Cargo.toml")
.unwrap()
@@ -554,9 +579,9 @@ mod tests {
let request = TestRequest::get()
.uri("/")
- .header(header::ACCEPT_ENCODING, "gzip")
+ .insert_header((header::ACCEPT_ENCODING, "gzip"))
.to_request();
- let res = test::call_service(&mut srv, request).await;
+ let res = test::call_service(&srv, request).await;
assert_eq!(res.status(), StatusCode::OK);
assert_eq!(
res.headers()
@@ -578,27 +603,25 @@ mod tests {
#[actix_rt::test]
async fn test_static_files() {
- let mut srv = test::init_service(
- App::new().service(Files::new("/", ".").show_files_listing()),
- )
- .await;
+ let srv =
+ test::init_service(App::new().service(Files::new("/", ".").show_files_listing()))
+ .await;
let req = TestRequest::with_uri("/missing").to_request();
- let resp = test::call_service(&mut srv, req).await;
+ let resp = test::call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
- let mut srv = test::init_service(App::new().service(Files::new("/", "."))).await;
+ let srv = test::init_service(App::new().service(Files::new("/", "."))).await;
let req = TestRequest::default().to_request();
- let resp = test::call_service(&mut srv, req).await;
+ let resp = test::call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
- let mut srv = test::init_service(
- App::new().service(Files::new("/", ".").show_files_listing()),
- )
- .await;
+ let srv =
+ test::init_service(App::new().service(Files::new("/", ".").show_files_listing()))
+ .await;
let req = TestRequest::with_uri("/tests").to_request();
- let resp = test::call_service(&mut srv, req).await;
+ let resp = test::call_service(&srv, req).await;
assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(),
"text/html; charset=utf-8"
@@ -611,16 +634,16 @@ mod tests {
#[actix_rt::test]
async fn test_redirect_to_slash_directory() {
// should not redirect if no index
- let mut srv = test::init_service(
+ let srv = test::init_service(
App::new().service(Files::new("/", ".").redirect_to_slash_directory()),
)
.await;
let req = TestRequest::with_uri("/tests").to_request();
- let resp = test::call_service(&mut srv, req).await;
+ let resp = test::call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
// should redirect if index present
- let mut srv = test::init_service(
+ let srv = test::init_service(
App::new().service(
Files::new("/", ".")
.index_file("test.png")
@@ -629,12 +652,12 @@ mod tests {
)
.await;
let req = TestRequest::with_uri("/tests").to_request();
- let resp = test::call_service(&mut srv, req).await;
+ let resp = test::call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::FOUND);
// should not redirect if the path is wrong
let req = TestRequest::with_uri("/not_existing").to_request();
- let resp = test::call_service(&mut srv, req).await;
+ let resp = test::call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
}
@@ -646,7 +669,7 @@ mod tests {
#[actix_rt::test]
async fn test_default_handler_file_missing() {
- let mut st = Files::new("/", ".")
+ let st = Files::new("/", ".")
.default_handler(|req: ServiceRequest| {
ok(req.into_response(HttpResponse::Ok().body("default content")))
})
@@ -655,7 +678,7 @@ mod tests {
.unwrap();
let req = TestRequest::with_uri("/missing").to_srv_request();
- let resp = test::call_service(&mut st, req).await;
+ let resp = test::call_service(&st, req).await;
assert_eq!(resp.status(), StatusCode::OK);
let bytes = test::read_body(resp).await;
assert_eq!(bytes, web::Bytes::from_static(b"default content"));
@@ -724,54 +747,49 @@ mod tests {
// );
// }
- // #[actix_rt::test]
- // fn integration_serve_index() {
- // let mut srv = test::TestServer::with_factory(|| {
- // App::new().handler(
- // "test",
- // Files::new(".").index_file("Cargo.toml"),
- // )
- // });
+ #[actix_rt::test]
+ async fn integration_serve_index() {
+ let srv = test::init_service(
+ App::new().service(Files::new("test", ".").index_file("Cargo.toml")),
+ )
+ .await;
- // let request = srv.get().uri(srv.url("/test")).finish().unwrap();
- // let response = srv.execute(request.send()).unwrap();
- // assert_eq!(response.status(), StatusCode::OK);
- // let bytes = srv.execute(response.body()).unwrap();
- // let data = Bytes::from(fs::read("Cargo.toml").unwrap());
- // assert_eq!(bytes, data);
+ let req = TestRequest::get().uri("/test").to_request();
+ let res = test::call_service(&srv, req).await;
+ assert_eq!(res.status(), StatusCode::OK);
- // let request = srv.get().uri(srv.url("/test/")).finish().unwrap();
- // let response = srv.execute(request.send()).unwrap();
- // assert_eq!(response.status(), StatusCode::OK);
- // let bytes = srv.execute(response.body()).unwrap();
- // let data = Bytes::from(fs::read("Cargo.toml").unwrap());
- // assert_eq!(bytes, data);
+ let bytes = test::read_body(res).await;
- // // nonexistent index file
- // let request = srv.get().uri(srv.url("/test/unknown")).finish().unwrap();
- // let response = srv.execute(request.send()).unwrap();
- // assert_eq!(response.status(), StatusCode::NOT_FOUND);
+ let data = Bytes::from(fs::read("Cargo.toml").unwrap());
+ assert_eq!(bytes, data);
- // let request = srv.get().uri(srv.url("/test/unknown/")).finish().unwrap();
- // let response = srv.execute(request.send()).unwrap();
- // assert_eq!(response.status(), StatusCode::NOT_FOUND);
- // }
+ let req = TestRequest::get().uri("/test/").to_request();
+ let res = test::call_service(&srv, req).await;
+ assert_eq!(res.status(), StatusCode::OK);
- // #[actix_rt::test]
- // fn integration_percent_encoded() {
- // let mut srv = test::TestServer::with_factory(|| {
- // App::new().handler(
- // "test",
- // Files::new(".").index_file("Cargo.toml"),
- // )
- // });
+ let bytes = test::read_body(res).await;
+ let data = Bytes::from(fs::read("Cargo.toml").unwrap());
+ assert_eq!(bytes, data);
- // let request = srv
- // .get()
- // .uri(srv.url("/test/%43argo.toml"))
- // .finish()
- // .unwrap();
- // let response = srv.execute(request.send()).unwrap();
- // assert_eq!(response.status(), StatusCode::OK);
- // }
+ // nonexistent index file
+ let req = TestRequest::get().uri("/test/unknown").to_request();
+ let res = test::call_service(&srv, req).await;
+ assert_eq!(res.status(), StatusCode::NOT_FOUND);
+
+ let req = TestRequest::get().uri("/test/unknown/").to_request();
+ let res = test::call_service(&srv, req).await;
+ assert_eq!(res.status(), StatusCode::NOT_FOUND);
+ }
+
+ #[actix_rt::test]
+ async fn integration_percent_encoded() {
+ let srv = test::init_service(
+ App::new().service(Files::new("test", ".").index_file("Cargo.toml")),
+ )
+ .await;
+
+ let req = TestRequest::get().uri("/test/%43argo.toml").to_request();
+ let res = test::call_service(&srv, req).await;
+ assert_eq!(res.status(), StatusCode::OK);
+ }
}
diff --git a/actix-files/src/named.rs b/actix-files/src/named.rs
index a9b95bad1..a688b2e6c 100644
--- a/actix-files/src/named.rs
+++ b/actix-files/src/named.rs
@@ -11,15 +11,13 @@ use actix_web::{
dev::{BodyEncoding, SizedStream},
http::{
header::{
- self, Charset, ContentDisposition, DispositionParam, DispositionType,
- ExtendedValue,
+ self, Charset, ContentDisposition, DispositionParam, DispositionType, ExtendedValue,
},
ContentEncoding, StatusCode,
},
- Error, HttpMessage, HttpRequest, HttpResponse, Responder,
+ HttpMessage, HttpRequest, HttpResponse, Responder,
};
use bitflags::bitflags;
-use futures_util::future::{ready, Ready};
use mime_guess::from_path;
use crate::ChunkedReadFile;
@@ -277,37 +275,31 @@ impl NamedFile {
}
/// Creates an `HttpResponse` with file as a streaming body.
- pub fn into_response(self, req: &HttpRequest) -> Result {
+ pub fn into_response(self, req: &HttpRequest) -> HttpResponse {
if self.status_code != StatusCode::OK {
let mut res = HttpResponse::build(self.status_code);
if self.flags.contains(Flags::PREFER_UTF8) {
let ct = equiv_utf8_text(self.content_type.clone());
- res.header(header::CONTENT_TYPE, ct.to_string());
+ res.insert_header((header::CONTENT_TYPE, ct.to_string()));
} else {
- res.header(header::CONTENT_TYPE, self.content_type.to_string());
+ res.insert_header((header::CONTENT_TYPE, self.content_type.to_string()));
}
if self.flags.contains(Flags::CONTENT_DISPOSITION) {
- res.header(
+ res.insert_header((
header::CONTENT_DISPOSITION,
self.content_disposition.to_string(),
- );
+ ));
}
if let Some(current_encoding) = self.encoding {
res.encoding(current_encoding);
}
- let reader = ChunkedReadFile {
- size: self.md.len(),
- offset: 0,
- file: Some(self.file),
- fut: None,
- counter: 0,
- };
+ let reader = ChunkedReadFile::new(self.md.len(), 0, self.file);
- return Ok(res.streaming(reader));
+ return res.streaming(reader);
}
let etag = if self.flags.contains(Flags::ETAG) {
@@ -332,7 +324,7 @@ impl NamedFile {
let t2: SystemTime = since.clone().into();
match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
- (Ok(t1), Ok(t2)) => t1 > t2,
+ (Ok(t1), Ok(t2)) => t1.as_secs() > t2.as_secs(),
_ => false,
}
} else {
@@ -351,7 +343,7 @@ impl NamedFile {
let t2: SystemTime = since.clone().into();
match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
- (Ok(t1), Ok(t2)) => t1 <= t2,
+ (Ok(t1), Ok(t2)) => t1.as_secs() <= t2.as_secs(),
_ => false,
}
} else {
@@ -362,16 +354,16 @@ impl NamedFile {
if self.flags.contains(Flags::PREFER_UTF8) {
let ct = equiv_utf8_text(self.content_type.clone());
- resp.header(header::CONTENT_TYPE, ct.to_string());
+ resp.insert_header((header::CONTENT_TYPE, ct.to_string()));
} else {
- resp.header(header::CONTENT_TYPE, self.content_type.to_string());
+ resp.insert_header((header::CONTENT_TYPE, self.content_type.to_string()));
}
if self.flags.contains(Flags::CONTENT_DISPOSITION) {
- resp.header(
+ resp.insert_header((
header::CONTENT_DISPOSITION,
self.content_disposition.to_string(),
- );
+ ));
}
// default compressing
@@ -380,14 +372,14 @@ impl NamedFile {
}
if let Some(lm) = last_modified {
- resp.header(header::LAST_MODIFIED, lm.to_string());
+ resp.insert_header((header::LAST_MODIFIED, lm.to_string()));
}
if let Some(etag) = etag {
- resp.header(header::ETAG, etag.to_string());
+ resp.insert_header((header::ETAG, etag.to_string()));
}
- resp.header(header::ACCEPT_RANGES, "bytes");
+ resp.insert_header((header::ACCEPT_RANGES, "bytes"));
let mut length = self.md.len();
let mut offset = 0;
@@ -400,43 +392,32 @@ impl NamedFile {
offset = ranges[0].start;
resp.encoding(ContentEncoding::Identity);
- resp.header(
+ resp.insert_header((
header::CONTENT_RANGE,
- format!(
- "bytes {}-{}/{}",
- offset,
- offset + length - 1,
- self.md.len()
- ),
- );
+ format!("bytes {}-{}/{}", offset, offset + length - 1, self.md.len()),
+ ));
} else {
- resp.header(header::CONTENT_RANGE, format!("bytes */{}", length));
- return Ok(resp.status(StatusCode::RANGE_NOT_SATISFIABLE).finish());
+ resp.insert_header((header::CONTENT_RANGE, format!("bytes */{}", length)));
+ return resp.status(StatusCode::RANGE_NOT_SATISFIABLE).finish();
};
} else {
- return Ok(resp.status(StatusCode::BAD_REQUEST).finish());
+ return resp.status(StatusCode::BAD_REQUEST).finish();
};
};
if precondition_failed {
- return Ok(resp.status(StatusCode::PRECONDITION_FAILED).finish());
+ return resp.status(StatusCode::PRECONDITION_FAILED).finish();
} else if not_modified {
- return Ok(resp.status(StatusCode::NOT_MODIFIED).finish());
+ return resp.status(StatusCode::NOT_MODIFIED).finish();
}
- let reader = ChunkedReadFile {
- offset,
- size: length,
- file: Some(self.file),
- fut: None,
- counter: 0,
- };
+ let reader = ChunkedReadFile::new(length, offset, self.file);
if offset != 0 || length != self.md.len() {
resp.status(StatusCode::PARTIAL_CONTENT);
}
- Ok(resp.body(SizedStream::new(length, reader)))
+ resp.body(SizedStream::new(length, reader))
}
}
@@ -495,10 +476,7 @@ fn none_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
}
impl Responder for NamedFile {
- type Error = Error;
- type Future = Ready>;
-
- fn respond_to(self, req: &HttpRequest) -> Self::Future {
- ready(self.into_response(req))
+ fn respond_to(self, req: &HttpRequest) -> HttpResponse {
+ self.into_response(req)
}
}
diff --git a/actix-files/src/range.rs b/actix-files/src/range.rs
index e420ce414..8d9fe9445 100644
--- a/actix-files/src/range.rs
+++ b/actix-files/src/range.rs
@@ -10,9 +10,6 @@ pub struct HttpRange {
pub length: u64,
}
-const PREFIX: &str = "bytes=";
-const PREFIX_LEN: usize = 6;
-
#[derive(Debug, Clone, Display, Error)]
#[display(fmt = "Parse HTTP Range failed")]
pub struct ParseRangeErr(#[error(not(source))] ());
@@ -23,84 +20,16 @@ impl HttpRange {
/// `header` is HTTP Range header (e.g. `bytes=bytes=0-9`).
/// `size` is full size of response (file).
pub fn parse(header: &str, size: u64) -> Result, ParseRangeErr> {
- if header.is_empty() {
- return Ok(Vec::new());
+ match http_range::HttpRange::parse(header, size) {
+ Ok(ranges) => Ok(ranges
+ .iter()
+ .map(|range| HttpRange {
+ start: range.start,
+ length: range.length,
+ })
+ .collect()),
+ Err(_) => Err(ParseRangeErr(())),
}
- if !header.starts_with(PREFIX) {
- return Err(ParseRangeErr(()));
- }
-
- let size_sig = size as i64;
- let mut no_overlap = false;
-
- let all_ranges: Vec> = header[PREFIX_LEN..]
- .split(',')
- .map(|x| x.trim())
- .filter(|x| !x.is_empty())
- .map(|ra| {
- let mut start_end_iter = ra.split('-');
-
- let start_str = start_end_iter.next().ok_or(ParseRangeErr(()))?.trim();
- let end_str = start_end_iter.next().ok_or(ParseRangeErr(()))?.trim();
-
- if start_str.is_empty() {
- // If no start is specified, end specifies the
- // range start relative to the end of the file.
- let mut length: i64 =
- end_str.parse().map_err(|_| ParseRangeErr(()))?;
-
- if length > size_sig {
- length = size_sig;
- }
-
- Ok(Some(HttpRange {
- start: (size_sig - length) as u64,
- length: length as u64,
- }))
- } else {
- let start: i64 = start_str.parse().map_err(|_| ParseRangeErr(()))?;
-
- if start < 0 {
- return Err(ParseRangeErr(()));
- }
- if start >= size_sig {
- no_overlap = true;
- return Ok(None);
- }
-
- let length = if end_str.is_empty() {
- // If no end is specified, range extends to end of the file.
- size_sig - start
- } else {
- let mut end: i64 =
- end_str.parse().map_err(|_| ParseRangeErr(()))?;
-
- if start > end {
- return Err(ParseRangeErr(()));
- }
-
- if end >= size_sig {
- end = size_sig - 1;
- }
-
- end - start + 1
- };
-
- Ok(Some(HttpRange {
- start: start as u64,
- length: length as u64,
- }))
- }
- })
- .collect::>()?;
-
- let ranges: Vec = all_ranges.into_iter().filter_map(|x| x).collect();
-
- if no_overlap && ranges.is_empty() {
- return Err(ParseRangeErr(()));
- }
-
- Ok(ranges)
}
}
diff --git a/actix-files/src/service.rs b/actix-files/src/service.rs
index dc4f2bd2c..14eea6ebc 100644
--- a/actix-files/src/service.rs
+++ b/actix-files/src/service.rs
@@ -1,9 +1,4 @@
-use std::{
- fmt, io,
- path::PathBuf,
- rc::Rc,
- task::{Context, Poll},
-};
+use std::{fmt, io, path::PathBuf, rc::Rc, task::Poll};
use actix_service::Service;
use actix_web::{
@@ -16,8 +11,8 @@ use actix_web::{
use futures_util::future::{ok, Either, LocalBoxFuture, Ready};
use crate::{
- named, Directory, DirectoryRenderer, FilesError, HttpService, MimeOverride,
- NamedFile, PathBufWrap,
+ named, Directory, DirectoryRenderer, FilesError, HttpService, MimeOverride, NamedFile,
+ PathBufWrap,
};
/// Assembled file serving service.
@@ -40,10 +35,10 @@ type FilesServiceFuture = Either<
>;
impl FilesService {
- fn handle_err(&mut self, e: io::Error, req: ServiceRequest) -> FilesServiceFuture {
+ fn handle_err(&self, e: io::Error, req: ServiceRequest) -> FilesServiceFuture {
log::debug!("Failed to handle {}: {}", req.path(), e);
- if let Some(ref mut default) = self.default {
+ if let Some(ref default) = self.default {
Either::Right(default.call(req))
} else {
Either::Left(ok(req.error_response(e)))
@@ -57,17 +52,14 @@ impl fmt::Debug for FilesService {
}
}
-impl Service for FilesService {
- type Request = ServiceRequest;
+impl Service for FilesService {
type Response = ServiceResponse;
type Error = Error;
type Future = FilesServiceFuture;
- fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll> {
- Poll::Ready(Ok(()))
- }
+ actix_service::always_ready!();
- fn call(&mut self, req: ServiceRequest) -> Self::Future {
+ fn call(&self, req: ServiceRequest) -> Self::Future {
let is_method_valid = if let Some(guard) = &self.guards {
// execute user defined guards
(**guard).check(req.head())
@@ -79,7 +71,7 @@ impl Service for FilesService {
if !is_method_valid {
return Either::Left(ok(req.into_response(
actix_web::HttpResponse::MethodNotAllowed()
- .header(header::CONTENT_TYPE, "text/plain")
+ .insert_header(header::ContentType(mime::TEXT_PLAIN_UTF_8))
.body("Request did not meet this resource's requirements."),
)));
}
@@ -103,7 +95,7 @@ impl Service for FilesService {
return Either::Left(ok(req.into_response(
HttpResponse::Found()
- .header(header::LOCATION, redirect_to)
+ .insert_header((header::LOCATION, redirect_to))
.body("")
.into_body(),
)));
@@ -121,10 +113,8 @@ impl Service for FilesService {
named_file.flags = self.file_flags;
let (req, _) = req.into_parts();
- Either::Left(ok(match named_file.into_response(&req) {
- Ok(item) => ServiceResponse::new(req, item),
- Err(e) => ServiceResponse::from_err(e, req),
- }))
+ let res = named_file.into_response(&req);
+ Either::Left(ok(ServiceResponse::new(req, res)))
}
Err(e) => self.handle_err(e, req),
}
@@ -148,19 +138,14 @@ impl Service for FilesService {
match NamedFile::open(path) {
Ok(mut named_file) => {
if let Some(ref mime_override) = self.mime_override {
- let new_disposition =
- mime_override(&named_file.content_type.type_());
+ let new_disposition = mime_override(&named_file.content_type.type_());
named_file.content_disposition.disposition = new_disposition;
}
named_file.flags = self.file_flags;
let (req, _) = req.into_parts();
- match named_file.into_response(&req) {
- Ok(item) => {
- Either::Left(ok(ServiceResponse::new(req.clone(), item)))
- }
- Err(e) => Either::Left(ok(ServiceResponse::from_err(e, req))),
- }
+ let res = named_file.into_response(&req);
+ Either::Left(ok(ServiceResponse::new(req, res)))
}
Err(e) => self.handle_err(e, req),
}
diff --git a/actix-files/tests/encoding.rs b/actix-files/tests/encoding.rs
index d7e01b305..d21d4f8fd 100644
--- a/actix-files/tests/encoding.rs
+++ b/actix-files/tests/encoding.rs
@@ -11,11 +11,10 @@ use actix_web::{
#[actix_rt::test]
async fn test_utf8_file_contents() {
// use default ISO-8859-1 encoding
- let mut srv =
- test::init_service(App::new().service(Files::new("/", "./tests"))).await;
+ let srv = test::init_service(App::new().service(Files::new("/", "./tests"))).await;
let req = TestRequest::with_uri("/utf8.txt").to_request();
- let res = test::call_service(&mut srv, req).await;
+ let res = test::call_service(&srv, req).await;
assert_eq!(res.status(), StatusCode::OK);
assert_eq!(
@@ -24,13 +23,12 @@ async fn test_utf8_file_contents() {
);
// prefer UTF-8 encoding
- let mut srv = test::init_service(
- App::new().service(Files::new("/", "./tests").prefer_utf8(true)),
- )
- .await;
+ let srv =
+ test::init_service(App::new().service(Files::new("/", "./tests").prefer_utf8(true)))
+ .await;
let req = TestRequest::with_uri("/utf8.txt").to_request();
- let res = test::call_service(&mut srv, req).await;
+ let res = test::call_service(&srv, req).await;
assert_eq!(res.status(), StatusCode::OK);
assert_eq!(
diff --git a/actix-http-test/CHANGES.md b/actix-http-test/CHANGES.md
index 835b75ddc..2f47d700d 100644
--- a/actix-http-test/CHANGES.md
+++ b/actix-http-test/CHANGES.md
@@ -1,6 +1,16 @@
# Changes
-## Unreleased - 2020-xx-xx
+## Unreleased - 2021-xx-xx
+
+
+## 3.0.0-beta.2 - 2021-02-10
+* No notable changes.
+
+
+## 3.0.0-beta.1 - 2021-01-07
+* Update `bytes` to `1.0`. [#1813]
+
+[#1813]: https://github.com/actix/actix-web/pull/1813
## 2.1.0 - 2020-11-25
diff --git a/actix-http-test/Cargo.toml b/actix-http-test/Cargo.toml
index 8b23bef1c..8ec073661 100644
--- a/actix-http-test/Cargo.toml
+++ b/actix-http-test/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "actix-http-test"
-version = "2.1.0"
+version = "3.0.0-beta.2"
authors = ["Nikolay Kim "]
description = "Various helpers for Actix applications to use during testing"
readme = "README.md"
@@ -26,31 +26,36 @@ path = "src/lib.rs"
default = []
# openssl
-openssl = ["open-ssl", "awc/openssl"]
+openssl = ["tls-openssl", "awc/openssl"]
[dependencies]
-actix-service = "1.0.6"
-actix-codec = "0.3.0"
-actix-connect = "2.0.0"
-actix-utils = "2.0.0"
-actix-rt = "1.1.1"
-actix-server = "1.0.0"
-actix-testing = "1.0.0"
-awc = "2.0.0"
+actix-service = "2.0.0-beta.4"
+actix-codec = "0.4.0-beta.1"
+actix-tls = "3.0.0-beta.3"
+actix-utils = "3.0.0-beta.2"
+actix-rt = "2"
+actix-server = "2.0.0-beta.3"
+awc = { version = "3.0.0-beta.2", default-features = false }
base64 = "0.13"
-bytes = "0.5.3"
-futures-core = { version = "0.3.5", default-features = false }
-http = "0.2.0"
+bytes = "1"
+futures-core = { version = "0.3.7", default-features = false }
+http = "0.2.2"
log = "0.4"
socket2 = "0.3"
serde = "1.0"
serde_json = "1.0"
slab = "0.4"
serde_urlencoded = "0.7"
-time = { version = "0.2.7", default-features = false, features = ["std"] }
-open-ssl = { version = "0.10", package = "openssl", optional = true }
+time = { version = "0.2.23", default-features = false, features = ["std"] }
+tls-openssl = { version = "0.10.9", package = "openssl", optional = true }
+
+[target.'cfg(windows)'.dependencies.tls-openssl]
+version = "0.10.9"
+package = "openssl"
+features = ["vendored"]
+optional = true
[dev-dependencies]
-actix-web = "3.0.0"
-actix-http = "2.0.0"
+actix-web = { version = "4.0.0-beta.3", default-features = false, features = ["cookies"] }
+actix-http = "3.0.0-beta.3"
diff --git a/actix-http-test/README.md b/actix-http-test/README.md
index bca9a7976..66f15979d 100644
--- a/actix-http-test/README.md
+++ b/actix-http-test/README.md
@@ -4,7 +4,7 @@
[](https://crates.io/crates/actix-http-test)
[](https://docs.rs/actix-http-test/2.1.0)
-
+
[](https://deps.rs/crate/actix-http-test/2.1.0)
[](https://gitter.im/actix/actix-web?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
diff --git a/actix-http-test/src/lib.rs b/actix-http-test/src/lib.rs
index 4d4bd6f2d..336dfe312 100644
--- a/actix-http-test/src/lib.rs
+++ b/actix-http-test/src/lib.rs
@@ -5,6 +5,9 @@
#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
#![clippy::msrv = "1.46"]
+#[cfg(feature = "openssl")]
+extern crate tls_openssl as openssl;
+
use std::sync::mpsc;
use std::{net, thread, time};
@@ -17,8 +20,6 @@ use futures_core::stream::Stream;
use http::Method;
use socket2::{Domain, Protocol, Socket, Type};
-pub use actix_testing::*;
-
/// Start test server
///
/// `TestServer` is very simple test server that simplify process of writing
@@ -63,16 +64,19 @@ pub async fn test_server_with_addr>(
// run server in separate thread
thread::spawn(move || {
- let sys = System::new("actix-test-server");
+ let sys = System::new();
let local_addr = tcp.local_addr().unwrap();
- Server::build()
+ let srv = Server::build()
.listen("test", tcp, factory)?
.workers(1)
- .disable_signals()
- .start();
+ .disable_signals();
+
+ sys.block_on(async {
+ srv.run();
+ tx.send((System::current(), local_addr)).unwrap();
+ });
- tx.send((System::current(), local_addr)).unwrap();
sys.run()
});
@@ -82,7 +86,7 @@ pub async fn test_server_with_addr>(
let connector = {
#[cfg(feature = "openssl")]
{
- use open_ssl::ssl::{SslConnector, SslMethod, SslVerifyMode};
+ use openssl::ssl::{SslConnector, SslMethod, SslVerifyMode};
let mut builder = SslConnector::builder(SslMethod::tls()).unwrap();
builder.set_verify(SslVerifyMode::NONE);
@@ -93,20 +97,17 @@ pub async fn test_server_with_addr>(
.conn_lifetime(time::Duration::from_secs(0))
.timeout(time::Duration::from_millis(30000))
.ssl(builder.build())
- .finish()
}
#[cfg(not(feature = "openssl"))]
{
Connector::new()
.conn_lifetime(time::Duration::from_secs(0))
.timeout(time::Duration::from_millis(30000))
- .finish()
}
};
Client::builder().connector(connector).finish()
};
- actix_connect::start_default_resolver().await.unwrap();
TestServer {
addr,
@@ -118,8 +119,7 @@ pub async fn test_server_with_addr>(
/// Get first available unused address
pub fn unused_addr() -> net::SocketAddr {
let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
- let socket =
- Socket::new(Domain::ipv4(), Type::stream(), Some(Protocol::tcp())).unwrap();
+ let socket = Socket::new(Domain::ipv4(), Type::stream(), Some(Protocol::tcp())).unwrap();
socket.bind(&addr.into()).unwrap();
socket.set_reuse_address(true).unwrap();
let tcp = socket.into_tcp_listener();
@@ -148,7 +148,7 @@ impl TestServer {
}
}
- /// Construct test https server url
+ /// Construct test HTTPS server URL.
pub fn surl(&self, uri: &str) -> String {
if uri.starts_with('/') {
format!("https://localhost:{}{}", self.addr.port(), uri)
@@ -162,7 +162,7 @@ impl TestServer {
self.client.get(self.url(path.as_ref()).as_str())
}
- /// Create https `GET` request
+ /// Create HTTPS `GET` request
pub fn sget>(&self, path: S) -> ClientRequest {
self.client.get(self.surl(path.as_ref()).as_str())
}
@@ -172,7 +172,7 @@ impl TestServer {
self.client.post(self.url(path.as_ref()).as_str())
}
- /// Create https `POST` request
+ /// Create HTTPS `POST` request
pub fn spost>(&self, path: S) -> ClientRequest {
self.client.post(self.surl(path.as_ref()).as_str())
}
@@ -182,7 +182,7 @@ impl TestServer {
self.client.head(self.url(path.as_ref()).as_str())
}
- /// Create https `HEAD` request
+ /// Create HTTPS `HEAD` request
pub fn shead>(&self, path: S) -> ClientRequest {
self.client.head(self.surl(path.as_ref()).as_str())
}
@@ -192,7 +192,7 @@ impl TestServer {
self.client.put(self.url(path.as_ref()).as_str())
}
- /// Create https `PUT` request
+ /// Create HTTPS `PUT` request
pub fn sput>(&self, path: S) -> ClientRequest {
self.client.put(self.surl(path.as_ref()).as_str())
}
@@ -202,7 +202,7 @@ impl TestServer {
self.client.patch(self.url(path.as_ref()).as_str())
}
- /// Create https `PATCH` request
+ /// Create HTTPS `PATCH` request
pub fn spatch>(&self, path: S) -> ClientRequest {
self.client.patch(self.surl(path.as_ref()).as_str())
}
@@ -212,7 +212,7 @@ impl TestServer {
self.client.delete(self.url(path.as_ref()).as_str())
}
- /// Create https `DELETE` request
+ /// Create HTTPS `DELETE` request
pub fn sdelete>(&self, path: S) -> ClientRequest {
self.client.delete(self.surl(path.as_ref()).as_str())
}
@@ -222,12 +222,12 @@ impl TestServer {
self.client.options(self.url(path.as_ref()).as_str())
}
- /// Create https `OPTIONS` request
+ /// Create HTTPS `OPTIONS` request
pub fn soptions>(&self, path: S) -> ClientRequest {
self.client.options(self.surl(path.as_ref()).as_str())
}
- /// Connect to test http server
+ /// Connect to test HTTP server
pub fn request>(&self, method: Method, path: S) -> ClientRequest {
self.client.request(method, path.as_ref())
}
@@ -242,26 +242,24 @@ impl TestServer {
response.body().limit(10_485_760).await
}
- /// Connect to websocket server at a given path
+ /// Connect to WebSocket server at a given path.
pub async fn ws_at(
&mut self,
path: &str,
- ) -> Result, awc::error::WsClientError>
- {
+ ) -> Result, awc::error::WsClientError> {
let url = self.url(path);
let connect = self.client.ws(url).connect();
connect.await.map(|(_, framed)| framed)
}
- /// Connect to a websocket server
+ /// Connect to a WebSocket server.
pub async fn ws(
&mut self,
- ) -> Result, awc::error::WsClientError>
- {
+ ) -> Result, awc::error::WsClientError> {
self.ws_at("/").await
}
- /// Stop http server
+ /// Stop HTTP server
fn stop(&mut self) {
self.system.stop();
}
diff --git a/actix-http/CHANGES.md b/actix-http/CHANGES.md
index c43246bb0..6ba111eb3 100644
--- a/actix-http/CHANGES.md
+++ b/actix-http/CHANGES.md
@@ -1,14 +1,99 @@
# Changes
-## Unreleased - 2020-xx-xx
+## Unreleased - 2021-xx-xx
### Changed
-* Bumped `rand` to `0.8`
+* Feature `cookies` is now optional and disabled by default. [#1981]
+
+### Removed
+* re-export of `futures_channel::oneshot::Canceled` is removed from `error` mod. [#1994]
+* `ResponseError` impl for `futures_channel::oneshot::Canceled` is removed. [#1994]
+
+[#1981]: https://github.com/actix/actix-web/pull/1981
+[#1994]: https://github.com/actix/actix-web/pull/1994
+
+
+## 3.0.0-beta.3 - 2021-02-10
+* No notable changes.
+
+
+## 3.0.0-beta.2 - 2021-02-10
+### Added
+* `IntoHeaderPair` trait that allows using typed and untyped headers in the same methods. [#1869]
+* `ResponseBuilder::insert_header` method which allows using typed headers. [#1869]
+* `ResponseBuilder::append_header` method which allows using typed headers. [#1869]
+* `TestRequest::insert_header` method which allows using typed headers. [#1869]
+* `ContentEncoding` implements all necessary header traits. [#1912]
+* `HeaderMap::len_keys` has the behavior of the old `len` method. [#1964]
+* `HeaderMap::drain` as an efficient draining iterator. [#1964]
+* Implement `IntoIterator` for owned `HeaderMap`. [#1964]
+* `trust-dns` optional feature to enable `trust-dns-resolver` as client dns resolver. [#1969]
+
+### Changed
+* `ResponseBuilder::content_type` now takes an `impl IntoHeaderValue` to support using typed
+ `mime` types. [#1894]
+* Renamed `IntoHeaderValue::{try_into => try_into_value}` to avoid ambiguity with std
+ `TryInto` trait. [#1894]
+* `Extensions::insert` returns Option of replaced item. [#1904]
+* Remove `HttpResponseBuilder::json2()`. [#1903]
+* Enable `HttpResponseBuilder::json()` to receive data by value and reference. [#1903]
+* `client::error::ConnectError` Resolver variant contains `Box` type. [#1905]
+* `client::ConnectorConfig` default timeout changed to 5 seconds. [#1905]
+* Simplify `BlockingError` type to a unit struct. It's now only triggered when blocking thread pool
+ is dead. [#1957]
+* `HeaderMap::len` now returns number of values instead of number of keys. [#1964]
+* `HeaderMap::insert` now returns iterator of removed values. [#1964]
+* `HeaderMap::remove` now returns iterator of removed values. [#1964]
+
+### Removed
+* `ResponseBuilder::set`; use `ResponseBuilder::insert_header`. [#1869]
+* `ResponseBuilder::set_header`; use `ResponseBuilder::insert_header`. [#1869]
+* `ResponseBuilder::header`; use `ResponseBuilder::append_header`. [#1869]
+* `TestRequest::with_hdr`; use `TestRequest::default().insert_header()`. [#1869]
+* `TestRequest::with_header`; use `TestRequest::default().insert_header()`. [#1869]
+* `actors` optional feature. [#1969]
+* `ResponseError` impl for `actix::MailboxError`. [#1969]
+
+### Documentation
+* Vastly improve docs and add examples for `HeaderMap`. [#1964]
+
+[#1869]: https://github.com/actix/actix-web/pull/1869
+[#1894]: https://github.com/actix/actix-web/pull/1894
+[#1903]: https://github.com/actix/actix-web/pull/1903
+[#1904]: https://github.com/actix/actix-web/pull/1904
+[#1905]: https://github.com/actix/actix-web/pull/1905
+[#1912]: https://github.com/actix/actix-web/pull/1912
+[#1957]: https://github.com/actix/actix-web/pull/1957
+[#1964]: https://github.com/actix/actix-web/pull/1964
+[#1969]: https://github.com/actix/actix-web/pull/1969
+
+
+## 3.0.0-beta.1 - 2021-01-07
+### Added
+* Add `Http3` to `Protocol` enum for future compatibility and also mark `#[non_exhaustive]`.
+
+### Changed
+* Update `actix-*` dependencies to tokio `1.0` based versions. [#1813]
+* Bumped `rand` to `0.8`.
+* Update `bytes` to `1.0`. [#1813]
+* Update `h2` to `0.3`. [#1813]
+* The `ws::Message::Text` enum variant now contains a `bytestring::ByteString`. [#1864]
### Removed
* Deprecated `on_connect` methods have been removed. Prefer the new
`on_connect_ext` technique. [#1857]
+* Remove `ResponseError` impl for `actix::actors::resolver::ResolverError`
+ due to deprecate of resolver actor. [#1813]
+* Remove `ConnectError::SslHandshakeError` and re-export of `HandshakeError`.
+ due to the removal of this type from `tokio-openssl` crate. openssl handshake
+ error would return as `ConnectError::SslError`. [#1813]
+* Remove `actix-threadpool` dependency. Use `actix_rt::task::spawn_blocking`.
+ Due to this change `actix_threadpool::BlockingError` type is moved into
+ `actix_http::error` module. [#1878]
+[#1813]: https://github.com/actix/actix-web/pull/1813
[#1857]: https://github.com/actix/actix-web/pull/1857
+[#1864]: https://github.com/actix/actix-web/pull/1864
+[#1878]: https://github.com/actix/actix-web/pull/1878
## 2.2.0 - 2020-11-25
@@ -55,15 +140,14 @@
* Update actix-connect and actix-tls dependencies.
-## [2.0.0-beta.3] - 2020-08-14
-
+## 2.0.0-beta.3 - 2020-08-14
### Fixed
* Memory leak of `client::pool::ConnectorPoolSupport`. [#1626]
[#1626]: https://github.com/actix/actix-web/pull/1626
-## [2.0.0-beta.2] - 2020-07-21
+## 2.0.0-beta.2 - 2020-07-21
### Fixed
* Potential UB in h1 decoder using uninitialized memory. [#1614]
@@ -74,10 +158,8 @@
[#1615]: https://github.com/actix/actix-web/pull/1615
-## [2.0.0-beta.1] - 2020-07-11
-
+## 2.0.0-beta.1 - 2020-07-11
### Changed
-
* Migrate cookie handling to `cookie` crate. [#1558]
* Update `sha-1` to 0.9. [#1586]
* Fix leak in client pool. [#1580]
@@ -87,33 +169,30 @@
[#1586]: https://github.com/actix/actix-web/pull/1586
[#1580]: https://github.com/actix/actix-web/pull/1580
-## [2.0.0-alpha.4] - 2020-05-21
+## 2.0.0-alpha.4 - 2020-05-21
### Changed
-
* Bump minimum supported Rust version to 1.40
-* content_length function is removed, and you can set Content-Length by calling no_chunking function [#1439]
+* content_length function is removed, and you can set Content-Length by calling
+ no_chunking function [#1439]
* `BodySize::Sized64` variant has been removed. `BodySize::Sized` now receives a
`u64` instead of a `usize`.
* Update `base64` dependency to 0.12
### Fixed
-
* Support parsing of `SameSite=None` [#1503]
[#1439]: https://github.com/actix/actix-web/pull/1439
[#1503]: https://github.com/actix/actix-web/pull/1503
-## [2.0.0-alpha.3] - 2020-05-08
+## 2.0.0-alpha.3 - 2020-05-08
### Fixed
-
* Correct spelling of ConnectError::Unresolved [#1487]
* Fix a mistake in the encoding of websocket continuation messages wherein
Item::FirstText and Item::FirstBinary are each encoded as the other.
### Changed
-
* Implement `std::error::Error` for our custom errors [#1422]
* Remove `failure` support for `ResponseError` since that crate
will be deprecated in the near future.
@@ -121,338 +200,247 @@
[#1422]: https://github.com/actix/actix-web/pull/1422
[#1487]: https://github.com/actix/actix-web/pull/1487
-## [2.0.0-alpha.2] - 2020-03-07
+## 2.0.0-alpha.2 - 2020-03-07
### Changed
-
* Update `actix-connect` and `actix-tls` dependency to 2.0.0-alpha.1. [#1395]
-
-* Change default initial window size and connection window size for HTTP2 to 2MB and 1MB respectively
- to improve download speed for awc when downloading large objects. [#1394]
-
-* client::Connector accepts initial_window_size and initial_connection_window_size HTTP2 configuration. [#1394]
-
+* Change default initial window size and connection window size for HTTP2 to 2MB and 1MB
+ respectively to improve download speed for awc when downloading large objects. [#1394]
+* client::Connector accepts initial_window_size and initial_connection_window_size
+ HTTP2 configuration. [#1394]
* client::Connector allowing to set max_http_version to limit HTTP version to be used. [#1394]
[#1394]: https://github.com/actix/actix-web/pull/1394
[#1395]: https://github.com/actix/actix-web/pull/1395
-## [2.0.0-alpha.1] - 2020-02-27
+## 2.0.0-alpha.1 - 2020-02-27
### Changed
-
* Update the `time` dependency to 0.2.7.
* Moved actors messages support from actix crate, enabled with feature `actors`.
-* Breaking change: trait MessageBody requires Unpin and accepting Pin<&mut Self> instead of &mut self in the poll_next().
+* Breaking change: trait MessageBody requires Unpin and accepting `Pin<&mut Self>` instead of
+ `&mut self` in the poll_next().
* MessageBody is not implemented for &'static [u8] anymore.
### Fixed
-
* Allow `SameSite=None` cookies to be sent in a response.
-## [1.0.1] - 2019-12-20
+## 1.0.1 - 2019-12-20
### Fixed
-
* Poll upgrade service's readiness from HTTP service handlers
-
* Replace brotli with brotli2 #1224
-## [1.0.0] - 2019-12-13
+## 1.0.0 - 2019-12-13
### Added
-
* Add websockets continuation frame support
### Changed
-
* Replace `flate2-xxx` features with `compress`
-## [1.0.0-alpha.5] - 2019-12-09
+## 1.0.0-alpha.5 - 2019-12-09
### Fixed
-
* Check `Upgrade` service readiness before calling it
-
-* Fix buffer remaining capacity calcualtion
+* Fix buffer remaining capacity calculation
### Changed
-
* Websockets: Ping and Pong should have binary data #1049
-## [1.0.0-alpha.4] - 2019-12-08
+## 1.0.0-alpha.4 - 2019-12-08
### Added
-
* Add impl ResponseBuilder for Error
### Changed
-
* Use rust based brotli compression library
-## [1.0.0-alpha.3] - 2019-12-07
-
+## 1.0.0-alpha.3 - 2019-12-07
### Changed
-
* Migrate to tokio 0.2
-
* Migrate to `std::future`
-## [0.2.11] - 2019-11-06
-
+## 0.2.11 - 2019-11-06
### Added
-
* Add support for serde_json::Value to be passed as argument to ResponseBuilder.body()
-
-* Add an additional `filename*` param in the `Content-Disposition` header of `actix_files::NamedFile` to be more compatible. (#1151)
-
+* Add an additional `filename*` param in the `Content-Disposition` header of
+ `actix_files::NamedFile` to be more compatible. (#1151)
* Allow to use `std::convert::Infallible` as `actix_http::error::Error`
### Fixed
+* To be compatible with non-English error responses, `ResponseError` rendered with `text/plain;
+ charset=utf-8` header [#1118]
-* To be compatible with non-English error responses, `ResponseError` rendered with `text/plain; charset=utf-8` header #1118
+[#1878]: https://github.com/actix/actix-web/pull/1878
-## [0.2.10] - 2019-09-11
-
+## 0.2.10 - 2019-09-11
### Added
-
-* Add support for sending HTTP requests with `Rc` in addition to sending HTTP requests with `RequestHead`
+* Add support for sending HTTP requests with `Rc` in addition to sending HTTP requests
+ with `RequestHead`
### Fixed
-
* h2 will use error response #1080
-
* on_connect result isn't added to request extensions for http2 requests #1009
-## [0.2.9] - 2019-08-13
-
+## 0.2.9 - 2019-08-13
### Changed
-
* Dropped the `byteorder`-dependency in favor of `stdlib`-implementation
-
* Update percent-encoding to 2.1
-
* Update serde_urlencoded to 0.6.1
### Fixed
-
* Fixed a panic in the HTTP2 handshake in client HTTP requests (#1031)
-## [0.2.8] - 2019-08-01
-
+## 0.2.8 - 2019-08-01
### Added
-
* Add `rustls` support
-
* Add `Clone` impl for `HeaderMap`
### Fixed
-
* awc client panic #1016
-
-* Invalid response with compression middleware enabled, but compression-related features disabled #997
+* Invalid response with compression middleware enabled, but compression-related features
+ disabled #997
-## [0.2.7] - 2019-07-18
-
+## 0.2.7 - 2019-07-18
### Added
-
* Add support for downcasting response errors #986
-## [0.2.6] - 2019-07-17
-
+## 0.2.6 - 2019-07-17
### Changed
-
* Replace `ClonableService` with local copy
-
* Upgrade `rand` dependency version to 0.7
-## [0.2.5] - 2019-06-28
-
+## 0.2.5 - 2019-06-28
### Added
-
* Add `on-connect` callback, `HttpServiceBuilder::on_connect()` #946
### Changed
-
* Use `encoding_rs` crate instead of unmaintained `encoding` crate
-
* Add `Copy` and `Clone` impls for `ws::Codec`
-## [0.2.4] - 2019-06-16
-
+## 0.2.4 - 2019-06-16
### Fixed
-
* Do not compress NoContent (204) responses #918
-## [0.2.3] - 2019-06-02
-
+## 0.2.3 - 2019-06-02
### Added
-
* Debug impl for ResponseBuilder
-
* From SizedStream and BodyStream for Body
### Changed
-
* SizedStream uses u64
-## [0.2.2] - 2019-05-29
-
+## 0.2.2 - 2019-05-29
### Fixed
-
* Parse incoming stream before closing stream on disconnect #868
-## [0.2.1] - 2019-05-25
-
+## 0.2.1 - 2019-05-25
### Fixed
-
* Handle socket read disconnect
-## [0.2.0] - 2019-05-12
-
+## 0.2.0 - 2019-05-12
### Changed
-
* Update actix-service to 0.4
-
* Expect and upgrade services accept `ServerConfig` config.
### Deleted
-
* `OneRequest` service
-## [0.1.5] - 2019-05-04
-
+## 0.1.5 - 2019-05-04
### Fixed
-
* Clean up response extensions in response pool #817
-## [0.1.4] - 2019-04-24
-
+## 0.1.4 - 2019-04-24
### Added
-
* Allow to render h1 request headers in `Camel-Case`
### Fixed
-
* Read until eof for http/1.0 responses #771
-## [0.1.3] - 2019-04-23
-
+## 0.1.3 - 2019-04-23
### Fixed
-
* Fix http client pool management
-
* Fix http client wait queue management #794
-## [0.1.2] - 2019-04-23
-
+## 0.1.2 - 2019-04-23
### Fixed
-
* Fix BorrowMutError panic in client connector #793
-## [0.1.1] - 2019-04-19
-
+## 0.1.1 - 2019-04-19
### Changed
-
* Cookie::max_age() accepts value in seconds
-
* Cookie::max_age_time() accepts value in time::Duration
-
* Allow to specify server address for client connector
-## [0.1.0] - 2019-04-16
-
+## 0.1.0 - 2019-04-16
### Added
-
* Expose peer addr via `Request::peer_addr()` and `RequestHead::peer_addr`
### Changed
-
* `actix_http::encoding` always available
-
* use trust-dns-resolver 0.11.0
-## [0.1.0-alpha.5] - 2019-04-12
-
+## 0.1.0-alpha.5 - 2019-04-12
### Added
-
* Allow to use custom service for upgrade requests
-
* Added `h1::SendResponse` future.
### Changed
-
* MessageBody::length() renamed to MessageBody::size() for consistency
-
* ws handshake verification functions take RequestHead instead of Request
-## [0.1.0-alpha.4] - 2019-04-08
-
+## 0.1.0-alpha.4 - 2019-04-08
### Added
-
* Allow to use custom `Expect` handler
-
* Add minimal `std::error::Error` impl for `Error`
### Changed
-
* Export IntoHeaderValue
-
* Render error and return as response body
-
-* Use thread pool for response body comression
+* Use thread pool for response body compression
### Deleted
-
* Removed PayloadBuffer
-## [0.1.0-alpha.3] - 2019-04-02
-
+## 0.1.0-alpha.3 - 2019-04-02
### Added
-
* Warn when an unsealed private cookie isn't valid UTF-8
### Fixed
-
* Rust 1.31.0 compatibility
-
* Preallocate read buffer for h1 codec
-
* Detect socket disconnection during protocol selection
-## [0.1.0-alpha.2] - 2019-03-29
-
+## 0.1.0-alpha.2 - 2019-03-29
### Added
-
* Added ws::Message::Nop, no-op websockets message
### Changed
-
-* Do not use thread pool for decomression if chunk size is smaller than 2048.
+* Do not use thread pool for decompression if chunk size is smaller than 2048.
-## [0.1.0-alpha.1] - 2019-03-28
-
+## 0.1.0-alpha.1 - 2019-03-28
* Initial impl
diff --git a/actix-http/Cargo.toml b/actix-http/Cargo.toml
index 7cf344487..78fb55079 100644
--- a/actix-http/Cargo.toml
+++ b/actix-http/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "actix-http"
-version = "2.2.0"
+version = "3.0.0-beta.3"
authors = ["Nikolay Kim "]
description = "HTTP primitives for the Actix ecosystem"
readme = "README.md"
@@ -15,7 +15,8 @@ license = "MIT OR Apache-2.0"
edition = "2018"
[package.metadata.docs.rs]
-features = ["openssl", "rustls", "compress", "secure-cookies", "actors"]
+# features that docs.rs will build with
+features = ["openssl", "rustls", "compress", "cookies", "secure-cookies"]
[lib]
name = "actix_http"
@@ -25,49 +26,47 @@ path = "src/lib.rs"
default = []
# openssl
-openssl = ["actix-tls/openssl", "actix-connect/openssl"]
+openssl = ["actix-tls/openssl"]
# rustls support
-rustls = ["actix-tls/rustls", "actix-connect/rustls"]
+rustls = ["actix-tls/rustls"]
-# enable compressison support
+# enable compression support
compress = ["flate2", "brotli2"]
-# support for secure cookies
-secure-cookies = ["cookie/secure"]
+# support for cookies
+cookies = ["cookie"]
-# support for actix Actor messages
-actors = ["actix"]
+# support for secure cookies
+secure-cookies = ["cookies", "cookie/secure"]
+
+# trust-dns as client dns resolver
+trust-dns = ["trust-dns-resolver"]
[dependencies]
-actix-service = "1.0.6"
-actix-codec = "0.3.0"
-actix-connect = "2.0.0"
-actix-utils = "2.0.0"
-actix-rt = "1.0.0"
-actix-threadpool = "0.3.1"
-actix-tls = { version = "2.0.0", optional = true }
-actix = { version = "0.10.0", optional = true }
+actix-service = "2.0.0-beta.4"
+actix-codec = "0.4.0-beta.1"
+actix-utils = "3.0.0-beta.2"
+actix-rt = "2"
+actix-tls = "3.0.0-beta.2"
+ahash = "0.7"
base64 = "0.13"
bitflags = "1.2"
-bytes = "0.5.3"
-cookie = { version = "0.14.1", features = ["percent-encode"] }
-copyless = "0.1.4"
-derive_more = "0.99.2"
-either = "1.5.3"
+bytes = "1"
+bytestring = "1"
+cfg-if = "1"
+cookie = { version = "0.14.1", features = ["percent-encode"], optional = true }
+derive_more = "0.99.5"
encoding_rs = "0.8"
-futures-channel = { version = "0.3.5", default-features = false }
-futures-core = { version = "0.3.5", default-features = false }
-futures-util = { version = "0.3.5", default-features = false }
-fxhash = "0.2.1"
-h2 = "0.2.1"
-http = "0.2.0"
+futures-core = { version = "0.3.7", default-features = false, features = ["alloc"] }
+futures-util = { version = "0.3.7", default-features = false, features = ["alloc", "sink"] }
+h2 = "0.3.0"
+http = "0.2.2"
httparse = "1.3"
-indexmap = "1.3"
itoa = "0.4"
-lazy_static = "1.4"
language-tags = "0.2"
+lazy_static = "1.4"
log = "0.4"
mime = "0.3"
percent-encoding = "2.1"
@@ -76,28 +75,36 @@ rand = "0.8"
regex = "1.3"
serde = "1.0"
serde_json = "1.0"
-sha-1 = "0.9"
-slab = "0.4"
serde_urlencoded = "0.7"
-time = { version = "0.2.7", default-features = false, features = ["std"] }
+sha-1 = "0.9"
+smallvec = "1.6"
+time = { version = "0.2.23", default-features = false, features = ["std"] }
+tokio = { version = "1.2", features = ["sync"] }
# compression
brotli2 = { version="0.3.2", optional = true }
flate2 = { version = "1.0.13", optional = true }
+trust-dns-resolver = { version = "0.20.0", optional = true }
+
[dev-dependencies]
-actix-server = "1.0.1"
-actix-connect = { version = "2.0.0", features = ["openssl"] }
-actix-http-test = { version = "2.0.0", features = ["openssl"] }
-actix-tls = { version = "2.0.0", features = ["openssl"] }
+actix-server = "2.0.0-beta.3"
+actix-http-test = { version = "3.0.0-beta.2", features = ["openssl"] }
+actix-tls = { version = "3.0.0-beta.2", features = ["openssl"] }
criterion = "0.3"
-env_logger = "0.7"
+env_logger = "0.8"
+rcgen = "0.8"
serde_derive = "1.0"
-open-ssl = { version="0.10", package = "openssl" }
-rust-tls = { version="0.18", package = "rustls" }
+tls-openssl = { version = "0.10", package = "openssl" }
+tls-rustls = { version = "0.19", package = "rustls" }
+
+[target.'cfg(windows)'.dev-dependencies.tls-openssl]
+version = "0.10.9"
+package = "openssl"
+features = ["vendored"]
[[bench]]
-name = "content-length"
+name = "write-camel-case"
harness = false
[[bench]]
diff --git a/actix-http/README.md b/actix-http/README.md
index 9dfb85e24..881fbc8c5 100644
--- a/actix-http/README.md
+++ b/actix-http/README.md
@@ -3,10 +3,13 @@
> HTTP primitives for the Actix ecosystem.
[](https://crates.io/crates/actix-http)
-[](https://docs.rs/actix-http/2.2.0)
-
-[](https://deps.rs/crate/actix-http/2.2.0)
-[](https://gitter.im/actix/actix-web?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[](https://docs.rs/actix-http/3.0.0-beta.3)
+[](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
+
+
+[](https://deps.rs/crate/actix-http/3.0.0-beta.3)
+[](https://crates.io/crates/actix-http)
+[](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
## Documentation & Resources
diff --git a/actix-http/benches/content-length.rs b/actix-http/benches/content-length.rs
deleted file mode 100644
index 18a55a33b..000000000
--- a/actix-http/benches/content-length.rs
+++ /dev/null
@@ -1,291 +0,0 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-
-use bytes::BytesMut;
-
-// benchmark sending all requests at the same time
-fn bench_write_content_length(c: &mut Criterion) {
- let mut group = c.benchmark_group("write_content_length");
-
- let sizes = [
- 0, 1, 11, 83, 101, 653, 1001, 6323, 10001, 56329, 100001, 123456, 98724245,
- 4294967202,
- ];
-
- for i in sizes.iter() {
- group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
- b.iter(|| {
- let mut b = BytesMut::with_capacity(35);
- _original::write_content_length(i, &mut b)
- })
- });
-
- group.bench_with_input(BenchmarkId::new("New (safe)", i), i, |b, &i| {
- b.iter(|| {
- let mut b = BytesMut::with_capacity(35);
- _new::write_content_length(i, &mut b)
- })
- });
-
- group.bench_with_input(BenchmarkId::new("itoa", i), i, |b, &i| {
- b.iter(|| {
- let mut b = BytesMut::with_capacity(35);
- _itoa::write_content_length(i, &mut b)
- })
- });
- }
-
- group.finish();
-}
-
-criterion_group!(benches, bench_write_content_length);
-criterion_main!(benches);
-
-mod _itoa {
- use bytes::{BufMut, BytesMut};
-
- pub fn write_content_length(n: usize, bytes: &mut BytesMut) {
- if n == 0 {
- bytes.put_slice(b"\r\ncontent-length: 0\r\n");
- return;
- }
-
- let mut buf = itoa::Buffer::new();
-
- bytes.put_slice(b"\r\ncontent-length: ");
- bytes.put_slice(buf.format(n).as_bytes());
- bytes.put_slice(b"\r\n");
- }
-}
-
-mod _new {
- use bytes::{BufMut, BytesMut};
-
- const DIGITS_START: u8 = b'0';
-
- /// NOTE: bytes object has to contain enough space
- pub fn write_content_length(n: usize, bytes: &mut BytesMut) {
- if n == 0 {
- bytes.put_slice(b"\r\ncontent-length: 0\r\n");
- return;
- }
-
- bytes.put_slice(b"\r\ncontent-length: ");
-
- if n < 10 {
- bytes.put_u8(DIGITS_START + (n as u8));
- } else if n < 100 {
- let n = n as u8;
-
- let d10 = n / 10;
- let d1 = n % 10;
-
- bytes.put_u8(DIGITS_START + d10);
- bytes.put_u8(DIGITS_START + d1);
- } else if n < 1000 {
- let n = n as u16;
-
- let d100 = (n / 100) as u8;
- let d10 = ((n / 10) % 10) as u8;
- let d1 = (n % 10) as u8;
-
- bytes.put_u8(DIGITS_START + d100);
- bytes.put_u8(DIGITS_START + d10);
- bytes.put_u8(DIGITS_START + d1);
- } else if n < 10_000 {
- let n = n as u16;
-
- let d1000 = (n / 1000) as u8;
- let d100 = ((n / 100) % 10) as u8;
- let d10 = ((n / 10) % 10) as u8;
- let d1 = (n % 10) as u8;
-
- bytes.put_u8(DIGITS_START + d1000);
- bytes.put_u8(DIGITS_START + d100);
- bytes.put_u8(DIGITS_START + d10);
- bytes.put_u8(DIGITS_START + d1);
- } else if n < 100_000 {
- let n = n as u32;
-
- let d10000 = (n / 10000) as u8;
- let d1000 = ((n / 1000) % 10) as u8;
- let d100 = ((n / 100) % 10) as u8;
- let d10 = ((n / 10) % 10) as u8;
- let d1 = (n % 10) as u8;
-
- bytes.put_u8(DIGITS_START + d10000);
- bytes.put_u8(DIGITS_START + d1000);
- bytes.put_u8(DIGITS_START + d100);
- bytes.put_u8(DIGITS_START + d10);
- bytes.put_u8(DIGITS_START + d1);
- } else if n < 1_000_000 {
- let n = n as u32;
-
- let d100000 = (n / 100000) as u8;
- let d10000 = ((n / 10000) % 10) as u8;
- let d1000 = ((n / 1000) % 10) as u8;
- let d100 = ((n / 100) % 10) as u8;
- let d10 = ((n / 10) % 10) as u8;
- let d1 = (n % 10) as u8;
-
- bytes.put_u8(DIGITS_START + d100000);
- bytes.put_u8(DIGITS_START + d10000);
- bytes.put_u8(DIGITS_START + d1000);
- bytes.put_u8(DIGITS_START + d100);
- bytes.put_u8(DIGITS_START + d10);
- bytes.put_u8(DIGITS_START + d1);
- } else {
- write_usize(n, bytes);
- }
-
- bytes.put_slice(b"\r\n");
- }
-
- fn write_usize(n: usize, bytes: &mut BytesMut) {
- let mut n = n;
-
- // 20 chars is max length of a usize (2^64)
- // digits will be added to the buffer from lsd to msd
- let mut buf = BytesMut::with_capacity(20);
-
- while n > 9 {
- // "pop" the least-significant digit
- let lsd = (n % 10) as u8;
-
- // remove the lsd from n
- n = n / 10;
-
- buf.put_u8(DIGITS_START + lsd);
- }
-
- // put msd to result buffer
- bytes.put_u8(DIGITS_START + (n as u8));
-
- // put, in reverse (msd to lsd), remaining digits to buffer
- for i in (0..buf.len()).rev() {
- bytes.put_u8(buf[i]);
- }
- }
-}
-
-mod _original {
- use std::{mem, ptr, slice};
-
- use bytes::{BufMut, BytesMut};
-
- const DEC_DIGITS_LUT: &[u8] = b"0001020304050607080910111213141516171819\
- 2021222324252627282930313233343536373839\
- 4041424344454647484950515253545556575859\
- 6061626364656667686970717273747576777879\
- 8081828384858687888990919293949596979899";
-
- /// NOTE: bytes object has to contain enough space
- pub fn write_content_length(mut n: usize, bytes: &mut BytesMut) {
- if n < 10 {
- let mut buf: [u8; 21] = [
- b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l',
- b'e', b'n', b'g', b't', b'h', b':', b' ', b'0', b'\r', b'\n',
- ];
- buf[18] = (n as u8) + b'0';
- bytes.put_slice(&buf);
- } else if n < 100 {
- let mut buf: [u8; 22] = [
- b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l',
- b'e', b'n', b'g', b't', b'h', b':', b' ', b'0', b'0', b'\r', b'\n',
- ];
- let d1 = n << 1;
- unsafe {
- ptr::copy_nonoverlapping(
- DEC_DIGITS_LUT.as_ptr().add(d1),
- buf.as_mut_ptr().offset(18),
- 2,
- );
- }
- bytes.put_slice(&buf);
- } else if n < 1000 {
- let mut buf: [u8; 23] = [
- b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l',
- b'e', b'n', b'g', b't', b'h', b':', b' ', b'0', b'0', b'0', b'\r',
- b'\n',
- ];
- // decode 2 more chars, if > 2 chars
- let d1 = (n % 100) << 1;
- n /= 100;
- unsafe {
- ptr::copy_nonoverlapping(
- DEC_DIGITS_LUT.as_ptr().add(d1),
- buf.as_mut_ptr().offset(19),
- 2,
- )
- };
-
- // decode last 1
- buf[18] = (n as u8) + b'0';
-
- bytes.put_slice(&buf);
- } else {
- bytes.put_slice(b"\r\ncontent-length: ");
- convert_usize(n, bytes);
- }
- }
-
- pub(crate) fn convert_usize(mut n: usize, bytes: &mut BytesMut) {
- let mut curr: isize = 39;
- let mut buf: [u8; 41] = unsafe { mem::MaybeUninit::uninit().assume_init() };
- buf[39] = b'\r';
- buf[40] = b'\n';
- let buf_ptr = buf.as_mut_ptr();
- let lut_ptr = DEC_DIGITS_LUT.as_ptr();
-
- // eagerly decode 4 characters at a time
- while n >= 10_000 {
- let rem = (n % 10_000) as isize;
- n /= 10_000;
-
- let d1 = (rem / 100) << 1;
- let d2 = (rem % 100) << 1;
- curr -= 4;
- unsafe {
- ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
- ptr::copy_nonoverlapping(
- lut_ptr.offset(d2),
- buf_ptr.offset(curr + 2),
- 2,
- );
- }
- }
-
- // if we reach here numbers are <= 9999, so at most 4 chars long
- let mut n = n as isize; // possibly reduce 64bit math
-
- // decode 2 more chars, if > 2 chars
- if n >= 100 {
- let d1 = (n % 100) << 1;
- n /= 100;
- curr -= 2;
- unsafe {
- ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
- }
- }
-
- // decode last 1 or 2 chars
- if n < 10 {
- curr -= 1;
- unsafe {
- *buf_ptr.offset(curr) = (n as u8) + b'0';
- }
- } else {
- let d1 = n << 1;
- curr -= 2;
- unsafe {
- ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
- }
- }
-
- unsafe {
- bytes.extend_from_slice(slice::from_raw_parts(
- buf_ptr.offset(curr),
- 41 - curr as usize,
- ));
- }
- }
-}
diff --git a/actix-http/benches/status-line.rs b/actix-http/benches/status-line.rs
index 51f840f89..f62d18ed8 100644
--- a/actix-http/benches/status-line.rs
+++ b/actix-http/benches/status-line.rs
@@ -176,7 +176,7 @@ mod _original {
buf[5] = b'0';
buf[7] = b'9';
}
- _ => (),
+ _ => {}
}
let mut curr: isize = 12;
diff --git a/actix-http/benches/write-camel-case.rs b/actix-http/benches/write-camel-case.rs
new file mode 100644
index 000000000..fa4930eb9
--- /dev/null
+++ b/actix-http/benches/write-camel-case.rs
@@ -0,0 +1,89 @@
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+
+fn bench_write_camel_case(c: &mut Criterion) {
+ let mut group = c.benchmark_group("write_camel_case");
+
+ let names = ["connection", "Transfer-Encoding", "transfer-encoding"];
+
+ for &i in &names {
+ let bts = i.as_bytes();
+
+ group.bench_with_input(BenchmarkId::new("Original", i), bts, |b, bts| {
+ b.iter(|| {
+ let mut buf = black_box([0; 24]);
+ _original::write_camel_case(black_box(bts), &mut buf)
+ });
+ });
+
+ group.bench_with_input(BenchmarkId::new("New", i), bts, |b, bts| {
+ b.iter(|| {
+ let mut buf = black_box([0; 24]);
+ _new::write_camel_case(black_box(bts), &mut buf)
+ });
+ });
+ }
+
+ group.finish();
+}
+
+criterion_group!(benches, bench_write_camel_case);
+criterion_main!(benches);
+
+mod _new {
+ pub fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
+ // first copy entire (potentially wrong) slice to output
+ buffer[..value.len()].copy_from_slice(value);
+
+ let mut iter = value.iter();
+
+ // first character should be uppercase
+ if let Some(c @ b'a'..=b'z') = iter.next() {
+ buffer[0] = c & 0b1101_1111;
+ }
+
+ // track 1 ahead of the current position since that's the location being assigned to
+ let mut index = 2;
+
+ // remaining characters after hyphens should also be uppercase
+ while let Some(&c) = iter.next() {
+ if c == b'-' {
+ // advance iter by one and uppercase if needed
+ if let Some(c @ b'a'..=b'z') = iter.next() {
+ buffer[index] = c & 0b1101_1111;
+ }
+ }
+
+ index += 1;
+ }
+ }
+}
+
+mod _original {
+ pub fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
+ let mut index = 0;
+ let key = value;
+ let mut key_iter = key.iter();
+
+ if let Some(c) = key_iter.next() {
+ if *c >= b'a' && *c <= b'z' {
+ buffer[index] = *c ^ b' ';
+ index += 1;
+ }
+ } else {
+ return;
+ }
+
+ while let Some(c) = key_iter.next() {
+ buffer[index] = *c;
+ index += 1;
+ if *c == b'-' {
+ if let Some(c) = key_iter.next() {
+ if *c >= b'a' && *c <= b'z' {
+ buffer[index] = *c ^ b' ';
+ index += 1;
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/actix-http/examples/echo.rs b/actix-http/examples/echo.rs
index beb1cce2c..90d768cbe 100644
--- a/actix-http/examples/echo.rs
+++ b/actix-http/examples/echo.rs
@@ -26,7 +26,10 @@ async fn main() -> io::Result<()> {
info!("request body: {:?}", body);
Ok::<_, Error>(
Response::Ok()
- .header("x-head", HeaderValue::from_static("dummy value!"))
+ .insert_header((
+ "x-head",
+ HeaderValue::from_static("dummy value!"),
+ ))
.body(body),
)
})
diff --git a/actix-http/examples/echo2.rs b/actix-http/examples/echo2.rs
index 5b7e504d3..bc932ce8f 100644
--- a/actix-http/examples/echo2.rs
+++ b/actix-http/examples/echo2.rs
@@ -15,7 +15,7 @@ async fn handle_request(mut req: Request) -> Result {
info!("request body: {:?}", body);
Ok(Response::Ok()
- .header("x-head", HeaderValue::from_static("dummy value!"))
+ .insert_header(("x-head", HeaderValue::from_static("dummy value!")))
.body(body))
}
diff --git a/actix-http/examples/hello-world.rs b/actix-http/examples/hello-world.rs
index d6477b152..a84e9aac6 100644
--- a/actix-http/examples/hello-world.rs
+++ b/actix-http/examples/hello-world.rs
@@ -19,7 +19,10 @@ async fn main() -> io::Result<()> {
.finish(|_req| {
info!("{:?}", _req);
let mut res = Response::Ok();
- res.header("x-head", HeaderValue::from_static("dummy value!"));
+ res.insert_header((
+ "x-head",
+ HeaderValue::from_static("dummy value!"),
+ ));
future::ok::<_, ()>(res.body("Hello world!"))
})
.tcp()
diff --git a/actix-http/src/body.rs b/actix-http/src/body.rs
deleted file mode 100644
index c5d831c45..000000000
--- a/actix-http/src/body.rs
+++ /dev/null
@@ -1,723 +0,0 @@
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{fmt, mem};
-
-use bytes::{Bytes, BytesMut};
-use futures_core::Stream;
-use futures_util::ready;
-use pin_project::pin_project;
-
-use crate::error::Error;
-
-#[derive(Debug, PartialEq, Copy, Clone)]
-/// Body size hint
-pub enum BodySize {
- None,
- Empty,
- Sized(u64),
- Stream,
-}
-
-impl BodySize {
- pub fn is_eof(&self) -> bool {
- matches!(self, BodySize::None | BodySize::Empty | BodySize::Sized(0))
- }
-}
-
-/// Type that provides this trait can be streamed to a peer.
-pub trait MessageBody {
- fn size(&self) -> BodySize;
-
- fn poll_next(
- self: Pin<&mut Self>,
- cx: &mut Context<'_>,
- ) -> Poll>>;
-
- downcast_get_type_id!();
-}
-
-downcast!(MessageBody);
-
-impl MessageBody for () {
- fn size(&self) -> BodySize {
- BodySize::Empty
- }
-
- fn poll_next(
- self: Pin<&mut Self>,
- _: &mut Context<'_>,
- ) -> Poll>> {
- Poll::Ready(None)
- }
-}
-
-impl MessageBody for Box {
- fn size(&self) -> BodySize {
- self.as_ref().size()
- }
-
- fn poll_next(
- self: Pin<&mut Self>,
- cx: &mut Context<'_>,
- ) -> Poll>> {
- Pin::new(self.get_mut().as_mut()).poll_next(cx)
- }
-}
-
-#[pin_project(project = ResponseBodyProj)]
-pub enum ResponseBody {
- Body(#[pin] B),
- Other(#[pin] Body),
-}
-
-impl ResponseBody {
- pub fn into_body(self) -> ResponseBody {
- match self {
- ResponseBody::Body(b) => ResponseBody::Other(b),
- ResponseBody::Other(b) => ResponseBody::Other(b),
- }
- }
-}
-
-impl ResponseBody {
- pub fn take_body(&mut self) -> ResponseBody {
- std::mem::replace(self, ResponseBody::Other(Body::None))
- }
-}
-
-impl ResponseBody {
- pub fn as_ref(&self) -> Option<&B> {
- if let ResponseBody::Body(ref b) = self {
- Some(b)
- } else {
- None
- }
- }
-}
-
-impl MessageBody for ResponseBody {
- fn size(&self) -> BodySize {
- match self {
- ResponseBody::Body(ref body) => body.size(),
- ResponseBody::Other(ref body) => body.size(),
- }
- }
-
- fn poll_next(
- self: Pin<&mut Self>,
- cx: &mut Context<'_>,
- ) -> Poll>> {
- match self.project() {
- ResponseBodyProj::Body(body) => body.poll_next(cx),
- ResponseBodyProj::Other(body) => body.poll_next(cx),
- }
- }
-}
-
-impl Stream for ResponseBody {
- type Item = Result;
-
- fn poll_next(
- self: Pin<&mut Self>,
- cx: &mut Context<'_>,
- ) -> Poll> {
- match self.project() {
- ResponseBodyProj::Body(body) => body.poll_next(cx),
- ResponseBodyProj::Other(body) => body.poll_next(cx),
- }
- }
-}
-
-#[pin_project(project = BodyProj)]
-/// Represents various types of http message body.
-pub enum Body {
- /// Empty response. `Content-Length` header is not set.
- None,
- /// Zero sized response body. `Content-Length` header is set to `0`.
- Empty,
- /// Specific response body.
- Bytes(Bytes),
- /// Generic message body.
- Message(Box),
-}
-
-impl Body {
- /// Create body from slice (copy)
- pub fn from_slice(s: &[u8]) -> Body {
- Body::Bytes(Bytes::copy_from_slice(s))
- }
-
- /// Create body from generic message body.
- pub fn from_message(body: B) -> Body {
- Body::Message(Box::new(body))
- }
-}
-
-impl MessageBody for Body {
- fn size(&self) -> BodySize {
- match self {
- Body::None => BodySize::None,
- Body::Empty => BodySize::Empty,
- Body::Bytes(ref bin) => BodySize::Sized(bin.len() as u64),
- Body::Message(ref body) => body.size(),
- }
- }
-
- fn poll_next(
- self: Pin<&mut Self>,
- cx: &mut Context<'_>,
- ) -> Poll>> {
- match self.project() {
- BodyProj::None => Poll::Ready(None),
- BodyProj::Empty => Poll::Ready(None),
- BodyProj::Bytes(ref mut bin) => {
- let len = bin.len();
- if len == 0 {
- Poll::Ready(None)
- } else {
- Poll::Ready(Some(Ok(mem::take(bin))))
- }
- }
- BodyProj::Message(ref mut body) => Pin::new(body.as_mut()).poll_next(cx),
- }
- }
-}
-
-impl PartialEq for Body {
- fn eq(&self, other: &Body) -> bool {
- match *self {
- Body::None => matches!(*other, Body::None),
- Body::Empty => matches!(*other, Body::Empty),
- Body::Bytes(ref b) => match *other {
- Body::Bytes(ref b2) => b == b2,
- _ => false,
- },
- Body::Message(_) => false,
- }
- }
-}
-
-impl fmt::Debug for Body {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- match *self {
- Body::None => write!(f, "Body::None"),
- Body::Empty => write!(f, "Body::Empty"),
- Body::Bytes(ref b) => write!(f, "Body::Bytes({:?})", b),
- Body::Message(_) => write!(f, "Body::Message(_)"),
- }
- }
-}
-
-impl From<&'static str> for Body {
- fn from(s: &'static str) -> Body {
- Body::Bytes(Bytes::from_static(s.as_ref()))
- }
-}
-
-impl From<&'static [u8]> for Body {
- fn from(s: &'static [u8]) -> Body {
- Body::Bytes(Bytes::from_static(s))
- }
-}
-
-impl From> for Body {
- fn from(vec: Vec) -> Body {
- Body::Bytes(Bytes::from(vec))
- }
-}
-
-impl From for Body {
- fn from(s: String) -> Body {
- s.into_bytes().into()
- }
-}
-
-impl<'a> From<&'a String> for Body {
- fn from(s: &'a String) -> Body {
- Body::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(&s)))
- }
-}
-
-impl From for Body {
- fn from(s: Bytes) -> Body {
- Body::Bytes(s)
- }
-}
-
-impl From for Body {
- fn from(s: BytesMut) -> Body {
- Body::Bytes(s.freeze())
- }
-}
-
-impl From for Body {
- fn from(v: serde_json::Value) -> Body {
- Body::Bytes(v.to_string().into())
- }
-}
-
-impl From> for Body
-where
- S: Stream- > + Unpin + 'static,
-{
- fn from(s: SizedStream
) -> Body {
- Body::from_message(s)
- }
-}
-
-impl From> for Body
-where
- S: Stream- > + Unpin + 'static,
- E: Into + 'static,
-{
- fn from(s: BodyStream) -> Body {
- Body::from_message(s)
- }
-}
-
-impl MessageBody for Bytes {
- fn size(&self) -> BodySize {
- BodySize::Sized(self.len() as u64)
- }
-
- fn poll_next(
- self: Pin<&mut Self>,
- _: &mut Context<'_>,
- ) -> Poll>> {
- if self.is_empty() {
- Poll::Ready(None)
- } else {
- Poll::Ready(Some(Ok(mem::take(self.get_mut()))))
- }
- }
-}
-
-impl MessageBody for BytesMut {
- fn size(&self) -> BodySize {
- BodySize::Sized(self.len() as u64)
- }
-
- fn poll_next(
- self: Pin<&mut Self>,
- _: &mut Context<'_>,
- ) -> Poll>> {
- if self.is_empty() {
- Poll::Ready(None)
- } else {
- Poll::Ready(Some(Ok(mem::take(self.get_mut()).freeze())))
- }
- }
-}
-
-impl MessageBody for &'static str {
- fn size(&self) -> BodySize {
- BodySize::Sized(self.len() as u64)
- }
-
- fn poll_next(
- self: Pin<&mut Self>,
- _: &mut Context<'_>,
- ) -> Poll>> {
- if self.is_empty() {
- Poll::Ready(None)
- } else {
- Poll::Ready(Some(Ok(Bytes::from_static(
- mem::take(self.get_mut()).as_ref(),
- ))))
- }
- }
-}
-
-impl MessageBody for Vec {
- fn size(&self) -> BodySize {
- BodySize::Sized(self.len() as u64)
- }
-
- fn poll_next(
- self: Pin<&mut Self>,
- _: &mut Context<'_>,
- ) -> Poll>> {
- if self.is_empty() {
- Poll::Ready(None)
- } else {
- Poll::Ready(Some(Ok(Bytes::from(mem::take(self.get_mut())))))
- }
- }
-}
-
-impl MessageBody for String {
- fn size(&self) -> BodySize {
- BodySize::Sized(self.len() as u64)
- }
-
- fn poll_next(
- self: Pin<&mut Self>,
- _: &mut Context<'_>,
- ) -> Poll>> {
- if self.is_empty() {
- Poll::Ready(None)
- } else {
- Poll::Ready(Some(Ok(Bytes::from(
- mem::take(self.get_mut()).into_bytes(),
- ))))
- }
- }
-}
-
-/// Type represent streaming body.
-/// Response does not contain `content-length` header and appropriate transfer encoding is used.
-#[pin_project]
-pub struct BodyStream {
- #[pin]
- stream: S,
- _t: PhantomData,
-}
-
-impl BodyStream
-where
- S: Stream
- > + Unpin,
- E: Into,
-{
- pub fn new(stream: S) -> Self {
- BodyStream {
- stream,
- _t: PhantomData,
- }
- }
-}
-
-impl MessageBody for BodyStream
-where
- S: Stream
- > + Unpin,
- E: Into,
-{
- fn size(&self) -> BodySize {
- BodySize::Stream
- }
-
- /// Attempts to pull out the next value of the underlying [`Stream`].
- ///
- /// Empty values are skipped to prevent [`BodyStream`]'s transmission being
- /// ended on a zero-length chunk, but rather proceed until the underlying
- /// [`Stream`] ends.
- fn poll_next(
- self: Pin<&mut Self>,
- cx: &mut Context<'_>,
- ) -> Poll>> {
- let mut stream = self.project().stream;
- loop {
- let stream = stream.as_mut();
- return Poll::Ready(match ready!(stream.poll_next(cx)) {
- Some(Ok(ref bytes)) if bytes.is_empty() => continue,
- opt => opt.map(|res| res.map_err(Into::into)),
- });
- }
- }
-}
-
-/// Type represent streaming body. This body implementation should be used
-/// if total size of stream is known. Data get sent as is without using transfer encoding.
-#[pin_project]
-pub struct SizedStream {
- size: u64,
- #[pin]
- stream: S,
-}
-
-impl
SizedStream
-where
- S: Stream- > + Unpin,
-{
- pub fn new(size: u64, stream: S) -> Self {
- SizedStream { size, stream }
- }
-}
-
-impl
MessageBody for SizedStream
-where
- S: Stream- > + Unpin,
-{
- fn size(&self) -> BodySize {
- BodySize::Sized(self.size as u64)
- }
-
- /// Attempts to pull out the next value of the underlying [`Stream`].
- ///
- /// Empty values are skipped to prevent [`SizedStream`]'s transmission being
- /// ended on a zero-length chunk, but rather proceed until the underlying
- /// [`Stream`] ends.
- fn poll_next(
- self: Pin<&mut Self>,
- cx: &mut Context<'_>,
- ) -> Poll>> {
- let mut stream: Pin<&mut S> = self.project().stream;
- loop {
- let stream = stream.as_mut();
- return Poll::Ready(match ready!(stream.poll_next(cx)) {
- Some(Ok(ref bytes)) if bytes.is_empty() => continue,
- val => val,
- });
- }
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use futures_util::future::poll_fn;
- use futures_util::pin_mut;
- use futures_util::stream;
-
- impl Body {
- pub(crate) fn get_ref(&self) -> &[u8] {
- match *self {
- Body::Bytes(ref bin) => &bin,
- _ => panic!(),
- }
- }
- }
-
- impl ResponseBody {
- pub(crate) fn get_ref(&self) -> &[u8] {
- match *self {
- ResponseBody::Body(ref b) => b.get_ref(),
- ResponseBody::Other(ref b) => b.get_ref(),
- }
- }
- }
-
- #[actix_rt::test]
- async fn test_static_str() {
- assert_eq!(Body::from("").size(), BodySize::Sized(0));
- assert_eq!(Body::from("test").size(), BodySize::Sized(4));
- assert_eq!(Body::from("test").get_ref(), b"test");
-
- assert_eq!("test".size(), BodySize::Sized(4));
- assert_eq!(
- poll_fn(|cx| Pin::new(&mut "test").poll_next(cx))
- .await
- .unwrap()
- .ok(),
- Some(Bytes::from("test"))
- );
- }
-
- #[actix_rt::test]
- async fn test_static_bytes() {
- assert_eq!(Body::from(b"test".as_ref()).size(), BodySize::Sized(4));
- assert_eq!(Body::from(b"test".as_ref()).get_ref(), b"test");
- assert_eq!(
- Body::from_slice(b"test".as_ref()).size(),
- BodySize::Sized(4)
- );
- assert_eq!(Body::from_slice(b"test".as_ref()).get_ref(), b"test");
- let sb = Bytes::from(&b"test"[..]);
- pin_mut!(sb);
-
- assert_eq!(sb.size(), BodySize::Sized(4));
- assert_eq!(
- poll_fn(|cx| sb.as_mut().poll_next(cx)).await.unwrap().ok(),
- Some(Bytes::from("test"))
- );
- }
-
- #[actix_rt::test]
- async fn test_vec() {
- assert_eq!(Body::from(Vec::from("test")).size(), BodySize::Sized(4));
- assert_eq!(Body::from(Vec::from("test")).get_ref(), b"test");
- let test_vec = Vec::from("test");
- pin_mut!(test_vec);
-
- assert_eq!(test_vec.size(), BodySize::Sized(4));
- assert_eq!(
- poll_fn(|cx| test_vec.as_mut().poll_next(cx))
- .await
- .unwrap()
- .ok(),
- Some(Bytes::from("test"))
- );
- }
-
- #[actix_rt::test]
- async fn test_bytes() {
- let b = Bytes::from("test");
- assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
- assert_eq!(Body::from(b.clone()).get_ref(), b"test");
- pin_mut!(b);
-
- assert_eq!(b.size(), BodySize::Sized(4));
- assert_eq!(
- poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
- Some(Bytes::from("test"))
- );
- }
-
- #[actix_rt::test]
- async fn test_bytes_mut() {
- let b = BytesMut::from("test");
- assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
- assert_eq!(Body::from(b.clone()).get_ref(), b"test");
- pin_mut!(b);
-
- assert_eq!(b.size(), BodySize::Sized(4));
- assert_eq!(
- poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
- Some(Bytes::from("test"))
- );
- }
-
- #[actix_rt::test]
- async fn test_string() {
- let b = "test".to_owned();
- assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
- assert_eq!(Body::from(b.clone()).get_ref(), b"test");
- assert_eq!(Body::from(&b).size(), BodySize::Sized(4));
- assert_eq!(Body::from(&b).get_ref(), b"test");
- pin_mut!(b);
-
- assert_eq!(b.size(), BodySize::Sized(4));
- assert_eq!(
- poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
- Some(Bytes::from("test"))
- );
- }
-
- #[actix_rt::test]
- async fn test_unit() {
- assert_eq!(().size(), BodySize::Empty);
- assert!(poll_fn(|cx| Pin::new(&mut ()).poll_next(cx))
- .await
- .is_none());
- }
-
- #[actix_rt::test]
- async fn test_box() {
- let val = Box::new(());
- pin_mut!(val);
- assert_eq!(val.size(), BodySize::Empty);
- assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
- }
-
- #[actix_rt::test]
- async fn test_body_eq() {
- assert!(
- Body::Bytes(Bytes::from_static(b"1"))
- == Body::Bytes(Bytes::from_static(b"1"))
- );
- assert!(Body::Bytes(Bytes::from_static(b"1")) != Body::None);
- }
-
- #[actix_rt::test]
- async fn test_body_debug() {
- assert!(format!("{:?}", Body::None).contains("Body::None"));
- assert!(format!("{:?}", Body::Empty).contains("Body::Empty"));
- assert!(format!("{:?}", Body::Bytes(Bytes::from_static(b"1"))).contains('1'));
- }
-
- #[actix_rt::test]
- async fn test_serde_json() {
- use serde_json::json;
- assert_eq!(
- Body::from(serde_json::Value::String("test".into())).size(),
- BodySize::Sized(6)
- );
- assert_eq!(
- Body::from(json!({"test-key":"test-value"})).size(),
- BodySize::Sized(25)
- );
- }
-
- mod body_stream {
- use super::*;
- //use futures::task::noop_waker;
- //use futures::stream::once;
-
- #[actix_rt::test]
- async fn skips_empty_chunks() {
- let body = BodyStream::new(stream::iter(
- ["1", "", "2"]
- .iter()
- .map(|&v| Ok(Bytes::from(v)) as Result),
- ));
- pin_mut!(body);
-
- assert_eq!(
- poll_fn(|cx| body.as_mut().poll_next(cx))
- .await
- .unwrap()
- .ok(),
- Some(Bytes::from("1")),
- );
- assert_eq!(
- poll_fn(|cx| body.as_mut().poll_next(cx))
- .await
- .unwrap()
- .ok(),
- Some(Bytes::from("2")),
- );
- }
-
- /* Now it does not compile as it should
- #[actix_rt::test]
- async fn move_pinned_pointer() {
- let (sender, receiver) = futures::channel::oneshot::channel();
- let mut body_stream = Ok(BodyStream::new(once(async {
- let x = Box::new(0i32);
- let y = &x;
- receiver.await.unwrap();
- let _z = **y;
- Ok::<_, ()>(Bytes::new())
- })));
-
- let waker = noop_waker();
- let mut context = Context::from_waker(&waker);
- pin_mut!(body_stream);
-
- let _ = body_stream.as_mut().unwrap().poll_next(&mut context);
- sender.send(()).unwrap();
- let _ = std::mem::replace(&mut body_stream, Err([0; 32])).unwrap().poll_next(&mut context);
- }*/
- }
-
- mod sized_stream {
- use super::*;
-
- #[actix_rt::test]
- async fn skips_empty_chunks() {
- let body = SizedStream::new(
- 2,
- stream::iter(["1", "", "2"].iter().map(|&v| Ok(Bytes::from(v)))),
- );
- pin_mut!(body);
- assert_eq!(
- poll_fn(|cx| body.as_mut().poll_next(cx))
- .await
- .unwrap()
- .ok(),
- Some(Bytes::from("1")),
- );
- assert_eq!(
- poll_fn(|cx| body.as_mut().poll_next(cx))
- .await
- .unwrap()
- .ok(),
- Some(Bytes::from("2")),
- );
- }
- }
-
- #[actix_rt::test]
- async fn test_body_casting() {
- let mut body = String::from("hello cast");
- let resp_body: &mut dyn MessageBody = &mut body;
- let body = resp_body.downcast_ref::().unwrap();
- assert_eq!(body, "hello cast");
- let body = &mut resp_body.downcast_mut::().unwrap();
- body.push('!');
- let body = resp_body.downcast_ref::().unwrap();
- assert_eq!(body, "hello cast!");
- let not_body = resp_body.downcast_ref::<()>();
- assert!(not_body.is_none());
- }
-}
diff --git a/actix-http/src/body/body.rs b/actix-http/src/body/body.rs
new file mode 100644
index 000000000..a3fd7d41c
--- /dev/null
+++ b/actix-http/src/body/body.rs
@@ -0,0 +1,158 @@
+use std::{
+ fmt, mem,
+ pin::Pin,
+ task::{Context, Poll},
+};
+
+use bytes::{Bytes, BytesMut};
+use futures_core::Stream;
+
+use crate::error::Error;
+
+use super::{BodySize, BodyStream, MessageBody, SizedStream};
+
+/// Represents various types of HTTP message body.
+pub enum Body {
+ /// Empty response. `Content-Length` header is not set.
+ None,
+ /// Zero sized response body. `Content-Length` header is set to `0`.
+ Empty,
+ /// Specific response body.
+ Bytes(Bytes),
+ /// Generic message body.
+ Message(Box),
+}
+
+impl Body {
+ /// Create body from slice (copy)
+ pub fn from_slice(s: &[u8]) -> Body {
+ Body::Bytes(Bytes::copy_from_slice(s))
+ }
+
+ /// Create body from generic message body.
+ pub fn from_message(body: B) -> Body {
+ Body::Message(Box::new(body))
+ }
+}
+
+impl MessageBody for Body {
+ fn size(&self) -> BodySize {
+ match self {
+ Body::None => BodySize::None,
+ Body::Empty => BodySize::Empty,
+ Body::Bytes(ref bin) => BodySize::Sized(bin.len() as u64),
+ Body::Message(ref body) => body.size(),
+ }
+ }
+
+ fn poll_next(
+ self: Pin<&mut Self>,
+ cx: &mut Context<'_>,
+ ) -> Poll>> {
+ match self.get_mut() {
+ Body::None => Poll::Ready(None),
+ Body::Empty => Poll::Ready(None),
+ Body::Bytes(ref mut bin) => {
+ let len = bin.len();
+ if len == 0 {
+ Poll::Ready(None)
+ } else {
+ Poll::Ready(Some(Ok(mem::take(bin))))
+ }
+ }
+ Body::Message(body) => Pin::new(&mut **body).poll_next(cx),
+ }
+ }
+}
+
+impl PartialEq for Body {
+ fn eq(&self, other: &Body) -> bool {
+ match *self {
+ Body::None => matches!(*other, Body::None),
+ Body::Empty => matches!(*other, Body::Empty),
+ Body::Bytes(ref b) => match *other {
+ Body::Bytes(ref b2) => b == b2,
+ _ => false,
+ },
+ Body::Message(_) => false,
+ }
+ }
+}
+
+impl fmt::Debug for Body {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match *self {
+ Body::None => write!(f, "Body::None"),
+ Body::Empty => write!(f, "Body::Empty"),
+ Body::Bytes(ref b) => write!(f, "Body::Bytes({:?})", b),
+ Body::Message(_) => write!(f, "Body::Message(_)"),
+ }
+ }
+}
+
+impl From<&'static str> for Body {
+ fn from(s: &'static str) -> Body {
+ Body::Bytes(Bytes::from_static(s.as_ref()))
+ }
+}
+
+impl From<&'static [u8]> for Body {
+ fn from(s: &'static [u8]) -> Body {
+ Body::Bytes(Bytes::from_static(s))
+ }
+}
+
+impl From> for Body {
+ fn from(vec: Vec) -> Body {
+ Body::Bytes(Bytes::from(vec))
+ }
+}
+
+impl From for Body {
+ fn from(s: String) -> Body {
+ s.into_bytes().into()
+ }
+}
+
+impl<'a> From<&'a String> for Body {
+ fn from(s: &'a String) -> Body {
+ Body::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(&s)))
+ }
+}
+
+impl From for Body {
+ fn from(s: Bytes) -> Body {
+ Body::Bytes(s)
+ }
+}
+
+impl From for Body {
+ fn from(s: BytesMut) -> Body {
+ Body::Bytes(s.freeze())
+ }
+}
+
+impl From for Body {
+ fn from(v: serde_json::Value) -> Body {
+ Body::Bytes(v.to_string().into())
+ }
+}
+
+impl
From> for Body
+where
+ S: Stream- > + Unpin + 'static,
+{
+ fn from(s: SizedStream
) -> Body {
+ Body::from_message(s)
+ }
+}
+
+impl From> for Body
+where
+ S: Stream- > + Unpin + 'static,
+ E: Into + 'static,
+{
+ fn from(s: BodyStream
) -> Body {
+ Body::from_message(s)
+ }
+}
diff --git a/actix-http/src/body/body_stream.rs b/actix-http/src/body/body_stream.rs
new file mode 100644
index 000000000..60e33b161
--- /dev/null
+++ b/actix-http/src/body/body_stream.rs
@@ -0,0 +1,59 @@
+use std::{
+ pin::Pin,
+ task::{Context, Poll},
+};
+
+use bytes::Bytes;
+use futures_core::{ready, Stream};
+
+use crate::error::Error;
+
+use super::{BodySize, MessageBody};
+
+/// Streaming response wrapper.
+///
+/// Response does not contain `Content-Length` header and appropriate transfer encoding is used.
+pub struct BodyStream {
+ stream: S,
+}
+
+impl BodyStream
+where
+ S: Stream- > + Unpin,
+ E: Into,
+{
+ pub fn new(stream: S) -> Self {
+ BodyStream { stream }
+ }
+}
+
+impl MessageBody for BodyStream
+where
+ S: Stream- > + Unpin,
+ E: Into,
+{
+ fn size(&self) -> BodySize {
+ BodySize::Stream
+ }
+
+ /// Attempts to pull out the next value of the underlying [`Stream`].
+ ///
+ /// Empty values are skipped to prevent [`BodyStream`]'s transmission being
+ /// ended on a zero-length chunk, but rather proceed until the underlying
+ /// [`Stream`] ends.
+ fn poll_next(
+ mut self: Pin<&mut Self>,
+ cx: &mut Context<'_>,
+ ) -> Poll>> {
+ loop {
+ let stream = &mut self.as_mut().stream;
+
+ let chunk = match ready!(Pin::new(stream).poll_next(cx)) {
+ Some(Ok(ref bytes)) if bytes.is_empty() => continue,
+ opt => opt.map(|res| res.map_err(Into::into)),
+ };
+
+ return Poll::Ready(chunk);
+ }
+ }
+}
diff --git a/actix-http/src/body/message_body.rs b/actix-http/src/body/message_body.rs
new file mode 100644
index 000000000..012329146
--- /dev/null
+++ b/actix-http/src/body/message_body.rs
@@ -0,0 +1,142 @@
+//! [`MessageBody`] trait and foreign implementations.
+
+use std::{
+ mem,
+ pin::Pin,
+ task::{Context, Poll},
+};
+
+use bytes::{Bytes, BytesMut};
+
+use crate::error::Error;
+
+use super::BodySize;
+
+/// Type that implement this trait can be streamed to a peer.
+pub trait MessageBody {
+ fn size(&self) -> BodySize;
+
+ fn poll_next(
+ self: Pin<&mut Self>,
+ cx: &mut Context<'_>,
+ ) -> Poll>>;
+
+ downcast_get_type_id!();
+}
+
+downcast!(MessageBody);
+
+impl MessageBody for () {
+ fn size(&self) -> BodySize {
+ BodySize::Empty
+ }
+
+ fn poll_next(
+ self: Pin<&mut Self>,
+ _: &mut Context<'_>,
+ ) -> Poll>> {
+ Poll::Ready(None)
+ }
+}
+
+impl MessageBody for Box {
+ fn size(&self) -> BodySize {
+ self.as_ref().size()
+ }
+
+ fn poll_next(
+ self: Pin<&mut Self>,
+ cx: &mut Context<'_>,
+ ) -> Poll>> {
+ Pin::new(self.get_mut().as_mut()).poll_next(cx)
+ }
+}
+
+impl MessageBody for Bytes {
+ fn size(&self) -> BodySize {
+ BodySize::Sized(self.len() as u64)
+ }
+
+ fn poll_next(
+ self: Pin<&mut Self>,
+ _: &mut Context<'_>,
+ ) -> Poll>> {
+ if self.is_empty() {
+ Poll::Ready(None)
+ } else {
+ Poll::Ready(Some(Ok(mem::take(self.get_mut()))))
+ }
+ }
+}
+
+impl MessageBody for BytesMut {
+ fn size(&self) -> BodySize {
+ BodySize::Sized(self.len() as u64)
+ }
+
+ fn poll_next(
+ self: Pin<&mut Self>,
+ _: &mut Context<'_>,
+ ) -> Poll>> {
+ if self.is_empty() {
+ Poll::Ready(None)
+ } else {
+ Poll::Ready(Some(Ok(mem::take(self.get_mut()).freeze())))
+ }
+ }
+}
+
+impl MessageBody for &'static str {
+ fn size(&self) -> BodySize {
+ BodySize::Sized(self.len() as u64)
+ }
+
+ fn poll_next(
+ self: Pin<&mut Self>,
+ _: &mut Context<'_>,
+ ) -> Poll>> {
+ if self.is_empty() {
+ Poll::Ready(None)
+ } else {
+ Poll::Ready(Some(Ok(Bytes::from_static(
+ mem::take(self.get_mut()).as_ref(),
+ ))))
+ }
+ }
+}
+
+impl MessageBody for Vec {
+ fn size(&self) -> BodySize {
+ BodySize::Sized(self.len() as u64)
+ }
+
+ fn poll_next(
+ self: Pin<&mut Self>,
+ _: &mut Context<'_>,
+ ) -> Poll>> {
+ if self.is_empty() {
+ Poll::Ready(None)
+ } else {
+ Poll::Ready(Some(Ok(Bytes::from(mem::take(self.get_mut())))))
+ }
+ }
+}
+
+impl MessageBody for String {
+ fn size(&self) -> BodySize {
+ BodySize::Sized(self.len() as u64)
+ }
+
+ fn poll_next(
+ self: Pin<&mut Self>,
+ _: &mut Context<'_>,
+ ) -> Poll>> {
+ if self.is_empty() {
+ Poll::Ready(None)
+ } else {
+ Poll::Ready(Some(Ok(Bytes::from(
+ mem::take(self.get_mut()).into_bytes(),
+ ))))
+ }
+ }
+}
diff --git a/actix-http/src/body/mod.rs b/actix-http/src/body/mod.rs
new file mode 100644
index 000000000..a4d6ba2b6
--- /dev/null
+++ b/actix-http/src/body/mod.rs
@@ -0,0 +1,252 @@
+//! Traits and structures to aid consuming and writing HTTP payloads.
+
+#[allow(clippy::module_inception)]
+mod body;
+mod body_stream;
+mod message_body;
+mod response_body;
+mod size;
+mod sized_stream;
+
+pub use self::body::Body;
+pub use self::body_stream::BodyStream;
+pub use self::message_body::MessageBody;
+pub use self::response_body::ResponseBody;
+pub use self::size::BodySize;
+pub use self::sized_stream::SizedStream;
+
+#[cfg(test)]
+mod tests {
+ use std::pin::Pin;
+
+ use actix_rt::pin;
+ use bytes::{Bytes, BytesMut};
+ use futures_util::{future::poll_fn, stream};
+
+ use super::*;
+
+ impl Body {
+ pub(crate) fn get_ref(&self) -> &[u8] {
+ match *self {
+ Body::Bytes(ref bin) => &bin,
+ _ => panic!(),
+ }
+ }
+ }
+
+ impl ResponseBody {
+ pub(crate) fn get_ref(&self) -> &[u8] {
+ match *self {
+ ResponseBody::Body(ref b) => b.get_ref(),
+ ResponseBody::Other(ref b) => b.get_ref(),
+ }
+ }
+ }
+
+ #[actix_rt::test]
+ async fn test_static_str() {
+ assert_eq!(Body::from("").size(), BodySize::Sized(0));
+ assert_eq!(Body::from("test").size(), BodySize::Sized(4));
+ assert_eq!(Body::from("test").get_ref(), b"test");
+
+ assert_eq!("test".size(), BodySize::Sized(4));
+ assert_eq!(
+ poll_fn(|cx| Pin::new(&mut "test").poll_next(cx))
+ .await
+ .unwrap()
+ .ok(),
+ Some(Bytes::from("test"))
+ );
+ }
+
+ #[actix_rt::test]
+ async fn test_static_bytes() {
+ assert_eq!(Body::from(b"test".as_ref()).size(), BodySize::Sized(4));
+ assert_eq!(Body::from(b"test".as_ref()).get_ref(), b"test");
+ assert_eq!(
+ Body::from_slice(b"test".as_ref()).size(),
+ BodySize::Sized(4)
+ );
+ assert_eq!(Body::from_slice(b"test".as_ref()).get_ref(), b"test");
+ let sb = Bytes::from(&b"test"[..]);
+ pin!(sb);
+
+ assert_eq!(sb.size(), BodySize::Sized(4));
+ assert_eq!(
+ poll_fn(|cx| sb.as_mut().poll_next(cx)).await.unwrap().ok(),
+ Some(Bytes::from("test"))
+ );
+ }
+
+ #[actix_rt::test]
+ async fn test_vec() {
+ assert_eq!(Body::from(Vec::from("test")).size(), BodySize::Sized(4));
+ assert_eq!(Body::from(Vec::from("test")).get_ref(), b"test");
+ let test_vec = Vec::from("test");
+ pin!(test_vec);
+
+ assert_eq!(test_vec.size(), BodySize::Sized(4));
+ assert_eq!(
+ poll_fn(|cx| test_vec.as_mut().poll_next(cx))
+ .await
+ .unwrap()
+ .ok(),
+ Some(Bytes::from("test"))
+ );
+ }
+
+ #[actix_rt::test]
+ async fn test_bytes() {
+ let b = Bytes::from("test");
+ assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
+ assert_eq!(Body::from(b.clone()).get_ref(), b"test");
+ pin!(b);
+
+ assert_eq!(b.size(), BodySize::Sized(4));
+ assert_eq!(
+ poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
+ Some(Bytes::from("test"))
+ );
+ }
+
+ #[actix_rt::test]
+ async fn test_bytes_mut() {
+ let b = BytesMut::from("test");
+ assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
+ assert_eq!(Body::from(b.clone()).get_ref(), b"test");
+ pin!(b);
+
+ assert_eq!(b.size(), BodySize::Sized(4));
+ assert_eq!(
+ poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
+ Some(Bytes::from("test"))
+ );
+ }
+
+ #[actix_rt::test]
+ async fn test_string() {
+ let b = "test".to_owned();
+ assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
+ assert_eq!(Body::from(b.clone()).get_ref(), b"test");
+ assert_eq!(Body::from(&b).size(), BodySize::Sized(4));
+ assert_eq!(Body::from(&b).get_ref(), b"test");
+ pin!(b);
+
+ assert_eq!(b.size(), BodySize::Sized(4));
+ assert_eq!(
+ poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
+ Some(Bytes::from("test"))
+ );
+ }
+
+ #[actix_rt::test]
+ async fn test_unit() {
+ assert_eq!(().size(), BodySize::Empty);
+ assert!(poll_fn(|cx| Pin::new(&mut ()).poll_next(cx))
+ .await
+ .is_none());
+ }
+
+ #[actix_rt::test]
+ async fn test_box() {
+ let val = Box::new(());
+ pin!(val);
+ assert_eq!(val.size(), BodySize::Empty);
+ assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
+ }
+
+ #[actix_rt::test]
+ async fn test_body_eq() {
+ assert!(
+ Body::Bytes(Bytes::from_static(b"1"))
+ == Body::Bytes(Bytes::from_static(b"1"))
+ );
+ assert!(Body::Bytes(Bytes::from_static(b"1")) != Body::None);
+ }
+
+ #[actix_rt::test]
+ async fn test_body_debug() {
+ assert!(format!("{:?}", Body::None).contains("Body::None"));
+ assert!(format!("{:?}", Body::Empty).contains("Body::Empty"));
+ assert!(format!("{:?}", Body::Bytes(Bytes::from_static(b"1"))).contains('1'));
+ }
+
+ #[actix_rt::test]
+ async fn test_serde_json() {
+ use serde_json::json;
+ assert_eq!(
+ Body::from(serde_json::Value::String("test".into())).size(),
+ BodySize::Sized(6)
+ );
+ assert_eq!(
+ Body::from(json!({"test-key":"test-value"})).size(),
+ BodySize::Sized(25)
+ );
+ }
+
+ #[actix_rt::test]
+ async fn body_stream_skips_empty_chunks() {
+ let body = BodyStream::new(stream::iter(
+ ["1", "", "2"]
+ .iter()
+ .map(|&v| Ok(Bytes::from(v)) as Result),
+ ));
+ pin!(body);
+
+ assert_eq!(
+ poll_fn(|cx| body.as_mut().poll_next(cx))
+ .await
+ .unwrap()
+ .ok(),
+ Some(Bytes::from("1")),
+ );
+ assert_eq!(
+ poll_fn(|cx| body.as_mut().poll_next(cx))
+ .await
+ .unwrap()
+ .ok(),
+ Some(Bytes::from("2")),
+ );
+ }
+
+ mod sized_stream {
+ use super::*;
+
+ #[actix_rt::test]
+ async fn skips_empty_chunks() {
+ let body = SizedStream::new(
+ 2,
+ stream::iter(["1", "", "2"].iter().map(|&v| Ok(Bytes::from(v)))),
+ );
+ pin!(body);
+ assert_eq!(
+ poll_fn(|cx| body.as_mut().poll_next(cx))
+ .await
+ .unwrap()
+ .ok(),
+ Some(Bytes::from("1")),
+ );
+ assert_eq!(
+ poll_fn(|cx| body.as_mut().poll_next(cx))
+ .await
+ .unwrap()
+ .ok(),
+ Some(Bytes::from("2")),
+ );
+ }
+ }
+
+ #[actix_rt::test]
+ async fn test_body_casting() {
+ let mut body = String::from("hello cast");
+ let resp_body: &mut dyn MessageBody = &mut body;
+ let body = resp_body.downcast_ref::().unwrap();
+ assert_eq!(body, "hello cast");
+ let body = &mut resp_body.downcast_mut::().unwrap();
+ body.push('!');
+ let body = resp_body.downcast_ref::().unwrap();
+ assert_eq!(body, "hello cast!");
+ let not_body = resp_body.downcast_ref::<()>();
+ assert!(not_body.is_none());
+ }
+}
diff --git a/actix-http/src/body/response_body.rs b/actix-http/src/body/response_body.rs
new file mode 100644
index 000000000..97141e11e
--- /dev/null
+++ b/actix-http/src/body/response_body.rs
@@ -0,0 +1,77 @@
+use std::{
+ mem,
+ pin::Pin,
+ task::{Context, Poll},
+};
+
+use bytes::Bytes;
+use futures_core::Stream;
+use pin_project::pin_project;
+
+use crate::error::Error;
+
+use super::{Body, BodySize, MessageBody};
+
+#[pin_project(project = ResponseBodyProj)]
+pub enum ResponseBody {
+ Body(#[pin] B),
+ Other(Body),
+}
+
+impl ResponseBody {
+ pub fn into_body(self) -> ResponseBody {
+ match self {
+ ResponseBody::Body(b) => ResponseBody::Other(b),
+ ResponseBody::Other(b) => ResponseBody::Other(b),
+ }
+ }
+}
+
+impl ResponseBody {
+ pub fn take_body(&mut self) -> ResponseBody {
+ mem::replace(self, ResponseBody::Other(Body::None))
+ }
+}
+
+impl ResponseBody {
+ pub fn as_ref(&self) -> Option<&B> {
+ if let ResponseBody::Body(ref b) = self {
+ Some(b)
+ } else {
+ None
+ }
+ }
+}
+
+impl MessageBody for ResponseBody {
+ fn size(&self) -> BodySize {
+ match self {
+ ResponseBody::Body(ref body) => body.size(),
+ ResponseBody::Other(ref body) => body.size(),
+ }
+ }
+
+ fn poll_next(
+ self: Pin<&mut Self>,
+ cx: &mut Context<'_>,
+ ) -> Poll>> {
+ match self.project() {
+ ResponseBodyProj::Body(body) => body.poll_next(cx),
+ ResponseBodyProj::Other(body) => Pin::new(body).poll_next(cx),
+ }
+ }
+}
+
+impl Stream for ResponseBody {
+ type Item = Result;
+
+ fn poll_next(
+ self: Pin<&mut Self>,
+ cx: &mut Context<'_>,
+ ) -> Poll> {
+ match self.project() {
+ ResponseBodyProj::Body(body) => body.poll_next(cx),
+ ResponseBodyProj::Other(body) => Pin::new(body).poll_next(cx),
+ }
+ }
+}
diff --git a/actix-http/src/body/size.rs b/actix-http/src/body/size.rs
new file mode 100644
index 000000000..775d5b8f1
--- /dev/null
+++ b/actix-http/src/body/size.rs
@@ -0,0 +1,40 @@
+/// Body size hint.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum BodySize {
+ /// Absence of body can be assumed from method or status code.
+ ///
+ /// Will skip writing Content-Length header.
+ None,
+
+ /// Zero size body.
+ ///
+ /// Will write `Content-Length: 0` header.
+ Empty,
+
+ /// Known size body.
+ ///
+ /// Will write `Content-Length: N` header. `Sized(0)` is treated the same as `Empty`.
+ Sized(u64),
+
+ /// Unknown size body.
+ ///
+ /// Will not write Content-Length header. Can be used with chunked Transfer-Encoding.
+ Stream,
+}
+
+impl BodySize {
+ /// Returns true if size hint indicates no or empty body.
+ ///
+ /// ```
+ /// # use actix_http::body::BodySize;
+ /// assert!(BodySize::None.is_eof());
+ /// assert!(BodySize::Empty.is_eof());
+ /// assert!(BodySize::Sized(0).is_eof());
+ ///
+ /// assert!(!BodySize::Sized(64).is_eof());
+ /// assert!(!BodySize::Stream.is_eof());
+ /// ```
+ pub fn is_eof(&self) -> bool {
+ matches!(self, BodySize::None | BodySize::Empty | BodySize::Sized(0))
+ }
+}
diff --git a/actix-http/src/body/sized_stream.rs b/actix-http/src/body/sized_stream.rs
new file mode 100644
index 000000000..af995a0fb
--- /dev/null
+++ b/actix-http/src/body/sized_stream.rs
@@ -0,0 +1,59 @@
+use std::{
+ pin::Pin,
+ task::{Context, Poll},
+};
+
+use bytes::Bytes;
+use futures_core::{ready, Stream};
+
+use crate::error::Error;
+
+use super::{BodySize, MessageBody};
+
+/// Known sized streaming response wrapper.
+///
+/// This body implementation should be used if total size of stream is known. Data get sent as is
+/// without using transfer encoding.
+pub struct SizedStream {
+ size: u64,
+ stream: S,
+}
+
+impl
SizedStream
+where
+ S: Stream- > + Unpin,
+{
+ pub fn new(size: u64, stream: S) -> Self {
+ SizedStream { size, stream }
+ }
+}
+
+impl
MessageBody for SizedStream
+where
+ S: Stream- > + Unpin,
+{
+ fn size(&self) -> BodySize {
+ BodySize::Sized(self.size as u64)
+ }
+
+ /// Attempts to pull out the next value of the underlying [`Stream`].
+ ///
+ /// Empty values are skipped to prevent [`SizedStream`]'s transmission being
+ /// ended on a zero-length chunk, but rather proceed until the underlying
+ /// [`Stream`] ends.
+ fn poll_next(
+ mut self: Pin<&mut Self>,
+ cx: &mut Context<'_>,
+ ) -> Poll>> {
+ loop {
+ let stream = &mut self.as_mut().stream;
+
+ let chunk = match ready!(Pin::new(stream).poll_next(cx)) {
+ Some(Ok(ref bytes)) if bytes.is_empty() => continue,
+ val => val,
+ };
+
+ return Poll::Ready(chunk);
+ }
+ }
+}
diff --git a/actix-http/src/builder.rs b/actix-http/src/builder.rs
index df1b332c1..fa430c4fe 100644
--- a/actix-http/src/builder.rs
+++ b/actix-http/src/builder.rs
@@ -19,7 +19,7 @@ use crate::{ConnectCallback, Extensions};
///
/// This type can be used to construct an instance of [`HttpService`] through a
/// builder-like pattern.
-pub struct HttpServiceBuilder> {
+pub struct HttpServiceBuilder {
keep_alive: KeepAlive,
client_timeout: u64,
client_disconnect: u64,
@@ -28,15 +28,15 @@ pub struct HttpServiceBuilder> {
expect: X,
upgrade: Option,
on_connect_ext: Option>>,
- _t: PhantomData<(T, S)>,
+ _phantom: PhantomData
,
}
-impl HttpServiceBuilder>
+impl HttpServiceBuilder
where
- S: ServiceFactory,
+ S: ServiceFactory,
S::Error: Into + 'static,
S::InitError: fmt::Debug,
- ::Future: 'static,
+ >::Future: 'static,
{
/// Create instance of `ServiceConfigBuilder`
pub fn new() -> Self {
@@ -49,25 +49,25 @@ where
expect: ExpectHandler,
upgrade: None,
on_connect_ext: None,
- _t: PhantomData,
+ _phantom: PhantomData,
}
}
}
impl HttpServiceBuilder
where
- S: ServiceFactory,
+ S: ServiceFactory,
S::Error: Into + 'static,
S::InitError: fmt::Debug,
- ::Future: 'static,
- X: ServiceFactory,
+ >::Future: 'static,
+ X: ServiceFactory,
X::Error: Into,
X::InitError: fmt::Debug,
- ::Future: 'static,
- U: ServiceFactory), Response = ()>,
+ >::Future: 'static,
+ U: ServiceFactory<(Request, Framed), Config = (), Response = ()>,
U::Error: fmt::Display,
U::InitError: fmt::Debug,
- ::Future: 'static,
+ )>>::Future: 'static,
{
/// Set server keep-alive setting.
///
@@ -123,11 +123,11 @@ where
/// request will be forwarded to main service.
pub fn expect(self, expect: F) -> HttpServiceBuilder
where
- F: IntoServiceFactory,
- X1: ServiceFactory,
+ F: IntoServiceFactory,
+ X1: ServiceFactory,
X1::Error: Into,
X1::InitError: fmt::Debug,
- ::Future: 'static,
+ >::Future: 'static,
{
HttpServiceBuilder {
keep_alive: self.keep_alive,
@@ -138,7 +138,7 @@ where
expect: expect.into_factory(),
upgrade: self.upgrade,
on_connect_ext: self.on_connect_ext,
- _t: PhantomData,
+ _phantom: PhantomData,
}
}
@@ -148,15 +148,11 @@ where
/// and this service get called with original request and framed object.
pub fn upgrade(self, upgrade: F) -> HttpServiceBuilder
where
- F: IntoServiceFactory,
- U1: ServiceFactory<
- Config = (),
- Request = (Request, Framed),
- Response = (),
- >,
+ F: IntoServiceFactory)>,
+ U1: ServiceFactory<(Request, Framed), Config = (), Response = ()>,
U1::Error: fmt::Display,
U1::InitError: fmt::Debug,
- ::Future: 'static,
+ )>>::Future: 'static,
{
HttpServiceBuilder {
keep_alive: self.keep_alive,
@@ -167,7 +163,7 @@ where
expect: self.expect,
upgrade: Some(upgrade.into_factory()),
on_connect_ext: self.on_connect_ext,
- _t: PhantomData,
+ _phantom: PhantomData,
}
}
@@ -188,7 +184,7 @@ where
pub fn h1(self, service: F) -> H1Service
where
B: MessageBody,
- F: IntoServiceFactory,
+ F: IntoServiceFactory,
S::Error: Into,
S::InitError: fmt::Debug,
S::Response: Into>,
@@ -211,11 +207,11 @@ where
pub fn h2(self, service: F) -> H2Service
where
B: MessageBody + 'static,
- F: IntoServiceFactory,
+ F: IntoServiceFactory,
S::Error: Into + 'static,
S::InitError: fmt::Debug,
S::Response: Into> + 'static,
- ::Future: 'static,
+ >::Future: 'static,
{
let cfg = ServiceConfig::new(
self.keep_alive,
@@ -233,11 +229,11 @@ where
pub fn finish(self, service: F) -> HttpService
where
B: MessageBody + 'static,
- F: IntoServiceFactory,
+ F: IntoServiceFactory,
S::Error: Into