mirror of https://github.com/fafhrd91/actix-web
Merge branch 'master' into feature/h1_pending_timer
This commit is contained in:
fakeshadow
GitHub
commit
6f03ef4c8c
15
CHANGES.md
15
CHANGES.md
|
|
@ -1,10 +1,21 @@
|
|||
# Changes
|
||||
|
||||
## Unreleased - 2021-xx-xx
|
||||
### Fixed
|
||||
* Double ampersand in Logger format is escaped correctly. [#2067]
|
||||
|
||||
### Removed
|
||||
* The `client` mod was removed. Clients should now use `awc` directly.
|
||||
[871ca5e4](https://github.com/actix/actix-web/commit/871ca5e4ae2bdc22d1ea02701c2992fa8d04aed7)
|
||||
|
||||
[#2067]: https://github.com/actix/actix-web/pull/2067
|
||||
|
||||
|
||||
## 4.0.0-beta.4 - 2021-03-09
|
||||
### Changed
|
||||
* Feature `cookies` is now optional and enabled by default. [#1981]
|
||||
* `JsonBody::new` returns a default limit of 32kB to be consistent with `JsonConfig` and the
|
||||
default behaviour of the `web::Json<T>` extractor. [#2010]
|
||||
* `JsonBody::new` returns a default limit of 32kB to be consistent with `JsonConfig` and the default
|
||||
behaviour of the `web::Json<T>` extractor. [#2010]
|
||||
|
||||
[#1981]: https://github.com/actix/actix-web/pull/1981
|
||||
[#2010]: https://github.com/actix/actix-web/pull/2010
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
[package]
|
||||
name = "actix-web"
|
||||
version = "4.0.0-beta.3"
|
||||
version = "4.0.0-beta.4"
|
||||
authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
|
||||
description = "Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust"
|
||||
readme = "README.md"
|
||||
|
|
@ -86,9 +86,9 @@ actix-service = "2.0.0-beta.4"
|
|||
actix-utils = "3.0.0-beta.2"
|
||||
actix-tls = { version = "3.0.0-beta.4", default-features = false, optional = true }
|
||||
|
||||
actix-web-codegen = "0.5.0-beta.1"
|
||||
actix-http = "3.0.0-beta.3"
|
||||
awc = { version = "3.0.0-beta.2", default-features = false }
|
||||
actix-web-codegen = "0.5.0-beta.2"
|
||||
actix-http = "3.0.0-beta.4"
|
||||
awc = { version = "3.0.0-beta.3", default-features = false }
|
||||
|
||||
ahash = "0.7"
|
||||
bytes = "1"
|
||||
|
|
|
|||
|
|
@ -6,10 +6,10 @@
|
|||
<p>
|
||||
|
||||
[](https://crates.io/crates/actix-web)
|
||||
[](https://docs.rs/actix-web/4.0.0-beta.2)
|
||||
[](https://docs.rs/actix-web/4.0.0-beta.4)
|
||||
[](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
|
||||
|
||||
[](https://deps.rs/crate/actix-web/4.0.0-beta.2)
|
||||
[](https://deps.rs/crate/actix-web/4.0.0-beta.4)
|
||||
<br />
|
||||
[](https://github.com/actix/actix-web/actions)
|
||||
[](https://codecov.io/gh/actix/actix-web)
|
||||
|
|
|
|||
|
|
@ -3,6 +3,10 @@
|
|||
## Unreleased - 2021-xx-xx
|
||||
|
||||
|
||||
## 0.6.0-beta.3 - 2021-03-09
|
||||
* No notable changes.
|
||||
|
||||
|
||||
## 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]
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
[package]
|
||||
name = "actix-files"
|
||||
version = "0.6.0-beta.2"
|
||||
version = "0.6.0-beta.3"
|
||||
authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
|
||||
description = "Static file serving for Actix Web"
|
||||
readme = "README.md"
|
||||
|
|
@ -17,7 +17,7 @@ name = "actix_files"
|
|||
path = "src/lib.rs"
|
||||
|
||||
[dependencies]
|
||||
actix-web = { version = "4.0.0-beta.3", default-features = false }
|
||||
actix-web = { version = "4.0.0-beta.4", default-features = false }
|
||||
actix-service = "2.0.0-beta.4"
|
||||
|
||||
askama_escape = "0.10"
|
||||
|
|
@ -34,4 +34,4 @@ percent-encoding = "2.1"
|
|||
|
||||
[dev-dependencies]
|
||||
actix-rt = "2.1"
|
||||
actix-web = "4.0.0-beta.3"
|
||||
actix-web = "4.0.0-beta.4"
|
||||
|
|
|
|||
|
|
@ -3,17 +3,17 @@
|
|||
> Static file serving for Actix Web
|
||||
|
||||
[](https://crates.io/crates/actix-files)
|
||||
[](https://docs.rs/actix-files/0.5.0)
|
||||
[](https://docs.rs/actix-files/0.6.0-beta.3)
|
||||
[](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
|
||||
|
||||
<br />
|
||||
[](https://deps.rs/crate/actix-files/0.5.0)
|
||||
[](https://deps.rs/crate/actix-files/0.6.0-beta.3)
|
||||
[](https://crates.io/crates/actix-files)
|
||||
[](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
|
||||
|
||||
## Documentation & Resources
|
||||
|
||||
- [API Documentation](https://docs.rs/actix-files/)
|
||||
- [Example Project](https://github.com/actix/examples/tree/master/static_index)
|
||||
- [Example Project](https://github.com/actix/examples/tree/master/basics/static_index)
|
||||
- [Chat on Gitter](https://gitter.im/actix/actix-web)
|
||||
- Minimum supported Rust version: 1.46 or later
|
||||
|
|
|
|||
|
|
@ -662,8 +662,12 @@ mod tests {
|
|||
|
||||
#[actix_rt::test]
|
||||
async fn test_static_files_bad_directory() {
|
||||
let _st: Files = Files::new("/", "missing");
|
||||
let _st: Files = Files::new("/", "Cargo.toml");
|
||||
let service = Files::new("/", "./missing").new_service(()).await.unwrap();
|
||||
|
||||
let req = TestRequest::with_uri("/").to_srv_request();
|
||||
let resp = test::call_service(&service, req).await;
|
||||
|
||||
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
|
||||
}
|
||||
|
||||
#[actix_rt::test]
|
||||
|
|
@ -676,75 +680,34 @@ mod tests {
|
|||
.await
|
||||
.unwrap();
|
||||
let req = TestRequest::with_uri("/missing").to_srv_request();
|
||||
|
||||
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"));
|
||||
}
|
||||
|
||||
// #[actix_rt::test]
|
||||
// async fn test_serve_index() {
|
||||
// let st = Files::new(".").index_file("test.binary");
|
||||
// let req = TestRequest::default().uri("/tests").finish();
|
||||
#[actix_rt::test]
|
||||
async fn test_serve_index_nested() {
|
||||
let service = Files::new(".", ".")
|
||||
.index_file("lib.rs")
|
||||
.new_service(())
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
// let resp = st.handle(&req).respond_to(&req).unwrap();
|
||||
// let resp = resp.as_msg();
|
||||
// assert_eq!(resp.status(), StatusCode::OK);
|
||||
// assert_eq!(
|
||||
// resp.headers()
|
||||
// .get(header::CONTENT_TYPE)
|
||||
// .expect("content type"),
|
||||
// "application/octet-stream"
|
||||
// );
|
||||
// assert_eq!(
|
||||
// resp.headers()
|
||||
// .get(header::CONTENT_DISPOSITION)
|
||||
// .expect("content disposition"),
|
||||
// "attachment; filename=\"test.binary\""
|
||||
// );
|
||||
let req = TestRequest::default().uri("/src").to_srv_request();
|
||||
let resp = test::call_service(&service, req).await;
|
||||
|
||||
// let req = TestRequest::default().uri("/tests/").finish();
|
||||
// let resp = st.handle(&req).respond_to(&req).unwrap();
|
||||
// let resp = resp.as_msg();
|
||||
// assert_eq!(resp.status(), StatusCode::OK);
|
||||
// assert_eq!(
|
||||
// resp.headers().get(header::CONTENT_TYPE).unwrap(),
|
||||
// "application/octet-stream"
|
||||
// );
|
||||
// assert_eq!(
|
||||
// resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
|
||||
// "attachment; filename=\"test.binary\""
|
||||
// );
|
||||
|
||||
// // nonexistent index file
|
||||
// let req = TestRequest::default().uri("/tests/unknown").finish();
|
||||
// let resp = st.handle(&req).respond_to(&req).unwrap();
|
||||
// let resp = resp.as_msg();
|
||||
// assert_eq!(resp.status(), StatusCode::NOT_FOUND);
|
||||
|
||||
// let req = TestRequest::default().uri("/tests/unknown/").finish();
|
||||
// let resp = st.handle(&req).respond_to(&req).unwrap();
|
||||
// let resp = resp.as_msg();
|
||||
// assert_eq!(resp.status(), StatusCode::NOT_FOUND);
|
||||
// }
|
||||
|
||||
// #[actix_rt::test]
|
||||
// async fn test_serve_index_nested() {
|
||||
// let st = Files::new(".").index_file("mod.rs");
|
||||
// let req = TestRequest::default().uri("/src/client").finish();
|
||||
// let resp = st.handle(&req).respond_to(&req).unwrap();
|
||||
// let resp = resp.as_msg();
|
||||
// assert_eq!(resp.status(), StatusCode::OK);
|
||||
// assert_eq!(
|
||||
// resp.headers().get(header::CONTENT_TYPE).unwrap(),
|
||||
// "text/x-rust"
|
||||
// );
|
||||
// assert_eq!(
|
||||
// resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
|
||||
// "inline; filename=\"mod.rs\""
|
||||
// );
|
||||
// }
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
assert_eq!(
|
||||
resp.headers().get(header::CONTENT_TYPE).unwrap(),
|
||||
"text/x-rust"
|
||||
);
|
||||
assert_eq!(
|
||||
resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
|
||||
"inline; filename=\"lib.rs\""
|
||||
);
|
||||
}
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn integration_serve_index() {
|
||||
|
|
|
|||
|
|
@ -3,6 +3,10 @@
|
|||
## Unreleased - 2021-xx-xx
|
||||
|
||||
|
||||
## 3.0.0-beta.3 - 2021-03-09
|
||||
* No notable changes.
|
||||
|
||||
|
||||
## 3.0.0-beta.2 - 2021-02-10
|
||||
* No notable changes.
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
[package]
|
||||
name = "actix-http-test"
|
||||
version = "3.0.0-beta.2"
|
||||
version = "3.0.0-beta.3"
|
||||
authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
|
||||
description = "Various helpers for Actix applications to use during testing"
|
||||
readme = "README.md"
|
||||
|
|
@ -35,7 +35,7 @@ actix-tls = "3.0.0-beta.4"
|
|||
actix-utils = "3.0.0-beta.2"
|
||||
actix-rt = "2.1"
|
||||
actix-server = "2.0.0-beta.3"
|
||||
awc = { version = "3.0.0-beta.2", default-features = false }
|
||||
awc = { version = "3.0.0-beta.3", default-features = false }
|
||||
|
||||
base64 = "0.13"
|
||||
bytes = "1"
|
||||
|
|
@ -57,5 +57,5 @@ features = ["vendored"]
|
|||
optional = true
|
||||
|
||||
[dev-dependencies]
|
||||
actix-web = { version = "4.0.0-beta.3", default-features = false, features = ["cookies"] }
|
||||
actix-http = "3.0.0-beta.3"
|
||||
actix-web = { version = "4.0.0-beta.4", default-features = false, features = ["cookies"] }
|
||||
actix-http = "3.0.0-beta.4"
|
||||
|
|
|
|||
|
|
@ -3,9 +3,9 @@
|
|||
> Various helpers for Actix applications to use during testing.
|
||||
|
||||
[](https://crates.io/crates/actix-http-test)
|
||||
[](https://docs.rs/actix-http-test/2.1.0)
|
||||
[](https://docs.rs/actix-http-test/3.0.0-beta.3)
|
||||
|
||||
[](https://deps.rs/crate/actix-http-test/2.1.0)
|
||||
[](https://deps.rs/crate/actix-http-test/3.0.0-beta.3)
|
||||
[](https://gitter.im/actix/actix-web?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
|
||||
|
||||
## Documentation & Resources
|
||||
|
|
|
|||
|
|
@ -1,15 +1,26 @@
|
|||
# Changes
|
||||
|
||||
## Unreleased - 2021-xx-xx
|
||||
### Chaged
|
||||
* `client::Connector` type now only have one generic type for `actix_service::Service`. [#2063]
|
||||
|
||||
[#2063]: https://github.com/actix/actix-web/pull/2063
|
||||
|
||||
|
||||
## 3.0.0-beta.4 - 2021-03-08
|
||||
### Changed
|
||||
* Feature `cookies` is now optional and disabled by default. [#1981]
|
||||
* `ws::hash_key` now returns array. [#2035]
|
||||
* `ResponseBuilder::json` now takes `impl Serialize`. [#2052]
|
||||
|
||||
### Removed
|
||||
* re-export of `futures_channel::oneshot::Canceled` is removed from `error` mod. [#1994]
|
||||
* 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
|
||||
[#2035]: https://github.com/actix/actix-web/pull/2035
|
||||
[#2052]: https://github.com/actix/actix-web/pull/2052
|
||||
|
||||
|
||||
## 3.0.0-beta.3 - 2021-02-10
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
[package]
|
||||
name = "actix-http"
|
||||
version = "3.0.0-beta.3"
|
||||
version = "3.0.0-beta.4"
|
||||
authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
|
||||
description = "HTTP primitives for the Actix ecosystem"
|
||||
readme = "README.md"
|
||||
|
|
@ -61,7 +61,7 @@ derive_more = "0.99.5"
|
|||
encoding_rs = "0.8"
|
||||
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"
|
||||
h2 = "0.3.1"
|
||||
http = "0.2.2"
|
||||
httparse = "1.3"
|
||||
itoa = "0.4"
|
||||
|
|
@ -89,7 +89,7 @@ trust-dns-resolver = { version = "0.20.0", optional = true }
|
|||
|
||||
[dev-dependencies]
|
||||
actix-server = "2.0.0-beta.3"
|
||||
actix-http-test = { version = "3.0.0-beta.2", features = ["openssl"] }
|
||||
actix-http-test = { version = "3.0.0-beta.3", features = ["openssl"] }
|
||||
actix-tls = { version = "3.0.0-beta.4", features = ["openssl"] }
|
||||
criterion = "0.3"
|
||||
env_logger = "0.8"
|
||||
|
|
@ -103,6 +103,10 @@ version = "0.10.9"
|
|||
package = "openssl"
|
||||
features = ["vendored"]
|
||||
|
||||
[[example]]
|
||||
name = "ws"
|
||||
required-features = ["rustls"]
|
||||
|
||||
[[bench]]
|
||||
name = "write-camel-case"
|
||||
harness = false
|
||||
|
|
|
|||
|
|
@ -3,11 +3,11 @@
|
|||
> HTTP primitives for the Actix ecosystem.
|
||||
|
||||
[](https://crates.io/crates/actix-http)
|
||||
[](https://docs.rs/actix-http/3.0.0-beta.3)
|
||||
[](https://docs.rs/actix-http/3.0.0-beta.4)
|
||||
[](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
|
||||
|
||||
<br />
|
||||
[](https://deps.rs/crate/actix-http/3.0.0-beta.3)
|
||||
[](https://deps.rs/crate/actix-http/3.0.0-beta.4)
|
||||
[](https://crates.io/crates/actix-http)
|
||||
[](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,107 @@
|
|||
//! Sets up a WebSocket server over TCP and TLS.
|
||||
//! Sends a heartbeat message every 4 seconds but does not respond to any incoming frames.
|
||||
|
||||
extern crate tls_rustls as rustls;
|
||||
|
||||
use std::{
|
||||
env, io,
|
||||
pin::Pin,
|
||||
task::{Context, Poll},
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
use actix_codec::Encoder;
|
||||
use actix_http::{error::Error, ws, HttpService, Request, Response};
|
||||
use actix_rt::time::{interval, Interval};
|
||||
use actix_server::Server;
|
||||
use bytes::{Bytes, BytesMut};
|
||||
use bytestring::ByteString;
|
||||
use futures_core::{ready, Stream};
|
||||
|
||||
#[actix_rt::main]
|
||||
async fn main() -> io::Result<()> {
|
||||
env::set_var("RUST_LOG", "actix=info,h2_ws=info");
|
||||
env_logger::init();
|
||||
|
||||
Server::build()
|
||||
.bind("tcp", ("127.0.0.1", 8080), || {
|
||||
HttpService::build().h1(handler).tcp()
|
||||
})?
|
||||
.bind("tls", ("127.0.0.1", 8443), || {
|
||||
HttpService::build().finish(handler).rustls(tls_config())
|
||||
})?
|
||||
.run()
|
||||
.await
|
||||
}
|
||||
|
||||
async fn handler(req: Request) -> Result<Response, Error> {
|
||||
log::info!("handshaking");
|
||||
let mut res = ws::handshake(req.head())?;
|
||||
|
||||
// handshake will always fail under HTTP/2
|
||||
|
||||
log::info!("responding");
|
||||
Ok(res.streaming(Heartbeat::new(ws::Codec::new())))
|
||||
}
|
||||
|
||||
struct Heartbeat {
|
||||
codec: ws::Codec,
|
||||
interval: Interval,
|
||||
}
|
||||
|
||||
impl Heartbeat {
|
||||
fn new(codec: ws::Codec) -> Self {
|
||||
Self {
|
||||
codec,
|
||||
interval: interval(Duration::from_secs(4)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Stream for Heartbeat {
|
||||
type Item = Result<Bytes, Error>;
|
||||
|
||||
fn poll_next(
|
||||
mut self: Pin<&mut Self>,
|
||||
cx: &mut Context<'_>,
|
||||
) -> Poll<Option<Self::Item>> {
|
||||
log::trace!("poll");
|
||||
|
||||
ready!(self.as_mut().interval.poll_tick(cx));
|
||||
|
||||
let mut buffer = BytesMut::new();
|
||||
|
||||
self.as_mut()
|
||||
.codec
|
||||
.encode(
|
||||
ws::Message::Text(ByteString::from_static("hello world")),
|
||||
&mut buffer,
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
Poll::Ready(Some(Ok(buffer.freeze())))
|
||||
}
|
||||
}
|
||||
|
||||
fn tls_config() -> rustls::ServerConfig {
|
||||
use std::io::BufReader;
|
||||
|
||||
use rustls::{
|
||||
internal::pemfile::{certs, pkcs8_private_keys},
|
||||
NoClientAuth, ServerConfig,
|
||||
};
|
||||
|
||||
let cert = rcgen::generate_simple_self_signed(vec!["localhost".to_owned()]).unwrap();
|
||||
let cert_file = cert.serialize_pem().unwrap();
|
||||
let key_file = cert.serialize_private_key_pem();
|
||||
|
||||
let mut config = ServerConfig::new(NoClientAuth::new());
|
||||
let cert_file = &mut BufReader::new(cert_file.as_bytes());
|
||||
let key_file = &mut BufReader::new(key_file.as_bytes());
|
||||
|
||||
let cert_chain = certs(cert_file).unwrap();
|
||||
let mut keys = pkcs8_private_keys(key_file).unwrap();
|
||||
config.set_single_cert(cert_chain, keys.remove(0)).unwrap();
|
||||
|
||||
config
|
||||
}
|
||||
|
|
@ -94,14 +94,6 @@ pub trait Connection {
|
|||
>;
|
||||
}
|
||||
|
||||
pub(crate) trait ConnectionLifetime: AsyncRead + AsyncWrite + 'static {
|
||||
/// Close connection
|
||||
fn close(self: Pin<&mut Self>);
|
||||
|
||||
/// Release connection to the connection pool
|
||||
fn release(self: Pin<&mut Self>);
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
/// HTTP client connection
|
||||
pub struct IoConnection<T>
|
||||
|
|
@ -110,7 +102,7 @@ where
|
|||
{
|
||||
io: Option<ConnectionType<T>>,
|
||||
created: time::Instant,
|
||||
pool: Option<Acquired<T>>,
|
||||
pool: Acquired<T>,
|
||||
}
|
||||
|
||||
impl<T> fmt::Debug for IoConnection<T>
|
||||
|
|
@ -130,7 +122,7 @@ impl<T: AsyncRead + AsyncWrite + Unpin> IoConnection<T> {
|
|||
pub(crate) fn new(
|
||||
io: ConnectionType<T>,
|
||||
created: time::Instant,
|
||||
pool: Option<Acquired<T>>,
|
||||
pool: Acquired<T>,
|
||||
) -> Self {
|
||||
IoConnection {
|
||||
pool,
|
||||
|
|
@ -139,13 +131,9 @@ impl<T: AsyncRead + AsyncWrite + Unpin> IoConnection<T> {
|
|||
}
|
||||
}
|
||||
|
||||
pub(crate) fn into_inner(self) -> (ConnectionType<T>, time::Instant) {
|
||||
(self.io.unwrap(), self.created)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(crate) fn into_parts(self) -> (ConnectionType<T>, time::Instant, Acquired<T>) {
|
||||
(self.io.unwrap(), self.created, self.pool.unwrap())
|
||||
(self.io.unwrap(), self.created, self.pool)
|
||||
}
|
||||
|
||||
async fn send_request<B: MessageBody + 'static, H: Into<RequestHeadType>>(
|
||||
|
|
@ -173,13 +161,7 @@ impl<T: AsyncRead + AsyncWrite + Unpin> IoConnection<T> {
|
|||
match self.io.take().unwrap() {
|
||||
ConnectionType::H1(io) => h1proto::open_tunnel(io, head.into()).await,
|
||||
ConnectionType::H2(io) => {
|
||||
if let Some(mut pool) = self.pool.take() {
|
||||
pool.release(IoConnection::new(
|
||||
ConnectionType::H2(io),
|
||||
self.created,
|
||||
None,
|
||||
));
|
||||
}
|
||||
self.pool.release(ConnectionType::H2(io), self.created);
|
||||
Err(SendRequestError::TunnelNotSupported)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,6 @@
|
|||
use std::{
|
||||
fmt,
|
||||
future::Future,
|
||||
marker::PhantomData,
|
||||
net::IpAddr,
|
||||
pin::Pin,
|
||||
task::{Context, Poll},
|
||||
|
|
@ -15,13 +14,15 @@ use actix_tls::connect::{
|
|||
new_connector, Connect as TcpConnect, Connection as TcpConnection, Resolver,
|
||||
};
|
||||
use actix_utils::timeout::{TimeoutError, TimeoutService};
|
||||
use futures_core::ready;
|
||||
use http::Uri;
|
||||
|
||||
use super::config::ConnectorConfig;
|
||||
use super::connection::{Connection, EitherIoConnection};
|
||||
use super::error::ConnectError;
|
||||
use super::pool::{ConnectionPool, Protocol};
|
||||
use super::pool::ConnectionPool;
|
||||
use super::Connect;
|
||||
use super::Protocol;
|
||||
|
||||
#[cfg(feature = "openssl")]
|
||||
use actix_tls::connect::ssl::openssl::SslConnector as OpensslConnector;
|
||||
|
|
@ -53,18 +54,17 @@ type SslConnector = ();
|
|||
/// .timeout(Duration::from_secs(5))
|
||||
/// .finish();
|
||||
/// ```
|
||||
pub struct Connector<T, U> {
|
||||
pub struct Connector<T> {
|
||||
connector: T,
|
||||
config: ConnectorConfig,
|
||||
#[allow(dead_code)]
|
||||
ssl: SslConnector,
|
||||
_phantom: PhantomData<U>,
|
||||
}
|
||||
|
||||
pub trait Io: AsyncRead + AsyncWrite + Unpin {}
|
||||
impl<T: AsyncRead + AsyncWrite + Unpin> Io for T {}
|
||||
|
||||
impl Connector<(), ()> {
|
||||
impl Connector<()> {
|
||||
#[allow(clippy::new_ret_no_self, clippy::let_unit_value)]
|
||||
pub fn new() -> Connector<
|
||||
impl Service<
|
||||
|
|
@ -72,13 +72,11 @@ impl Connector<(), ()> {
|
|||
Response = TcpConnection<Uri, TcpStream>,
|
||||
Error = actix_tls::connect::ConnectError,
|
||||
> + Clone,
|
||||
TcpStream,
|
||||
> {
|
||||
Connector {
|
||||
ssl: Self::build_ssl(vec![b"h2".to_vec(), b"http/1.1".to_vec()]),
|
||||
connector: new_connector(resolver::resolver()),
|
||||
config: ConnectorConfig::default(),
|
||||
_phantom: PhantomData,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -117,9 +115,9 @@ impl Connector<(), ()> {
|
|||
fn build_ssl(_: Vec<Vec<u8>>) -> SslConnector {}
|
||||
}
|
||||
|
||||
impl<T, U> Connector<T, U> {
|
||||
impl<T> Connector<T> {
|
||||
/// Use custom connector.
|
||||
pub fn connector<T1, U1>(self, connector: T1) -> Connector<T1, U1>
|
||||
pub fn connector<T1, U1>(self, connector: T1) -> Connector<T1>
|
||||
where
|
||||
U1: AsyncRead + AsyncWrite + Unpin + fmt::Debug,
|
||||
T1: Service<
|
||||
|
|
@ -132,12 +130,11 @@ impl<T, U> Connector<T, U> {
|
|||
connector,
|
||||
config: self.config,
|
||||
ssl: self.ssl,
|
||||
_phantom: PhantomData,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, U> Connector<T, U>
|
||||
impl<T, U> Connector<T>
|
||||
where
|
||||
U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static,
|
||||
T: Service<
|
||||
|
|
@ -148,7 +145,7 @@ where
|
|||
+ 'static,
|
||||
{
|
||||
/// Connection timeout, i.e. max time to connect to remote host including dns name resolution.
|
||||
/// Set to 1 second by default.
|
||||
/// Set to 5 second by default.
|
||||
pub fn timeout(mut self, timeout: Duration) -> Self {
|
||||
self.config.timeout = timeout;
|
||||
self
|
||||
|
|
@ -162,6 +159,7 @@ where
|
|||
}
|
||||
|
||||
#[cfg(feature = "rustls")]
|
||||
/// Use custom `SslConnector` instance.
|
||||
pub fn rustls(mut self, connector: Arc<ClientConfig>) -> Self {
|
||||
self.ssl = SslConnector::Rustls(connector);
|
||||
self
|
||||
|
|
@ -254,8 +252,7 @@ where
|
|||
/// its combinator chain.
|
||||
pub fn finish(
|
||||
self,
|
||||
) -> impl Service<Connect, Response = impl Connection, Error = ConnectError> + Clone
|
||||
{
|
||||
) -> impl Service<Connect, Response = impl Connection, Error = ConnectError> {
|
||||
let local_address = self.config.local_address;
|
||||
let timeout = self.config.timeout;
|
||||
|
||||
|
|
@ -392,21 +389,6 @@ where
|
|||
tls_pool: Option<ConnectionPool<S2, Io2>>,
|
||||
}
|
||||
|
||||
impl<S1, S2, Io1, Io2> Clone for InnerConnector<S1, S2, Io1, Io2>
|
||||
where
|
||||
S1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
|
||||
S2: Service<Connect, Response = (Io2, Protocol), Error = ConnectError> + 'static,
|
||||
Io1: AsyncRead + AsyncWrite + Unpin + 'static,
|
||||
Io2: AsyncRead + AsyncWrite + Unpin + 'static,
|
||||
{
|
||||
fn clone(&self) -> Self {
|
||||
InnerConnector {
|
||||
tcp_pool: self.tcp_pool.clone(),
|
||||
tls_pool: self.tls_pool.as_ref().cloned(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<S1, S2, Io1, Io2> Service<Connect> for InnerConnector<S1, S2, Io1, Io2>
|
||||
where
|
||||
S1: Service<Connect, Response = (Io1, Protocol), Error = ConnectError> + 'static,
|
||||
|
|
@ -419,7 +401,11 @@ where
|
|||
type Future = InnerConnectorResponse<S1, S2, Io1, Io2>;
|
||||
|
||||
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
|
||||
self.tcp_pool.poll_ready(cx)
|
||||
ready!(self.tcp_pool.poll_ready(cx))?;
|
||||
if let Some(ref tls_pool) = self.tls_pool {
|
||||
ready!(tls_pool.poll_ready(cx))?;
|
||||
}
|
||||
Poll::Ready(Ok(()))
|
||||
}
|
||||
|
||||
fn call(&self, req: Connect) -> Self::Future {
|
||||
|
|
|
|||
|
|
@ -7,17 +7,19 @@ use actix_codec::{AsyncRead, AsyncWrite, Framed, ReadBuf};
|
|||
use bytes::buf::BufMut;
|
||||
use bytes::{Bytes, BytesMut};
|
||||
use futures_core::Stream;
|
||||
use futures_util::future::poll_fn;
|
||||
use futures_util::{SinkExt, StreamExt};
|
||||
use futures_util::{future::poll_fn, SinkExt};
|
||||
|
||||
use crate::error::PayloadError;
|
||||
use crate::h1;
|
||||
use crate::header::HeaderMap;
|
||||
use crate::http::header::{IntoHeaderValue, HOST};
|
||||
use crate::http::{
|
||||
header::{IntoHeaderValue, EXPECT, HOST},
|
||||
StatusCode,
|
||||
};
|
||||
use crate::message::{RequestHeadType, ResponseHead};
|
||||
use crate::payload::{Payload, PayloadStream};
|
||||
|
||||
use super::connection::{ConnectionLifetime, ConnectionType, IoConnection};
|
||||
use super::connection::ConnectionType;
|
||||
use super::error::{ConnectError, SendRequestError};
|
||||
use super::pool::Acquired;
|
||||
use crate::body::{BodySize, MessageBody};
|
||||
|
|
@ -27,7 +29,7 @@ pub(crate) async fn send_request<T, B>(
|
|||
mut head: RequestHeadType,
|
||||
body: B,
|
||||
created: time::Instant,
|
||||
pool: Option<Acquired<T>>,
|
||||
acquired: Acquired<T>,
|
||||
) -> Result<(ResponseHead, Payload), SendRequestError>
|
||||
where
|
||||
T: AsyncRead + AsyncWrite + Unpin + 'static,
|
||||
|
|
@ -40,9 +42,9 @@ where
|
|||
if let Some(host) = head.as_ref().uri.host() {
|
||||
let mut wrt = BytesMut::with_capacity(host.len() + 5).writer();
|
||||
|
||||
let _ = match head.as_ref().uri.port_u16() {
|
||||
None | Some(80) | Some(443) => write!(wrt, "{}", host),
|
||||
Some(port) => write!(wrt, "{}:{}", host, port),
|
||||
match head.as_ref().uri.port_u16() {
|
||||
None | Some(80) | Some(443) => write!(wrt, "{}", host)?,
|
||||
Some(port) => write!(wrt, "{}:{}", host, port)?,
|
||||
};
|
||||
|
||||
match wrt.get_mut().split().freeze().try_into_value() {
|
||||
|
|
@ -62,37 +64,75 @@ where
|
|||
|
||||
let io = H1Connection {
|
||||
created,
|
||||
pool,
|
||||
acquired,
|
||||
io: Some(io),
|
||||
};
|
||||
|
||||
// create Framed and send request
|
||||
let mut framed_inner = Framed::new(io, h1::ClientCodec::default());
|
||||
framed_inner.send((head, body.size()).into()).await?;
|
||||
// create Framed and prepare sending request
|
||||
let mut framed = Framed::new(io, h1::ClientCodec::default());
|
||||
|
||||
// Check EXPECT header and enable expect handle flag accordingly.
|
||||
//
|
||||
// RFC: https://tools.ietf.org/html/rfc7231#section-5.1.1
|
||||
let is_expect = if head.as_ref().headers.contains_key(EXPECT) {
|
||||
match body.size() {
|
||||
BodySize::None | BodySize::Empty | BodySize::Sized(0) => {
|
||||
let keep_alive = framed.codec_ref().keepalive();
|
||||
framed.io_mut().on_release(keep_alive);
|
||||
|
||||
// TODO: use a new variant or a new type better describing error violate
|
||||
// `Requirements for clients` session of above RFC
|
||||
return Err(SendRequestError::Connect(ConnectError::Disconnected));
|
||||
}
|
||||
_ => true,
|
||||
}
|
||||
} else {
|
||||
false
|
||||
};
|
||||
|
||||
framed.send((head, body.size()).into()).await?;
|
||||
|
||||
let mut pin_framed = Pin::new(&mut framed);
|
||||
|
||||
// special handle for EXPECT request.
|
||||
let (do_send, mut res_head) = if is_expect {
|
||||
let head = poll_fn(|cx| pin_framed.as_mut().poll_next(cx))
|
||||
.await
|
||||
.ok_or(ConnectError::Disconnected)??;
|
||||
|
||||
// return response head in case status code is not continue
|
||||
// and current head would be used as final response head.
|
||||
(head.status == StatusCode::CONTINUE, Some(head))
|
||||
} else {
|
||||
(true, None)
|
||||
};
|
||||
|
||||
if do_send {
|
||||
// send request body
|
||||
match body.size() {
|
||||
BodySize::None | BodySize::Empty | BodySize::Sized(0) => {}
|
||||
_ => send_body(body, Pin::new(&mut framed_inner)).await?,
|
||||
_ => send_body(body, pin_framed.as_mut()).await?,
|
||||
};
|
||||
|
||||
// read response and init read body
|
||||
let res = Pin::new(&mut framed_inner).into_future().await;
|
||||
let (head, framed) = if let (Some(result), framed) = res {
|
||||
let item = result.map_err(SendRequestError::from)?;
|
||||
(item, framed)
|
||||
} else {
|
||||
return Err(SendRequestError::from(ConnectError::Disconnected));
|
||||
};
|
||||
let head = poll_fn(|cx| pin_framed.as_mut().poll_next(cx))
|
||||
.await
|
||||
.ok_or(ConnectError::Disconnected)??;
|
||||
|
||||
match framed.codec_ref().message_type() {
|
||||
res_head = Some(head);
|
||||
}
|
||||
|
||||
let head = res_head.unwrap();
|
||||
|
||||
match pin_framed.codec_ref().message_type() {
|
||||
h1::MessageType::None => {
|
||||
let force_close = !framed.codec_ref().keepalive();
|
||||
release_connection(framed, force_close);
|
||||
let keep_alive = pin_framed.codec_ref().keepalive();
|
||||
pin_framed.io_mut().on_release(keep_alive);
|
||||
|
||||
Ok((head, Payload::None))
|
||||
}
|
||||
_ => {
|
||||
let pl: PayloadStream = PlStream::new(framed_inner).boxed_local();
|
||||
let pl: PayloadStream = Box::pin(PlStream::new(framed));
|
||||
Ok((head, pl.into()))
|
||||
}
|
||||
}
|
||||
|
|
@ -110,12 +150,11 @@ where
|
|||
framed.send((head, BodySize::None).into()).await?;
|
||||
|
||||
// read response
|
||||
if let (Some(result), framed) = framed.into_future().await {
|
||||
let head = result.map_err(SendRequestError::from)?;
|
||||
let head = poll_fn(|cx| Pin::new(&mut framed).poll_next(cx))
|
||||
.await
|
||||
.ok_or(ConnectError::Disconnected)??;
|
||||
|
||||
Ok((head, framed))
|
||||
} else {
|
||||
Err(SendRequestError::from(ConnectError::Disconnected))
|
||||
}
|
||||
}
|
||||
|
||||
/// send request body to the peer
|
||||
|
|
@ -124,7 +163,7 @@ pub(crate) async fn send_body<T, B>(
|
|||
mut framed: Pin<&mut Framed<T, h1::ClientCodec>>,
|
||||
) -> Result<(), SendRequestError>
|
||||
where
|
||||
T: ConnectionLifetime + Unpin,
|
||||
T: AsyncRead + AsyncWrite + Unpin + 'static,
|
||||
B: MessageBody,
|
||||
{
|
||||
actix_rt::pin!(body);
|
||||
|
|
@ -159,7 +198,7 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
SinkExt::flush(Pin::into_inner(framed)).await?;
|
||||
SinkExt::flush(framed.get_mut()).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
|
@ -167,41 +206,37 @@ where
|
|||
/// HTTP client connection
|
||||
pub struct H1Connection<T>
|
||||
where
|
||||
T: AsyncWrite + Unpin + 'static,
|
||||
T: AsyncRead + AsyncWrite + Unpin + 'static,
|
||||
{
|
||||
/// T should be `Unpin`
|
||||
io: Option<T>,
|
||||
created: time::Instant,
|
||||
pool: Option<Acquired<T>>,
|
||||
acquired: Acquired<T>,
|
||||
}
|
||||
|
||||
impl<T> ConnectionLifetime for H1Connection<T>
|
||||
impl<T> H1Connection<T>
|
||||
where
|
||||
T: AsyncRead + AsyncWrite + Unpin + 'static,
|
||||
{
|
||||
/// Close connection
|
||||
fn close(mut self: Pin<&mut Self>) {
|
||||
if let Some(mut pool) = self.pool.take() {
|
||||
if let Some(io) = self.io.take() {
|
||||
pool.close(IoConnection::new(
|
||||
ConnectionType::H1(io),
|
||||
self.created,
|
||||
None,
|
||||
));
|
||||
fn on_release(&mut self, keep_alive: bool) {
|
||||
if keep_alive {
|
||||
self.release();
|
||||
} else {
|
||||
self.close();
|
||||
}
|
||||
}
|
||||
|
||||
/// Close connection
|
||||
fn close(&mut self) {
|
||||
if let Some(io) = self.io.take() {
|
||||
self.acquired.close(ConnectionType::H1(io));
|
||||
}
|
||||
}
|
||||
|
||||
/// Release this connection to the connection pool
|
||||
fn release(mut self: Pin<&mut Self>) {
|
||||
if let Some(mut pool) = self.pool.take() {
|
||||
fn release(&mut self) {
|
||||
if let Some(io) = self.io.take() {
|
||||
pool.release(IoConnection::new(
|
||||
ConnectionType::H1(io),
|
||||
self.created,
|
||||
None,
|
||||
));
|
||||
}
|
||||
self.acquired.release(ConnectionType::H1(io), self.created);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -241,13 +276,19 @@ impl<T: AsyncRead + AsyncWrite + Unpin + 'static> AsyncWrite for H1Connection<T>
|
|||
}
|
||||
|
||||
#[pin_project::pin_project]
|
||||
pub(crate) struct PlStream<Io> {
|
||||
pub(crate) struct PlStream<Io>
|
||||
where
|
||||
Io: AsyncRead + AsyncWrite + Unpin + 'static,
|
||||
{
|
||||
#[pin]
|
||||
framed: Option<Framed<Io, h1::ClientPayloadCodec>>,
|
||||
framed: Option<Framed<H1Connection<Io>, h1::ClientPayloadCodec>>,
|
||||
}
|
||||
|
||||
impl<Io: ConnectionLifetime> PlStream<Io> {
|
||||
fn new(framed: Framed<Io, h1::ClientCodec>) -> Self {
|
||||
impl<Io> PlStream<Io>
|
||||
where
|
||||
Io: AsyncRead + AsyncWrite + Unpin + 'static,
|
||||
{
|
||||
fn new(framed: Framed<H1Connection<Io>, h1::ClientCodec>) -> Self {
|
||||
let framed = framed.into_map_codec(|codec| codec.into_payload_codec());
|
||||
|
||||
PlStream {
|
||||
|
|
@ -256,24 +297,26 @@ impl<Io: ConnectionLifetime> PlStream<Io> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<Io: ConnectionLifetime> Stream for PlStream<Io> {
|
||||
impl<Io> Stream for PlStream<Io>
|
||||
where
|
||||
Io: AsyncRead + AsyncWrite + Unpin + 'static,
|
||||
{
|
||||
type Item = Result<Bytes, PayloadError>;
|
||||
|
||||
fn poll_next(
|
||||
self: Pin<&mut Self>,
|
||||
cx: &mut Context<'_>,
|
||||
) -> Poll<Option<Self::Item>> {
|
||||
let mut this = self.project();
|
||||
let mut framed = self.project().framed.as_pin_mut().unwrap();
|
||||
|
||||
match this.framed.as_mut().as_pin_mut().unwrap().next_item(cx)? {
|
||||
match framed.as_mut().next_item(cx)? {
|
||||
Poll::Pending => Poll::Pending,
|
||||
Poll::Ready(Some(chunk)) => {
|
||||
if let Some(chunk) = chunk {
|
||||
Poll::Ready(Some(Ok(chunk)))
|
||||
} else {
|
||||
let framed = this.framed.as_mut().as_pin_mut().unwrap();
|
||||
let force_close = !framed.codec_ref().keepalive();
|
||||
release_connection(framed, force_close);
|
||||
let keep_alive = framed.codec_ref().keepalive();
|
||||
framed.io_mut().on_release(keep_alive);
|
||||
Poll::Ready(None)
|
||||
}
|
||||
}
|
||||
|
|
@ -281,14 +324,3 @@ impl<Io: ConnectionLifetime> Stream for PlStream<Io> {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn release_connection<T, U>(framed: Pin<&mut Framed<T, U>>, force_close: bool)
|
||||
where
|
||||
T: ConnectionLifetime,
|
||||
{
|
||||
if !force_close && framed.is_read_buf_empty() && framed.is_write_buf_empty() {
|
||||
framed.io_pin().release()
|
||||
} else {
|
||||
framed.io_pin().close()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
use std::convert::TryFrom;
|
||||
use std::future::Future;
|
||||
use std::time;
|
||||
|
||||
|
|
@ -18,7 +17,7 @@ use crate::message::{RequestHeadType, ResponseHead};
|
|||
use crate::payload::Payload;
|
||||
|
||||
use super::config::ConnectorConfig;
|
||||
use super::connection::{ConnectionType, IoConnection};
|
||||
use super::connection::ConnectionType;
|
||||
use super::error::SendRequestError;
|
||||
use super::pool::Acquired;
|
||||
use crate::client::connection::H2Connection;
|
||||
|
|
@ -28,7 +27,7 @@ pub(crate) async fn send_request<T, B>(
|
|||
head: RequestHeadType,
|
||||
body: B,
|
||||
created: time::Instant,
|
||||
pool: Option<Acquired<T>>,
|
||||
acquired: Acquired<T>,
|
||||
) -> Result<(ResponseHead, Payload), SendRequestError>
|
||||
where
|
||||
T: AsyncRead + AsyncWrite + Unpin + 'static,
|
||||
|
|
@ -61,10 +60,14 @@ where
|
|||
BodySize::Empty => req
|
||||
.headers_mut()
|
||||
.insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
|
||||
BodySize::Sized(len) => req.headers_mut().insert(
|
||||
BodySize::Sized(len) => {
|
||||
let mut buf = itoa::Buffer::new();
|
||||
|
||||
req.headers_mut().insert(
|
||||
CONTENT_LENGTH,
|
||||
HeaderValue::try_from(format!("{}", len)).unwrap(),
|
||||
),
|
||||
HeaderValue::from_str(buf.format(len)).unwrap(),
|
||||
)
|
||||
}
|
||||
};
|
||||
|
||||
// Extracting extra headers from RequestHeadType. HeaderMap::new() does not allocate.
|
||||
|
|
@ -87,7 +90,10 @@ where
|
|||
// copy headers
|
||||
for (key, value) in headers {
|
||||
match *key {
|
||||
CONNECTION | TRANSFER_ENCODING => continue, // http2 specific
|
||||
// TODO: consider skipping other headers according to:
|
||||
// https://tools.ietf.org/html/rfc7540#section-8.1.2.2
|
||||
// omit HTTP/1.x only headers
|
||||
CONNECTION | TRANSFER_ENCODING => continue,
|
||||
CONTENT_LENGTH if skip_len => continue,
|
||||
// DATE => has_date = true,
|
||||
_ => {}
|
||||
|
|
@ -97,13 +103,13 @@ where
|
|||
|
||||
let res = poll_fn(|cx| io.poll_ready(cx)).await;
|
||||
if let Err(e) = res {
|
||||
release(io, pool, created, e.is_io());
|
||||
release(io, acquired, created, e.is_io());
|
||||
return Err(SendRequestError::from(e));
|
||||
}
|
||||
|
||||
let resp = match io.send_request(req, eof) {
|
||||
Ok((fut, send)) => {
|
||||
release(io, pool, created, false);
|
||||
release(io, acquired, created, false);
|
||||
|
||||
if !eof {
|
||||
send_body(body, send).await?;
|
||||
|
|
@ -111,7 +117,7 @@ where
|
|||
fut.await.map_err(SendRequestError::from)?
|
||||
}
|
||||
Err(e) => {
|
||||
release(io, pool, created, e.is_io());
|
||||
release(io, acquired, created, e.is_io());
|
||||
return Err(e.into());
|
||||
}
|
||||
};
|
||||
|
|
@ -175,16 +181,14 @@ async fn send_body<B: MessageBody>(
|
|||
/// release SendRequest object
|
||||
fn release<T: AsyncRead + AsyncWrite + Unpin + 'static>(
|
||||
io: H2Connection,
|
||||
pool: Option<Acquired<T>>,
|
||||
acquired: Acquired<T>,
|
||||
created: time::Instant,
|
||||
close: bool,
|
||||
) {
|
||||
if let Some(mut pool) = pool {
|
||||
if close {
|
||||
pool.close(IoConnection::new(ConnectionType::H2(io), created, None));
|
||||
acquired.close(ConnectionType::H2(io));
|
||||
} else {
|
||||
pool.release(IoConnection::new(ConnectionType::H2(io), created, None));
|
||||
}
|
||||
acquired.release(ConnectionType::H2(io), created);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ pub use actix_tls::connect::{
|
|||
pub use self::connection::Connection;
|
||||
pub use self::connector::Connector;
|
||||
pub use self::error::{ConnectError, FreezeRequestError, InvalidUrl, SendRequestError};
|
||||
pub use self::pool::Protocol;
|
||||
pub use crate::Protocol;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct Connect {
|
||||
|
|
|
|||
|
|
@ -25,13 +25,7 @@ use super::connection::{ConnectionType, H2Connection, IoConnection};
|
|||
use super::error::ConnectError;
|
||||
use super::h2proto::handshake;
|
||||
use super::Connect;
|
||||
|
||||
#[derive(Clone, Copy, PartialEq)]
|
||||
/// Protocol version
|
||||
pub enum Protocol {
|
||||
Http1,
|
||||
Http2,
|
||||
}
|
||||
use super::Protocol;
|
||||
|
||||
#[derive(Hash, Eq, PartialEq, Clone, Debug)]
|
||||
pub(crate) struct Key {
|
||||
|
|
@ -148,18 +142,6 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
impl<S, Io> Clone for ConnectionPool<S, Io>
|
||||
where
|
||||
Io: AsyncWrite + Unpin + 'static,
|
||||
{
|
||||
fn clone(&self) -> Self {
|
||||
Self {
|
||||
connector: self.connector.clone(),
|
||||
inner: self.inner.clone(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<S, Io> Service<Connect> for ConnectionPool<S, Io>
|
||||
where
|
||||
S: Service<Connect, Response = (Io, Protocol), Error = ConnectError> + 'static,
|
||||
|
|
@ -235,7 +217,7 @@ where
|
|||
|
||||
// construct acquired. It's used to put Io type back to pool/ close the Io type.
|
||||
// permit is carried with the whole lifecycle of Acquired.
|
||||
let acquired = Some(Acquired { key, inner, permit });
|
||||
let acquired = Acquired { key, inner, permit };
|
||||
|
||||
// match the connection and spawn new one if did not get anything.
|
||||
match conn {
|
||||
|
|
@ -243,6 +225,9 @@ where
|
|||
None => {
|
||||
let (io, proto) = connector.call(req).await?;
|
||||
|
||||
// TODO: remove when http3 is added in support.
|
||||
assert!(proto != Protocol::Http3);
|
||||
|
||||
if proto == Protocol::Http1 {
|
||||
Ok(IoConnection::new(
|
||||
ConnectionType::H1(io),
|
||||
|
|
@ -250,7 +235,7 @@ where
|
|||
acquired,
|
||||
))
|
||||
} else {
|
||||
let config = &acquired.as_ref().unwrap().inner.config;
|
||||
let config = &acquired.inner.config;
|
||||
let (sender, connection) = handshake(io, config).await?;
|
||||
Ok(IoConnection::new(
|
||||
ConnectionType::H2(H2Connection::new(sender, connection)),
|
||||
|
|
@ -361,14 +346,12 @@ where
|
|||
Io: AsyncRead + AsyncWrite + Unpin + 'static,
|
||||
{
|
||||
/// Close the IO.
|
||||
pub(crate) fn close(&mut self, conn: IoConnection<Io>) {
|
||||
let (conn, _) = conn.into_inner();
|
||||
pub(crate) fn close(&self, conn: ConnectionType<Io>) {
|
||||
self.inner.close(conn);
|
||||
}
|
||||
|
||||
/// Release IO back into pool.
|
||||
pub(crate) fn release(&mut self, conn: IoConnection<Io>) {
|
||||
let (io, created) = conn.into_inner();
|
||||
pub(crate) fn release(&self, conn: ConnectionType<Io>, created: Instant) {
|
||||
let Acquired { key, inner, .. } = self;
|
||||
|
||||
inner
|
||||
|
|
@ -377,12 +360,12 @@ where
|
|||
.entry(key.clone())
|
||||
.or_insert_with(VecDeque::new)
|
||||
.push_back(PooledConnection {
|
||||
conn: io,
|
||||
conn,
|
||||
created,
|
||||
used: Instant::now(),
|
||||
});
|
||||
|
||||
let _ = &mut self.permit;
|
||||
let _ = &self.permit;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -462,8 +445,8 @@ mod test {
|
|||
where
|
||||
T: AsyncRead + AsyncWrite + Unpin + 'static,
|
||||
{
|
||||
let (conn, created, mut acquired) = conn.into_parts();
|
||||
acquired.release(IoConnection::new(conn, created, None));
|
||||
let (conn, created, acquired) = conn.into_parts();
|
||||
acquired.release(conn, created);
|
||||
}
|
||||
|
||||
#[actix_rt::test]
|
||||
|
|
|
|||
|
|
@ -996,14 +996,15 @@ mod tests {
|
|||
use std::str;
|
||||
|
||||
use actix_service::fn_service;
|
||||
use futures_util::future::{lazy, ready};
|
||||
use futures_util::future::{lazy, ready, Ready};
|
||||
|
||||
use super::*;
|
||||
use crate::test::TestBuffer;
|
||||
use crate::{error::Error, KeepAlive};
|
||||
use crate::{
|
||||
error::Error,
|
||||
h1::{ExpectHandler, UpgradeHandler},
|
||||
test::TestSeqBuffer,
|
||||
http::Method,
|
||||
test::{TestBuffer, TestSeqBuffer},
|
||||
HttpMessage, KeepAlive,
|
||||
};
|
||||
|
||||
fn find_slice(haystack: &[u8], needle: &[u8], from: usize) -> Option<usize> {
|
||||
|
|
@ -1327,14 +1328,30 @@ mod tests {
|
|||
|
||||
#[actix_rt::test]
|
||||
async fn test_upgrade() {
|
||||
struct TestUpgrade;
|
||||
|
||||
impl<T> Service<(Request, Framed<T, Codec>)> for TestUpgrade {
|
||||
type Response = ();
|
||||
type Error = Error;
|
||||
type Future = Ready<Result<Self::Response, Self::Error>>;
|
||||
|
||||
actix_service::always_ready!();
|
||||
|
||||
fn call(&self, (req, _framed): (Request, Framed<T, Codec>)) -> Self::Future {
|
||||
assert_eq!(req.method(), Method::GET);
|
||||
assert!(req.upgrade());
|
||||
assert_eq!(req.headers().get("upgrade").unwrap(), "websocket");
|
||||
ready(Ok(()))
|
||||
}
|
||||
}
|
||||
|
||||
lazy(|cx| {
|
||||
let mut buf = TestSeqBuffer::empty();
|
||||
let cfg = ServiceConfig::new(KeepAlive::Disabled, 0, 0, false, None);
|
||||
|
||||
let services =
|
||||
HttpFlow::new(ok_service(), ExpectHandler, Some(UpgradeHandler));
|
||||
let services = HttpFlow::new(ok_service(), ExpectHandler, Some(TestUpgrade));
|
||||
|
||||
let h1 = Dispatcher::<_, _, _, _, UpgradeHandler>::new(
|
||||
let h1 = Dispatcher::<_, _, _, _, TestUpgrade>::new(
|
||||
buf.clone(),
|
||||
cfg,
|
||||
services,
|
||||
|
|
|
|||
|
|
@ -632,10 +632,9 @@ mod tests {
|
|||
|
||||
let mut res: Response<()> =
|
||||
Response::new(StatusCode::SWITCHING_PROTOCOLS).into_body::<()>();
|
||||
res.headers_mut().insert(DATE, HeaderValue::from_static(""));
|
||||
res.headers_mut()
|
||||
.insert(DATE, HeaderValue::from_static(&""));
|
||||
res.headers_mut()
|
||||
.insert(CONTENT_LENGTH, HeaderValue::from_static(&"0"));
|
||||
.insert(CONTENT_LENGTH, HeaderValue::from_static("0"));
|
||||
|
||||
let _ = res.encode_headers(
|
||||
&mut bytes,
|
||||
|
|
|
|||
|
|
@ -1,5 +1,3 @@
|
|||
use std::task::Poll;
|
||||
|
||||
use actix_service::{Service, ServiceFactory};
|
||||
use futures_util::future::{ready, Ready};
|
||||
|
||||
|
|
|
|||
|
|
@ -3,9 +3,8 @@ use std::cell::RefCell;
|
|||
use std::collections::VecDeque;
|
||||
use std::pin::Pin;
|
||||
use std::rc::{Rc, Weak};
|
||||
use std::task::{Context, Poll};
|
||||
use std::task::{Context, Poll, Waker};
|
||||
|
||||
use actix_utils::task::LocalWaker;
|
||||
use bytes::Bytes;
|
||||
use futures_core::Stream;
|
||||
|
||||
|
|
@ -134,7 +133,7 @@ impl PayloadSender {
|
|||
if shared.borrow().need_read {
|
||||
PayloadStatus::Read
|
||||
} else {
|
||||
shared.borrow_mut().io_task.register(cx.waker());
|
||||
shared.borrow_mut().register_io(cx);
|
||||
PayloadStatus::Pause
|
||||
}
|
||||
} else {
|
||||
|
|
@ -150,8 +149,8 @@ struct Inner {
|
|||
err: Option<PayloadError>,
|
||||
need_read: bool,
|
||||
items: VecDeque<Bytes>,
|
||||
task: LocalWaker,
|
||||
io_task: LocalWaker,
|
||||
task: Option<Waker>,
|
||||
io_task: Option<Waker>,
|
||||
}
|
||||
|
||||
impl Inner {
|
||||
|
|
@ -162,8 +161,48 @@ impl Inner {
|
|||
err: None,
|
||||
items: VecDeque::new(),
|
||||
need_read: true,
|
||||
task: LocalWaker::new(),
|
||||
io_task: LocalWaker::new(),
|
||||
task: None,
|
||||
io_task: None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Wake up future waiting for payload data to be available.
|
||||
fn wake(&mut self) {
|
||||
if let Some(waker) = self.task.take() {
|
||||
waker.wake();
|
||||
}
|
||||
}
|
||||
|
||||
/// Wake up future feeding data to Payload.
|
||||
fn wake_io(&mut self) {
|
||||
if let Some(waker) = self.io_task.take() {
|
||||
waker.wake();
|
||||
}
|
||||
}
|
||||
|
||||
/// Register future waiting data from payload.
|
||||
/// Waker would be used in `Inner::wake`
|
||||
fn register(&mut self, cx: &mut Context<'_>) {
|
||||
if self
|
||||
.task
|
||||
.as_ref()
|
||||
.map(|w| !cx.waker().will_wake(w))
|
||||
.unwrap_or(true)
|
||||
{
|
||||
self.task = Some(cx.waker().clone());
|
||||
}
|
||||
}
|
||||
|
||||
// Register future feeding data to payload.
|
||||
/// Waker would be used in `Inner::wake_io`
|
||||
fn register_io(&mut self, cx: &mut Context<'_>) {
|
||||
if self
|
||||
.io_task
|
||||
.as_ref()
|
||||
.map(|w| !cx.waker().will_wake(w))
|
||||
.unwrap_or(true)
|
||||
{
|
||||
self.io_task = Some(cx.waker().clone());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -182,7 +221,7 @@ impl Inner {
|
|||
self.len += data.len();
|
||||
self.items.push_back(data);
|
||||
self.need_read = self.len < MAX_BUFFER_SIZE;
|
||||
self.task.wake();
|
||||
self.wake();
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
|
@ -199,9 +238,9 @@ impl Inner {
|
|||
self.need_read = self.len < MAX_BUFFER_SIZE;
|
||||
|
||||
if self.need_read && !self.eof {
|
||||
self.task.register(cx.waker());
|
||||
self.register(cx);
|
||||
}
|
||||
self.io_task.wake();
|
||||
self.wake_io();
|
||||
Poll::Ready(Some(Ok(data)))
|
||||
} else if let Some(err) = self.err.take() {
|
||||
Poll::Ready(Some(Err(err)))
|
||||
|
|
@ -209,8 +248,8 @@ impl Inner {
|
|||
Poll::Ready(None)
|
||||
} else {
|
||||
self.need_read = true;
|
||||
self.task.register(cx.waker());
|
||||
self.io_task.wake();
|
||||
self.register(cx);
|
||||
self.wake_io();
|
||||
Poll::Pending
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,8 +1,6 @@
|
|||
use std::task::Poll;
|
||||
|
||||
use actix_codec::Framed;
|
||||
use actix_service::{Service, ServiceFactory};
|
||||
use futures_util::future::{ready, Ready};
|
||||
use futures_core::future::LocalBoxFuture;
|
||||
|
||||
use crate::error::Error;
|
||||
use crate::h1::Codec;
|
||||
|
|
@ -16,7 +14,7 @@ impl<T> ServiceFactory<(Request, Framed<T, Codec>)> for UpgradeHandler {
|
|||
type Config = ();
|
||||
type Service = UpgradeHandler;
|
||||
type InitError = Error;
|
||||
type Future = Ready<Result<Self::Service, Self::InitError>>;
|
||||
type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
|
||||
|
||||
fn new_service(&self, _: ()) -> Self::Future {
|
||||
unimplemented!()
|
||||
|
|
@ -26,11 +24,11 @@ impl<T> ServiceFactory<(Request, Framed<T, Codec>)> for UpgradeHandler {
|
|||
impl<T> Service<(Request, Framed<T, Codec>)> for UpgradeHandler {
|
||||
type Response = ();
|
||||
type Error = Error;
|
||||
type Future = Ready<Result<Self::Response, Self::Error>>;
|
||||
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
|
||||
|
||||
actix_service::always_ready!();
|
||||
|
||||
fn call(&self, _: (Request, Framed<T, Codec>)) -> Self::Future {
|
||||
ready(Ok(()))
|
||||
unimplemented!()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,13 +1,7 @@
|
|||
use std::future::Future;
|
||||
use std::marker::PhantomData;
|
||||
use std::net;
|
||||
use std::pin::Pin;
|
||||
use std::rc::Rc;
|
||||
use std::task::{Context, Poll};
|
||||
use std::{cmp, convert::TryFrom};
|
||||
use std::{cmp, future::Future, marker::PhantomData, net, pin::Pin, rc::Rc};
|
||||
|
||||
use actix_codec::{AsyncRead, AsyncWrite};
|
||||
use actix_rt::time::{Instant, Sleep};
|
||||
use actix_service::Service;
|
||||
use bytes::{Bytes, BytesMut};
|
||||
use futures_core::ready;
|
||||
|
|
@ -41,8 +35,6 @@ where
|
|||
on_connect_data: OnConnectData,
|
||||
config: ServiceConfig,
|
||||
peer_addr: Option<net::SocketAddr>,
|
||||
ka_expire: Instant,
|
||||
ka_timer: Option<Sleep>,
|
||||
_phantom: PhantomData<B>,
|
||||
}
|
||||
|
||||
|
|
@ -59,33 +51,14 @@ where
|
|||
connection: Connection<T, Bytes>,
|
||||
on_connect_data: OnConnectData,
|
||||
config: ServiceConfig,
|
||||
timeout: Option<Sleep>,
|
||||
peer_addr: Option<net::SocketAddr>,
|
||||
) -> Self {
|
||||
// let keepalive = config.keep_alive_enabled();
|
||||
// let flags = if keepalive {
|
||||
// Flags::KEEPALIVE | Flags::KEEPALIVE_ENABLED
|
||||
// } else {
|
||||
// Flags::empty()
|
||||
// };
|
||||
|
||||
// keep-alive timer
|
||||
let (ka_expire, ka_timer) = if let Some(delay) = timeout {
|
||||
(delay.deadline(), Some(delay))
|
||||
} else if let Some(delay) = config.keep_alive_timer() {
|
||||
(delay.deadline(), Some(delay))
|
||||
} else {
|
||||
(config.now(), None)
|
||||
};
|
||||
|
||||
Dispatcher {
|
||||
flow,
|
||||
config,
|
||||
peer_addr,
|
||||
connection,
|
||||
on_connect_data,
|
||||
ka_expire,
|
||||
ka_timer,
|
||||
_phantom: PhantomData,
|
||||
}
|
||||
}
|
||||
|
|
@ -113,19 +86,12 @@ where
|
|||
Some(Err(err)) => return Poll::Ready(Err(err.into())),
|
||||
|
||||
Some(Ok((req, res))) => {
|
||||
// update keep-alive expire
|
||||
if this.ka_timer.is_some() {
|
||||
if let Some(expire) = this.config.keep_alive_expire() {
|
||||
this.ka_expire = expire;
|
||||
}
|
||||
}
|
||||
|
||||
let (parts, body) = req.into_parts();
|
||||
let pl = crate::h2::Payload::new(body);
|
||||
let pl = Payload::<crate::payload::PayloadStream>::H2(pl);
|
||||
let mut req = Request::with_payload(pl);
|
||||
|
||||
let head = &mut req.head_mut();
|
||||
let head = req.head_mut();
|
||||
head.uri = parts.uri;
|
||||
head.method = parts.method;
|
||||
head.version = parts.version;
|
||||
|
|
@ -135,7 +101,7 @@ where
|
|||
// merge on_connect_ext data into request extensions
|
||||
this.on_connect_data.merge_into(&mut req);
|
||||
|
||||
let svc = ServiceResponse::<S::Future, S::Response, S::Error, B> {
|
||||
let svc = ServiceResponse {
|
||||
state: ServiceResponseState::ServiceCall(
|
||||
this.flow.service.call(req),
|
||||
Some(res),
|
||||
|
|
@ -203,16 +169,22 @@ where
|
|||
BodySize::Empty => res
|
||||
.headers_mut()
|
||||
.insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
|
||||
BodySize::Sized(len) => res.headers_mut().insert(
|
||||
BodySize::Sized(len) => {
|
||||
let mut buf = itoa::Buffer::new();
|
||||
|
||||
res.headers_mut().insert(
|
||||
CONTENT_LENGTH,
|
||||
HeaderValue::try_from(format!("{}", len)).unwrap(),
|
||||
),
|
||||
HeaderValue::from_str(buf.format(*len)).unwrap(),
|
||||
)
|
||||
}
|
||||
};
|
||||
|
||||
// copy headers
|
||||
for (key, value) in head.headers.iter() {
|
||||
match *key {
|
||||
// omit HTTP/1 only headers
|
||||
// TODO: consider skipping other headers according to:
|
||||
// https://tools.ietf.org/html/rfc7540#section-8.1.2.2
|
||||
// omit HTTP/1.x only headers
|
||||
CONNECTION | TRANSFER_ENCODING => continue,
|
||||
CONTENT_LENGTH if skip_len => continue,
|
||||
DATE => has_date = true,
|
||||
|
|
@ -310,11 +282,9 @@ where
|
|||
}
|
||||
|
||||
ServiceResponseStateProj::SendPayload(ref mut stream, ref mut body) => {
|
||||
loop {
|
||||
loop {
|
||||
match this.buffer {
|
||||
Some(ref mut buffer) => {
|
||||
match ready!(stream.poll_capacity(cx)) {
|
||||
Some(ref mut buffer) => match ready!(stream.poll_capacity(cx)) {
|
||||
None => return Poll::Ready(()),
|
||||
|
||||
Some(Ok(cap)) => {
|
||||
|
|
@ -336,23 +306,19 @@ where
|
|||
warn!("{:?}", e);
|
||||
return Poll::Ready(());
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
None => match ready!(body.as_mut().poll_next(cx)) {
|
||||
None => {
|
||||
if let Err(e) = stream.send_data(Bytes::new(), true)
|
||||
{
|
||||
if let Err(e) = stream.send_data(Bytes::new(), true) {
|
||||
warn!("{:?}", e);
|
||||
}
|
||||
return Poll::Ready(());
|
||||
}
|
||||
|
||||
Some(Ok(chunk)) => {
|
||||
stream.reserve_capacity(cmp::min(
|
||||
chunk.len(),
|
||||
CHUNK_SIZE,
|
||||
));
|
||||
stream
|
||||
.reserve_capacity(cmp::min(chunk.len(), CHUNK_SIZE));
|
||||
*this.buffer = Some(chunk);
|
||||
}
|
||||
|
||||
|
|
@ -367,4 +333,3 @@ where
|
|||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -368,7 +368,6 @@ where
|
|||
conn,
|
||||
on_connect_data,
|
||||
config.take().unwrap(),
|
||||
None,
|
||||
*peer_addr,
|
||||
));
|
||||
self.poll(cx)
|
||||
|
|
|
|||
|
|
@ -1,15 +1,15 @@
|
|||
use std::io;
|
||||
|
||||
use bytes::{BufMut, BytesMut};
|
||||
use bytes::BufMut;
|
||||
use http::Version;
|
||||
|
||||
const DIGITS_START: u8 = b'0';
|
||||
|
||||
pub(crate) fn write_status_line(version: Version, n: u16, bytes: &mut BytesMut) {
|
||||
pub(crate) fn write_status_line<B: BufMut>(version: Version, n: u16, buf: &mut B) {
|
||||
match version {
|
||||
Version::HTTP_11 => bytes.put_slice(b"HTTP/1.1 "),
|
||||
Version::HTTP_10 => bytes.put_slice(b"HTTP/1.0 "),
|
||||
Version::HTTP_09 => bytes.put_slice(b"HTTP/0.9 "),
|
||||
Version::HTTP_11 => buf.put_slice(b"HTTP/1.1 "),
|
||||
Version::HTTP_10 => buf.put_slice(b"HTTP/1.0 "),
|
||||
Version::HTTP_09 => buf.put_slice(b"HTTP/0.9 "),
|
||||
_ => {
|
||||
// other HTTP version handlers do not use this method
|
||||
}
|
||||
|
|
@ -19,33 +19,36 @@ pub(crate) fn write_status_line(version: Version, n: u16, bytes: &mut BytesMut)
|
|||
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);
|
||||
buf.put_u8(DIGITS_START + d100);
|
||||
buf.put_u8(DIGITS_START + d10);
|
||||
buf.put_u8(DIGITS_START + d1);
|
||||
|
||||
// trailing space before reason
|
||||
bytes.put_u8(b' ');
|
||||
buf.put_u8(b' ');
|
||||
}
|
||||
|
||||
/// NOTE: bytes object has to contain enough space
|
||||
pub fn write_content_length(n: u64, bytes: &mut BytesMut) {
|
||||
pub fn write_content_length<B: BufMut>(n: u64, buf: &mut B) {
|
||||
if n == 0 {
|
||||
bytes.put_slice(b"\r\ncontent-length: 0\r\n");
|
||||
buf.put_slice(b"\r\ncontent-length: 0\r\n");
|
||||
return;
|
||||
}
|
||||
|
||||
let mut buf = itoa::Buffer::new();
|
||||
let mut buffer = itoa::Buffer::new();
|
||||
|
||||
bytes.put_slice(b"\r\ncontent-length: ");
|
||||
bytes.put_slice(buf.format(n).as_bytes());
|
||||
bytes.put_slice(b"\r\n");
|
||||
buf.put_slice(b"\r\ncontent-length: ");
|
||||
buf.put_slice(buffer.format(n).as_bytes());
|
||||
buf.put_slice(b"\r\n");
|
||||
}
|
||||
|
||||
pub(crate) struct Writer<'a>(pub &'a mut BytesMut);
|
||||
pub(crate) struct Writer<'a, B>(pub &'a mut B);
|
||||
|
||||
impl<'a> io::Write for Writer<'a> {
|
||||
impl<'a, B> io::Write for Writer<'a, B>
|
||||
where
|
||||
B: BufMut,
|
||||
{
|
||||
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||
self.0.extend_from_slice(buf);
|
||||
self.0.put_slice(buf);
|
||||
Ok(buf.len())
|
||||
}
|
||||
|
||||
|
|
@ -58,6 +61,8 @@ impl<'a> io::Write for Writer<'a> {
|
|||
mod tests {
|
||||
use std::str::from_utf8;
|
||||
|
||||
use bytes::BytesMut;
|
||||
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -5,7 +5,6 @@ use std::{
|
|||
convert::TryInto,
|
||||
fmt,
|
||||
future::Future,
|
||||
ops,
|
||||
pin::Pin,
|
||||
str,
|
||||
task::{Context, Poll},
|
||||
|
|
@ -498,7 +497,8 @@ impl ResponseBuilder {
|
|||
/// Disable chunked transfer encoding for HTTP/1.1 streaming responses.
|
||||
#[inline]
|
||||
pub fn no_chunking(&mut self, len: u64) -> &mut Self {
|
||||
self.insert_header((header::CONTENT_LENGTH, len));
|
||||
let mut buf = itoa::Buffer::new();
|
||||
self.insert_header((header::CONTENT_LENGTH, buf.format(len)));
|
||||
|
||||
if let Some(parts) = parts(&mut self.head, &self.err) {
|
||||
parts.no_chunking(true);
|
||||
|
|
@ -672,12 +672,8 @@ impl ResponseBuilder {
|
|||
/// Set a json body and generate `Response`
|
||||
///
|
||||
/// `ResponseBuilder` can not be used after this call.
|
||||
pub fn json<T>(&mut self, value: T) -> Response
|
||||
where
|
||||
T: ops::Deref,
|
||||
T::Target: Serialize,
|
||||
{
|
||||
match serde_json::to_string(&*value) {
|
||||
pub fn json(&mut self, value: impl Serialize) -> Response {
|
||||
match serde_json::to_string(&value) {
|
||||
Ok(body) => {
|
||||
let contains = if let Some(parts) = parts(&mut self.head, &self.err) {
|
||||
parts.headers.contains_key(header::CONTENT_TYPE)
|
||||
|
|
@ -1006,7 +1002,12 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn test_json() {
|
||||
let resp = Response::build(StatusCode::OK).json(vec!["v1", "v2", "v3"]);
|
||||
let resp = Response::Ok().json(vec!["v1", "v2", "v3"]);
|
||||
let ct = resp.headers().get(CONTENT_TYPE).unwrap();
|
||||
assert_eq!(ct, HeaderValue::from_static("application/json"));
|
||||
assert_eq!(resp.body().get_ref(), b"[\"v1\",\"v2\",\"v3\"]");
|
||||
|
||||
let resp = Response::Ok().json(&["v1", "v2", "v3"]);
|
||||
let ct = resp.headers().get(CONTENT_TYPE).unwrap();
|
||||
assert_eq!(ct, HeaderValue::from_static("application/json"));
|
||||
assert_eq!(resp.body().get_ref(), b"[\"v1\",\"v2\",\"v3\"]");
|
||||
|
|
|
|||
|
|
@ -658,7 +658,6 @@ where
|
|||
conn,
|
||||
on_connect_data,
|
||||
cfg,
|
||||
None,
|
||||
peer_addr,
|
||||
)));
|
||||
self.poll(cx)
|
||||
|
|
|
|||
|
|
@ -80,7 +80,7 @@ bitflags! {
|
|||
|
||||
impl Codec {
|
||||
/// Create new WebSocket frames decoder.
|
||||
pub fn new() -> Codec {
|
||||
pub const fn new() -> Codec {
|
||||
Codec {
|
||||
max_size: 65_536,
|
||||
flags: Flags::SERVER,
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
//! WebSocket protocol.
|
||||
//! WebSocket protocol implementation.
|
||||
//!
|
||||
//! To setup a WebSocket, first perform the WebSocket handshake then on success convert `Payload` into a
|
||||
//! `WsStream` stream and then use `WsWriter` to communicate with the peer.
|
||||
|
|
@ -8,9 +8,12 @@ use std::io;
|
|||
use derive_more::{Display, Error, From};
|
||||
use http::{header, Method, StatusCode};
|
||||
|
||||
use crate::error::ResponseError;
|
||||
use crate::message::RequestHead;
|
||||
use crate::response::{Response, ResponseBuilder};
|
||||
use crate::{
|
||||
error::ResponseError,
|
||||
header::HeaderValue,
|
||||
message::RequestHead,
|
||||
response::{Response, ResponseBuilder},
|
||||
};
|
||||
|
||||
mod codec;
|
||||
mod dispatcher;
|
||||
|
|
@ -89,7 +92,7 @@ pub enum HandshakeError {
|
|||
NoVersionHeader,
|
||||
|
||||
/// Unsupported WebSocket version.
|
||||
#[display(fmt = "Unsupported version.")]
|
||||
#[display(fmt = "Unsupported WebSocket version.")]
|
||||
UnsupportedVersion,
|
||||
|
||||
/// WebSocket key is not set or wrong.
|
||||
|
|
@ -105,19 +108,19 @@ impl ResponseError for HandshakeError {
|
|||
.finish(),
|
||||
|
||||
HandshakeError::NoWebsocketUpgrade => Response::BadRequest()
|
||||
.reason("No WebSocket UPGRADE header found")
|
||||
.reason("No WebSocket Upgrade header found")
|
||||
.finish(),
|
||||
|
||||
HandshakeError::NoConnectionUpgrade => Response::BadRequest()
|
||||
.reason("No CONNECTION upgrade")
|
||||
.reason("No Connection upgrade")
|
||||
.finish(),
|
||||
|
||||
HandshakeError::NoVersionHeader => Response::BadRequest()
|
||||
.reason("Websocket version header is required")
|
||||
.reason("WebSocket version header is required")
|
||||
.finish(),
|
||||
|
||||
HandshakeError::UnsupportedVersion => Response::BadRequest()
|
||||
.reason("Unsupported version")
|
||||
.reason("Unsupported WebSocket version")
|
||||
.finish(),
|
||||
|
||||
HandshakeError::BadWebsocketKey => {
|
||||
|
|
@ -193,7 +196,11 @@ pub fn handshake_response(req: &RequestHead) -> ResponseBuilder {
|
|||
Response::build(StatusCode::SWITCHING_PROTOCOLS)
|
||||
.upgrade("websocket")
|
||||
.insert_header((header::TRANSFER_ENCODING, "chunked"))
|
||||
.insert_header((header::SEC_WEBSOCKET_ACCEPT, key))
|
||||
.insert_header((
|
||||
header::SEC_WEBSOCKET_ACCEPT,
|
||||
// key is known to be header value safe ascii
|
||||
HeaderValue::from_bytes(&key).unwrap(),
|
||||
))
|
||||
.take()
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,7 @@
|
|||
use std::convert::{From, Into};
|
||||
use std::fmt;
|
||||
use std::{
|
||||
convert::{From, Into},
|
||||
fmt,
|
||||
};
|
||||
|
||||
/// Operation codes as part of RFC6455.
|
||||
#[derive(Debug, Eq, PartialEq, Clone, Copy)]
|
||||
|
|
@ -28,8 +30,9 @@ pub enum OpCode {
|
|||
|
||||
impl fmt::Display for OpCode {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
use self::OpCode::*;
|
||||
match *self {
|
||||
use OpCode::*;
|
||||
|
||||
match self {
|
||||
Continue => write!(f, "CONTINUE"),
|
||||
Text => write!(f, "TEXT"),
|
||||
Binary => write!(f, "BINARY"),
|
||||
|
|
@ -44,6 +47,7 @@ impl fmt::Display for OpCode {
|
|||
impl From<OpCode> for u8 {
|
||||
fn from(op: OpCode) -> u8 {
|
||||
use self::OpCode::*;
|
||||
|
||||
match op {
|
||||
Continue => 0,
|
||||
Text => 1,
|
||||
|
|
@ -62,6 +66,7 @@ impl From<OpCode> for u8 {
|
|||
impl From<u8> for OpCode {
|
||||
fn from(byte: u8) -> OpCode {
|
||||
use self::OpCode::*;
|
||||
|
||||
match byte {
|
||||
0 => Continue,
|
||||
1 => Text,
|
||||
|
|
@ -77,63 +82,66 @@ impl From<u8> for OpCode {
|
|||
/// Status code used to indicate why an endpoint is closing the WebSocket connection.
|
||||
#[derive(Debug, Eq, PartialEq, Clone, Copy)]
|
||||
pub enum CloseCode {
|
||||
/// Indicates a normal closure, meaning that the purpose for
|
||||
/// which the connection was established has been fulfilled.
|
||||
/// Indicates a normal closure, meaning that the purpose for which the connection was
|
||||
/// established has been fulfilled.
|
||||
Normal,
|
||||
/// Indicates that an endpoint is "going away", such as a server
|
||||
/// going down or a browser having navigated away from a page.
|
||||
|
||||
/// Indicates that an endpoint is "going away", such as a server going down or a browser having
|
||||
/// navigated away from a page.
|
||||
Away,
|
||||
/// Indicates that an endpoint is terminating the connection due
|
||||
/// to a protocol error.
|
||||
|
||||
/// Indicates that an endpoint is terminating the connection due to a protocol error.
|
||||
Protocol,
|
||||
/// Indicates that an endpoint is terminating the connection
|
||||
/// because it has received a type of data it cannot accept (e.g., an
|
||||
/// endpoint that understands only text data MAY send this if it
|
||||
|
||||
/// Indicates that an endpoint is terminating the connection because it has received a type of
|
||||
/// data it cannot accept (e.g., an endpoint that understands only text data MAY send this if it
|
||||
/// receives a binary message).
|
||||
Unsupported,
|
||||
/// Indicates an abnormal closure. If the abnormal closure was due to an
|
||||
/// error, this close code will not be used. Instead, the `on_error` method
|
||||
/// of the handler will be called with the error. However, if the connection
|
||||
/// is simply dropped, without an error, this close code will be sent to the
|
||||
/// handler.
|
||||
|
||||
/// Indicates an abnormal closure. If the abnormal closure was due to an error, this close code
|
||||
/// will not be used. Instead, the `on_error` method of the handler will be called with
|
||||
/// the error. However, if the connection is simply dropped, without an error, this close code
|
||||
/// will be sent to the handler.
|
||||
Abnormal,
|
||||
/// Indicates that an endpoint is terminating the connection
|
||||
/// because it has received data within a message that was not
|
||||
/// consistent with the type of the message (e.g., non-UTF-8 \[RFC3629\]
|
||||
|
||||
/// Indicates that an endpoint is terminating the connection because it has received data within
|
||||
/// a message that was not consistent with the type of the message (e.g., non-UTF-8 \[RFC3629\]
|
||||
/// data within a text message).
|
||||
Invalid,
|
||||
/// Indicates that an endpoint is terminating the connection
|
||||
/// because it has received a message that violates its policy. This
|
||||
/// is a generic status code that can be returned when there is no
|
||||
/// other more suitable status code (e.g., Unsupported or Size) or if there
|
||||
/// is a need to hide specific details about the policy.
|
||||
|
||||
/// Indicates that an endpoint is terminating the connection because it has received a message
|
||||
/// that violates its policy. This is a generic status code that can be returned when there is
|
||||
/// no other more suitable status code (e.g., Unsupported or Size) or if there is a need to hide
|
||||
/// specific details about the policy.
|
||||
Policy,
|
||||
/// Indicates that an endpoint is terminating the connection
|
||||
/// because it has received a message that is too big for it to
|
||||
/// process.
|
||||
|
||||
/// Indicates that an endpoint is terminating the connection because it has received a message
|
||||
/// that is too big for it to process.
|
||||
Size,
|
||||
/// Indicates that an endpoint (client) is terminating the
|
||||
/// connection because it has expected the server to negotiate one or
|
||||
/// more extension, but the server didn't return them in the response
|
||||
/// message of the WebSocket handshake. The list of extensions that
|
||||
/// are needed should be given as the reason for closing.
|
||||
/// Note that this status code is not used by the server, because it
|
||||
/// can fail the WebSocket handshake instead.
|
||||
|
||||
/// Indicates that an endpoint (client) is terminating the connection because it has expected
|
||||
/// the server to negotiate one or more extension, but the server didn't return them in the
|
||||
/// response message of the WebSocket handshake. The list of extensions that are needed should
|
||||
/// be given as the reason for closing. Note that this status code is not used by the server,
|
||||
/// because it can fail the WebSocket handshake instead.
|
||||
Extension,
|
||||
/// Indicates that a server is terminating the connection because
|
||||
/// it encountered an unexpected condition that prevented it from
|
||||
/// fulfilling the request.
|
||||
|
||||
/// Indicates that a server is terminating the connection because it encountered an unexpected
|
||||
/// condition that prevented it from fulfilling the request.
|
||||
Error,
|
||||
/// Indicates that the server is restarting. A client may choose to
|
||||
/// reconnect, and if it does, it should use a randomized delay of 5-30
|
||||
/// seconds between attempts.
|
||||
|
||||
/// Indicates that the server is restarting. A client may choose to reconnect, and if it does,
|
||||
/// it should use a randomized delay of 5-30 seconds between attempts.
|
||||
Restart,
|
||||
/// Indicates that the server is overloaded and the client should either
|
||||
/// connect to a different IP (when multiple targets exist), or
|
||||
/// reconnect to the same IP when a user has performed an action.
|
||||
|
||||
/// Indicates that the server is overloaded and the client should either connect to a different
|
||||
/// IP (when multiple targets exist), or reconnect to the same IP when a user has performed
|
||||
/// an action.
|
||||
Again,
|
||||
|
||||
#[doc(hidden)]
|
||||
Tls,
|
||||
|
||||
#[doc(hidden)]
|
||||
Other(u16),
|
||||
}
|
||||
|
|
@ -141,6 +149,7 @@ pub enum CloseCode {
|
|||
impl From<CloseCode> for u16 {
|
||||
fn from(code: CloseCode) -> u16 {
|
||||
use self::CloseCode::*;
|
||||
|
||||
match code {
|
||||
Normal => 1000,
|
||||
Away => 1001,
|
||||
|
|
@ -163,6 +172,7 @@ impl From<CloseCode> for u16 {
|
|||
impl From<u16> for CloseCode {
|
||||
fn from(code: u16) -> CloseCode {
|
||||
use self::CloseCode::*;
|
||||
|
||||
match code {
|
||||
1000 => Normal,
|
||||
1001 => Away,
|
||||
|
|
@ -210,17 +220,29 @@ impl<T: Into<String>> From<(CloseCode, T)> for CloseReason {
|
|||
}
|
||||
}
|
||||
|
||||
static WS_GUID: &str = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
|
||||
/// The WebSocket GUID as stated in the spec. See https://tools.ietf.org/html/rfc6455#section-1.3.
|
||||
static WS_GUID: &[u8] = b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
|
||||
|
||||
/// Hashes the `Sec-WebSocket-Key` header according to the WebSocket spec.
|
||||
///
|
||||
/// Result is a Base64 encoded byte array. `base64(sha1(input))` is always 28 bytes.
|
||||
pub fn hash_key(key: &[u8]) -> [u8; 28] {
|
||||
let hash = {
|
||||
use sha1::Digest as _;
|
||||
|
||||
// TODO: hash is always same size, we don't need String
|
||||
pub fn hash_key(key: &[u8]) -> String {
|
||||
use sha1::Digest;
|
||||
let mut hasher = sha1::Sha1::new();
|
||||
|
||||
hasher.update(key);
|
||||
hasher.update(WS_GUID.as_bytes());
|
||||
hasher.update(WS_GUID);
|
||||
|
||||
base64::encode(&hasher.finalize())
|
||||
hasher.finalize()
|
||||
};
|
||||
|
||||
let mut hash_b64 = [0; 28];
|
||||
let n = base64::encode_config_slice(&hash, base64::STANDARD, &mut hash_b64);
|
||||
assert_eq!(n, 28);
|
||||
|
||||
hash_b64
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
|
@ -288,11 +310,11 @@ mod test {
|
|||
#[test]
|
||||
fn test_hash_key() {
|
||||
let hash = hash_key(b"hello actix-web");
|
||||
assert_eq!(&hash, "cR1dlyUUJKp0s/Bel25u5TgvC3E=");
|
||||
assert_eq!(&hash, b"cR1dlyUUJKp0s/Bel25u5TgvC3E=");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn closecode_from_u16() {
|
||||
fn close_code_from_u16() {
|
||||
assert_eq!(CloseCode::from(1000u16), CloseCode::Normal);
|
||||
assert_eq!(CloseCode::from(1001u16), CloseCode::Away);
|
||||
assert_eq!(CloseCode::from(1002u16), CloseCode::Protocol);
|
||||
|
|
@ -310,7 +332,7 @@ mod test {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn closecode_into_u16() {
|
||||
fn close_code_into_u16() {
|
||||
assert_eq!(1000u16, Into::<u16>::into(CloseCode::Normal));
|
||||
assert_eq!(1001u16, Into::<u16>::into(CloseCode::Away));
|
||||
assert_eq!(1002u16, Into::<u16>::into(CloseCode::Protocol));
|
||||
|
|
|
|||
|
|
@ -1,8 +1,13 @@
|
|||
use actix_http::{http, HttpService, Request, Response};
|
||||
use actix_http::{
|
||||
error, http, http::StatusCode, HttpMessage, HttpService, Request, Response,
|
||||
};
|
||||
use actix_http_test::test_server;
|
||||
use actix_service::ServiceFactoryExt;
|
||||
use bytes::Bytes;
|
||||
use futures_util::future::{self, ok};
|
||||
use futures_util::{
|
||||
future::{self, ok},
|
||||
StreamExt,
|
||||
};
|
||||
|
||||
const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
|
||||
Hello World Hello World Hello World Hello World Hello World \
|
||||
|
|
@ -88,3 +93,55 @@ async fn test_with_query_parameter() {
|
|||
let response = request.send().await.unwrap();
|
||||
assert!(response.status().is_success());
|
||||
}
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn test_h1_expect() {
|
||||
let srv = test_server(move || {
|
||||
HttpService::build()
|
||||
.expect(|req: Request| async {
|
||||
if req.headers().contains_key("AUTH") {
|
||||
Ok(req)
|
||||
} else {
|
||||
Err(error::ErrorExpectationFailed("expect failed"))
|
||||
}
|
||||
})
|
||||
.h1(|req: Request| async move {
|
||||
let (_, mut body) = req.into_parts();
|
||||
let mut buf = Vec::new();
|
||||
while let Some(Ok(chunk)) = body.next().await {
|
||||
buf.extend_from_slice(&chunk);
|
||||
}
|
||||
let str = std::str::from_utf8(&buf).unwrap();
|
||||
assert_eq!(str, "expect body");
|
||||
|
||||
Ok::<_, ()>(Response::Ok().finish())
|
||||
})
|
||||
.tcp()
|
||||
})
|
||||
.await;
|
||||
|
||||
// test expect without payload.
|
||||
let request = srv
|
||||
.request(http::Method::GET, srv.url("/"))
|
||||
.insert_header(("Expect", "100-continue"));
|
||||
|
||||
let response = request.send().await;
|
||||
assert!(response.is_err());
|
||||
|
||||
// test expect would fail to continue
|
||||
let request = srv
|
||||
.request(http::Method::GET, srv.url("/"))
|
||||
.insert_header(("Expect", "100-continue"));
|
||||
|
||||
let response = request.send_body("expect body").await.unwrap();
|
||||
assert_eq!(response.status(), StatusCode::EXPECTATION_FAILED);
|
||||
|
||||
// test exepct would continue
|
||||
let request = srv
|
||||
.request(http::Method::GET, srv.url("/"))
|
||||
.insert_header(("Expect", "100-continue"))
|
||||
.insert_header(("AUTH", "996"));
|
||||
|
||||
let response = request.send_body("expect body").await.unwrap();
|
||||
assert!(response.status().is_success());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -123,16 +123,14 @@ async fn test_h2_content_length() {
|
|||
let srv = test_server(move || {
|
||||
HttpService::build()
|
||||
.h2(|req: Request| {
|
||||
let indx: usize = req.uri().path()[1..].parse().unwrap();
|
||||
let idx: usize = req.uri().path()[1..].parse().unwrap();
|
||||
let statuses = [
|
||||
StatusCode::NO_CONTENT,
|
||||
StatusCode::CONTINUE,
|
||||
StatusCode::SWITCHING_PROTOCOLS,
|
||||
StatusCode::PROCESSING,
|
||||
StatusCode::NO_CONTENT,
|
||||
StatusCode::OK,
|
||||
StatusCode::NOT_FOUND,
|
||||
];
|
||||
ok::<_, ()>(Response::new(statuses[indx]))
|
||||
ok::<_, ()>(Response::new(statuses[idx]))
|
||||
})
|
||||
.openssl(tls_config())
|
||||
.map_err(|_| ())
|
||||
|
|
@ -143,21 +141,29 @@ async fn test_h2_content_length() {
|
|||
let value = HeaderValue::from_static("0");
|
||||
|
||||
{
|
||||
for i in 0..4 {
|
||||
for &i in &[0] {
|
||||
let req = srv
|
||||
.request(Method::HEAD, srv.surl(&format!("/{}", i)))
|
||||
.send();
|
||||
let _response = req.await.expect_err("should timeout on recv 1xx frame");
|
||||
// assert_eq!(response.headers().get(&header), None);
|
||||
|
||||
let req = srv
|
||||
.request(Method::GET, srv.surl(&format!("/{}", i)))
|
||||
.send();
|
||||
let _response = req.await.expect_err("should timeout on recv 1xx frame");
|
||||
// assert_eq!(response.headers().get(&header), None);
|
||||
}
|
||||
|
||||
for &i in &[1] {
|
||||
let req = srv
|
||||
.request(Method::GET, srv.surl(&format!("/{}", i)))
|
||||
.send();
|
||||
let response = req.await.unwrap();
|
||||
assert_eq!(response.headers().get(&header), None);
|
||||
|
||||
let req = srv
|
||||
.request(Method::HEAD, srv.surl(&format!("/{}", i)))
|
||||
.send();
|
||||
let response = req.await.unwrap();
|
||||
assert_eq!(response.headers().get(&header), None);
|
||||
}
|
||||
|
||||
for i in 4..6 {
|
||||
for &i in &[2, 3] {
|
||||
let req = srv
|
||||
.request(Method::GET, srv.surl(&format!("/{}", i)))
|
||||
.send();
|
||||
|
|
|
|||
|
|
@ -17,7 +17,6 @@ use rustls::{
|
|||
NoClientAuth, ServerConfig as RustlsServerConfig,
|
||||
};
|
||||
|
||||
use std::fs::File;
|
||||
use std::io::{self, BufReader};
|
||||
|
||||
async fn load_body<S>(mut stream: S) -> Result<BytesMut, PayloadError>
|
||||
|
|
@ -139,10 +138,8 @@ async fn test_h2_content_length() {
|
|||
.h2(|req: Request| {
|
||||
let indx: usize = req.uri().path()[1..].parse().unwrap();
|
||||
let statuses = [
|
||||
StatusCode::NO_CONTENT,
|
||||
StatusCode::CONTINUE,
|
||||
StatusCode::SWITCHING_PROTOCOLS,
|
||||
StatusCode::PROCESSING,
|
||||
StatusCode::NO_CONTENT,
|
||||
StatusCode::OK,
|
||||
StatusCode::NOT_FOUND,
|
||||
];
|
||||
|
|
@ -154,22 +151,31 @@ async fn test_h2_content_length() {
|
|||
|
||||
let header = HeaderName::from_static("content-length");
|
||||
let value = HeaderValue::from_static("0");
|
||||
|
||||
{
|
||||
for i in 0..4 {
|
||||
for &i in &[0] {
|
||||
let req = srv
|
||||
.request(Method::HEAD, srv.surl(&format!("/{}", i)))
|
||||
.send();
|
||||
let _response = req.await.expect_err("should timeout on recv 1xx frame");
|
||||
// assert_eq!(response.headers().get(&header), None);
|
||||
|
||||
let req = srv
|
||||
.request(Method::GET, srv.surl(&format!("/{}", i)))
|
||||
.send();
|
||||
let _response = req.await.expect_err("should timeout on recv 1xx frame");
|
||||
// assert_eq!(response.headers().get(&header), None);
|
||||
}
|
||||
|
||||
for &i in &[1] {
|
||||
let req = srv
|
||||
.request(Method::GET, srv.surl(&format!("/{}", i)))
|
||||
.send();
|
||||
let response = req.await.unwrap();
|
||||
assert_eq!(response.headers().get(&header), None);
|
||||
|
||||
let req = srv
|
||||
.request(Method::HEAD, srv.surl(&format!("/{}", i)))
|
||||
.send();
|
||||
let response = req.await.unwrap();
|
||||
assert_eq!(response.headers().get(&header), None);
|
||||
}
|
||||
|
||||
for i in 4..6 {
|
||||
for &i in &[2, 3] {
|
||||
let req = srv
|
||||
.request(Method::GET, srv.surl(&format!("/{}", i)))
|
||||
.send();
|
||||
|
|
|
|||
|
|
@ -126,7 +126,7 @@ async fn test_chunked_payload() {
|
|||
.take_payload()
|
||||
.map(|res| match res {
|
||||
Ok(pl) => pl,
|
||||
Err(e) => panic!(format!("Error reading payload: {}", e)),
|
||||
Err(e) => panic!("Error reading payload: {}", e),
|
||||
})
|
||||
.fold(0usize, |acc, chunk| ready(acc + chunk.len()))
|
||||
.map(|req_size| {
|
||||
|
|
@ -162,7 +162,7 @@ async fn test_chunked_payload() {
|
|||
let re = Regex::new(r"size=(\d+)").unwrap();
|
||||
let size: usize = match re.captures(&data) {
|
||||
Some(caps) => caps.get(1).unwrap().as_str().parse().unwrap(),
|
||||
None => panic!(format!("Failed to find size in HTTP Response: {}", data)),
|
||||
None => panic!("Failed to find size in HTTP Response: {}", data),
|
||||
};
|
||||
size
|
||||
};
|
||||
|
|
|
|||
|
|
@ -3,6 +3,10 @@
|
|||
## Unreleased - 2021-xx-xx
|
||||
|
||||
|
||||
## 0.4.0-beta.3 - 2021-03-09
|
||||
* No notable changes.
|
||||
|
||||
|
||||
## 0.4.0-beta.2 - 2021-02-10
|
||||
* No notable changes.
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
[package]
|
||||
name = "actix-multipart"
|
||||
version = "0.4.0-beta.2"
|
||||
version = "0.4.0-beta.3"
|
||||
authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
|
||||
description = "Multipart form support for Actix Web"
|
||||
readme = "README.md"
|
||||
|
|
@ -16,7 +16,7 @@ name = "actix_multipart"
|
|||
path = "src/lib.rs"
|
||||
|
||||
[dependencies]
|
||||
actix-web = { version = "4.0.0-beta.3", default-features = false }
|
||||
actix-web = { version = "4.0.0-beta.4", default-features = false }
|
||||
actix-utils = "3.0.0-beta.2"
|
||||
|
||||
bytes = "1"
|
||||
|
|
@ -29,6 +29,6 @@ twoway = "0.2"
|
|||
|
||||
[dev-dependencies]
|
||||
actix-rt = "2.1"
|
||||
actix-http = "3.0.0-beta.3"
|
||||
actix-http = "3.0.0-beta.4"
|
||||
tokio = { version = "1", features = ["sync"] }
|
||||
tokio-stream = "0.1"
|
||||
|
|
|
|||
|
|
@ -3,13 +3,12 @@
|
|||
> Multipart form support for Actix Web.
|
||||
|
||||
[](https://crates.io/crates/actix-multipart)
|
||||
[](https://docs.rs/actix-multipart/0.4.0-beta.2)
|
||||
[](https://docs.rs/actix-multipart/0.4.0-beta.3)
|
||||
[](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
|
||||
|
||||
<br />
|
||||
[](https://deps.rs/crate/actix-multipart/0.4.0-beta.2)
|
||||
[](https://deps.rs/crate/actix-multipart/0.4.0-beta.3)
|
||||
[](https://crates.io/crates/actix-multipart)
|
||||
[](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
|
||||
|
||||
## Documentation & Resources
|
||||
|
||||
|
|
|
|||
|
|
@ -3,6 +3,10 @@
|
|||
## Unreleased - 2021-xx-xx
|
||||
|
||||
|
||||
## 4.0.0-beta.3 - 2021-03-09
|
||||
* No notable changes.
|
||||
|
||||
|
||||
## 4.0.0-beta.2 - 2021-02-10
|
||||
* No notable changes.
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
[package]
|
||||
name = "actix-web-actors"
|
||||
version = "4.0.0-beta.2"
|
||||
version = "4.0.0-beta.3"
|
||||
authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
|
||||
description = "Actix actors support for Actix Web"
|
||||
readme = "README.md"
|
||||
|
|
@ -16,10 +16,10 @@ name = "actix_web_actors"
|
|||
path = "src/lib.rs"
|
||||
|
||||
[dependencies]
|
||||
actix = { version = "0.11.0-beta.2", default-features = false }
|
||||
actix = { version = "0.11.0-beta.3", default-features = false }
|
||||
actix-codec = "0.4.0-beta.1"
|
||||
actix-http = "3.0.0-beta.3"
|
||||
actix-web = { version = "4.0.0-beta.3", default-features = false }
|
||||
actix-http = "3.0.0-beta.4"
|
||||
actix-web = { version = "4.0.0-beta.4", default-features = false }
|
||||
|
||||
bytes = "1"
|
||||
bytestring = "1"
|
||||
|
|
|
|||
|
|
@ -3,11 +3,11 @@
|
|||
> Actix actors support for Actix Web.
|
||||
|
||||
[](https://crates.io/crates/actix-web-actors)
|
||||
[](https://docs.rs/actix-web-actors/0.5.0)
|
||||
[](https://docs.rs/actix-web-actors/4.0.0-beta.3)
|
||||
[](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
|
||||
|
||||
<br />
|
||||
[](https://deps.rs/crate/actix-web-actors/0.5.0)
|
||||
[](https://deps.rs/crate/actix-web-actors/4.0.0-beta.3)
|
||||
[](https://crates.io/crates/actix-web-actors)
|
||||
[](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
|
||||
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ where
|
|||
#[inline]
|
||||
fn spawn<F>(&mut self, fut: F) -> SpawnHandle
|
||||
where
|
||||
F: ActorFuture<Output = (), Actor = A> + 'static,
|
||||
F: ActorFuture<A, Output = ()> + 'static,
|
||||
{
|
||||
self.inner.spawn(fut)
|
||||
}
|
||||
|
|
@ -52,7 +52,7 @@ where
|
|||
#[inline]
|
||||
fn wait<F>(&mut self, fut: F)
|
||||
where
|
||||
F: ActorFuture<Output = (), Actor = A> + 'static,
|
||||
F: ActorFuture<A, Output = ()> + 'static,
|
||||
{
|
||||
self.inner.wait(fut)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,10 +15,13 @@ use actix::{
|
|||
SpawnHandle,
|
||||
};
|
||||
use actix_codec::{Decoder, Encoder};
|
||||
use actix_http::ws::{hash_key, Codec};
|
||||
pub use actix_http::ws::{
|
||||
CloseCode, CloseReason, Frame, HandshakeError, Message, ProtocolError,
|
||||
};
|
||||
use actix_http::{
|
||||
http::HeaderValue,
|
||||
ws::{hash_key, Codec},
|
||||
};
|
||||
use actix_web::dev::HttpResponseBuilder;
|
||||
use actix_web::error::{Error, PayloadError};
|
||||
use actix_web::http::{header, Method, StatusCode};
|
||||
|
|
@ -162,7 +165,11 @@ pub fn handshake_with_protocols(
|
|||
|
||||
let mut response = HttpResponse::build(StatusCode::SWITCHING_PROTOCOLS)
|
||||
.upgrade("websocket")
|
||||
.insert_header((header::SEC_WEBSOCKET_ACCEPT, key))
|
||||
.insert_header((
|
||||
header::SEC_WEBSOCKET_ACCEPT,
|
||||
// key is known to be header value safe ascii
|
||||
HeaderValue::from_bytes(&key).unwrap(),
|
||||
))
|
||||
.take();
|
||||
|
||||
if let Some(protocol) = protocol {
|
||||
|
|
@ -204,14 +211,14 @@ where
|
|||
{
|
||||
fn spawn<F>(&mut self, fut: F) -> SpawnHandle
|
||||
where
|
||||
F: ActorFuture<Output = (), Actor = A> + 'static,
|
||||
F: ActorFuture<A, Output = ()> + 'static,
|
||||
{
|
||||
self.inner.spawn(fut)
|
||||
}
|
||||
|
||||
fn wait<F>(&mut self, fut: F)
|
||||
where
|
||||
F: ActorFuture<Output = (), Actor = A> + 'static,
|
||||
F: ActorFuture<A, Output = ()> + 'static,
|
||||
{
|
||||
self.inner.wait(fut)
|
||||
}
|
||||
|
|
@ -488,7 +495,6 @@ where
|
|||
|
||||
if !*this.closed {
|
||||
loop {
|
||||
this = self.as_mut().project();
|
||||
match Pin::new(&mut this.stream).poll_next(cx) {
|
||||
Poll::Ready(Some(Ok(chunk))) => {
|
||||
this.buf.extend_from_slice(&chunk[..]);
|
||||
|
|
|
|||
|
|
@ -1,9 +1,14 @@
|
|||
# Changes
|
||||
|
||||
## Unreleased - 2021-xx-xx
|
||||
|
||||
|
||||
## 0.5.0-beta.2 - 2021-03-09
|
||||
* Preserve doc comments when using route macros. [#2022]
|
||||
* Add `name` attribute to `route` macro. [#1934]
|
||||
|
||||
[#2022]: https://github.com/actix/actix-web/pull/2022
|
||||
[#1934]: https://github.com/actix/actix-web/pull/1934
|
||||
|
||||
|
||||
## 0.5.0-beta.1 - 2021-02-10
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
[package]
|
||||
name = "actix-web-codegen"
|
||||
version = "0.5.0-beta.1"
|
||||
version = "0.5.0-beta.2"
|
||||
description = "Routing and runtime macros for Actix Web"
|
||||
readme = "README.md"
|
||||
homepage = "https://actix.rs"
|
||||
|
|
@ -20,7 +20,7 @@ proc-macro2 = "1"
|
|||
|
||||
[dev-dependencies]
|
||||
actix-rt = "2.1"
|
||||
actix-web = "4.0.0-beta.3"
|
||||
actix-web = "4.0.0-beta.4"
|
||||
futures-util = { version = "0.3.7", default-features = false }
|
||||
trybuild = "1"
|
||||
rustversion = "1"
|
||||
|
|
|
|||
|
|
@ -3,11 +3,11 @@
|
|||
> Routing and runtime macros for Actix Web.
|
||||
|
||||
[](https://crates.io/crates/actix-web-codegen)
|
||||
[](https://docs.rs/actix-web-codegen/0.5.0-beta.1)
|
||||
[](https://docs.rs/actix-web-codegen/0.5.0-beta.2)
|
||||
[](https://blog.rust-lang.org/2020/03/12/Rust-1.46.html)
|
||||
|
||||
<br />
|
||||
[](https://deps.rs/crate/actix-web-codegen/0.5.0-beta.1)
|
||||
[](https://deps.rs/crate/actix-web-codegen/0.5.0-beta.2)
|
||||
[](https://crates.io/crates/actix-web-codegen)
|
||||
[](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
|
||||
|
||||
|
|
|
|||
|
|
@ -71,6 +71,7 @@ mod route;
|
|||
///
|
||||
/// # Attributes
|
||||
/// - `"path"` - Raw literal string with path for which to register handler.
|
||||
/// - `name="resource_name"` - Specifies resource name for the handler. If not set, the function name of handler is used.
|
||||
/// - `method="HTTP_METHOD"` - Registers HTTP method to provide guard for. Upper-case string, "GET", "POST" for example.
|
||||
/// - `guard="function_name"` - Registers function as guard using `actix_web::guard::fn_guard`
|
||||
/// - `wrap="Middleware"` - Registers a resource middleware.
|
||||
|
|
@ -116,6 +117,7 @@ Creates route handler with `actix_web::guard::", stringify!($variant), "`.
|
|||
|
||||
# Attributes
|
||||
- `"path"` - Raw literal string with path for which to register handler.
|
||||
- `name="resource_name"` - Specifies resource name for the handler. If not set, the function name of handler is used.
|
||||
- `guard="function_name"` - Registers function as guard using `actix_web::guard::fn_guard`.
|
||||
- `wrap="Middleware"` - Registers a resource middleware.
|
||||
|
||||
|
|
|
|||
|
|
@ -78,6 +78,7 @@ impl TryFrom<&syn::LitStr> for MethodType {
|
|||
|
||||
struct Args {
|
||||
path: syn::LitStr,
|
||||
resource_name: Option<syn::LitStr>,
|
||||
guards: Vec<Ident>,
|
||||
wrappers: Vec<syn::Type>,
|
||||
methods: HashSet<MethodType>,
|
||||
|
|
@ -86,6 +87,7 @@ struct Args {
|
|||
impl Args {
|
||||
fn new(args: AttributeArgs, method: Option<MethodType>) -> syn::Result<Self> {
|
||||
let mut path = None;
|
||||
let mut resource_name = None;
|
||||
let mut guards = Vec::new();
|
||||
let mut wrappers = Vec::new();
|
||||
let mut methods = HashSet::new();
|
||||
|
|
@ -109,7 +111,16 @@ impl Args {
|
|||
}
|
||||
},
|
||||
NestedMeta::Meta(syn::Meta::NameValue(nv)) => {
|
||||
if nv.path.is_ident("guard") {
|
||||
if nv.path.is_ident("name") {
|
||||
if let syn::Lit::Str(lit) = nv.lit {
|
||||
resource_name = Some(lit);
|
||||
} else {
|
||||
return Err(syn::Error::new_spanned(
|
||||
nv.lit,
|
||||
"Attribute name expects literal string!",
|
||||
));
|
||||
}
|
||||
} else if nv.path.is_ident("guard") {
|
||||
if let syn::Lit::Str(lit) = nv.lit {
|
||||
guards.push(Ident::new(&lit.value(), Span::call_site()));
|
||||
} else {
|
||||
|
|
@ -164,6 +175,7 @@ impl Args {
|
|||
}
|
||||
Ok(Args {
|
||||
path: path.unwrap(),
|
||||
resource_name,
|
||||
guards,
|
||||
wrappers,
|
||||
methods,
|
||||
|
|
@ -276,6 +288,7 @@ impl ToTokens for Route {
|
|||
args:
|
||||
Args {
|
||||
path,
|
||||
resource_name,
|
||||
guards,
|
||||
wrappers,
|
||||
methods,
|
||||
|
|
@ -283,7 +296,9 @@ impl ToTokens for Route {
|
|||
resource_type,
|
||||
doc_attributes,
|
||||
} = self;
|
||||
let resource_name = name.to_string();
|
||||
let resource_name = resource_name
|
||||
.as_ref()
|
||||
.map_or_else(|| name.to_string(), |n| n.value());
|
||||
let method_guards = {
|
||||
let mut others = methods.iter();
|
||||
// unwrapping since length is checked to be at least one
|
||||
|
|
|
|||
|
|
@ -83,6 +83,13 @@ async fn route_test() -> impl Responder {
|
|||
HttpResponse::Ok()
|
||||
}
|
||||
|
||||
#[get("/custom_resource_name", name = "custom")]
|
||||
async fn custom_resource_name_test<'a>(req: actix_web::HttpRequest) -> impl Responder {
|
||||
assert!(req.url_for_static("custom").is_ok());
|
||||
assert!(req.url_for_static("custom_resource_name_test").is_err());
|
||||
HttpResponse::Ok()
|
||||
}
|
||||
|
||||
pub struct ChangeStatusCode;
|
||||
|
||||
impl<S, B> Transform<S, ServiceRequest> for ChangeStatusCode
|
||||
|
|
@ -174,6 +181,7 @@ async fn test_body() {
|
|||
.service(patch_test)
|
||||
.service(test_handler)
|
||||
.service(route_test)
|
||||
.service(custom_resource_name_test)
|
||||
});
|
||||
let request = srv.request(http::Method::GET, srv.url("/test"));
|
||||
let response = request.send().await.unwrap();
|
||||
|
|
@ -228,6 +236,10 @@ async fn test_body() {
|
|||
let request = srv.request(http::Method::PATCH, srv.url("/multi"));
|
||||
let response = request.send().await.unwrap();
|
||||
assert!(!response.status().is_success());
|
||||
|
||||
let request = srv.request(http::Method::GET, srv.url("/custom_resource_name"));
|
||||
let response = request.send().await.unwrap();
|
||||
assert!(response.status().is_success());
|
||||
}
|
||||
|
||||
#[actix_rt::test]
|
||||
|
|
|
|||
|
|
@ -1,6 +1,9 @@
|
|||
# Changes
|
||||
|
||||
## Unreleased - 2021-xx-xx
|
||||
|
||||
|
||||
## 3.0.0-beta.3 - 2021-03-08
|
||||
### Added
|
||||
* `ClientResponse::timeout` for set the timeout of collecting response body. [#1931]
|
||||
* `ClientBuilder::local_address` for bind to a local ip address for this client. [#2024]
|
||||
|
|
@ -8,15 +11,17 @@
|
|||
### Changed
|
||||
* Feature `cookies` is now optional and enabled by default. [#1981]
|
||||
* `ClientBuilder::connector` method would take `actix_http::client::Connector<T, U>` type. [#2008]
|
||||
* Basic auth password now takes blank passwords as an empty string instead of Option. [#2050]
|
||||
|
||||
### Removed
|
||||
* `ClientBuilder::default` function [#2008]
|
||||
* `ClientBuilder::disable_redirects` and `ClientBuilder::max_redirects` method [#2008]
|
||||
|
||||
[#1931]: https://github.com/actix/actix-web/pull/1931
|
||||
[#1981]: https://github.com/actix/actix-web/pull/1981
|
||||
[#2008]: https://github.com/actix/actix-web/pull/2008
|
||||
[#2024]: https://github.com/actix/actix-web/pull/2024
|
||||
[#2050]: https://github.com/actix/actix-web/pull/2050
|
||||
|
||||
|
||||
## 3.0.0-beta.2 - 2021-02-10
|
||||
### Added
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
[package]
|
||||
name = "awc"
|
||||
version = "3.0.0-beta.2"
|
||||
version = "3.0.0-beta.3"
|
||||
authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
|
||||
description = "Async HTTP and WebSocket client library built on the Actix ecosystem"
|
||||
readme = "README.md"
|
||||
|
|
@ -46,17 +46,19 @@ trust-dns = ["actix-http/trust-dns"]
|
|||
[dependencies]
|
||||
actix-codec = "0.4.0-beta.1"
|
||||
actix-service = "2.0.0-beta.4"
|
||||
actix-http = "3.0.0-beta.3"
|
||||
actix-rt = "2.1"
|
||||
actix-http = "3.0.0-beta.4"
|
||||
actix-rt = { version = "2.1", default-features = false }
|
||||
|
||||
base64 = "0.13"
|
||||
bytes = "1"
|
||||
cfg-if = "1.0"
|
||||
derive_more = "0.99.5"
|
||||
futures-core = { version = "0.3.7", default-features = false }
|
||||
itoa = "0.4"
|
||||
log =" 0.4"
|
||||
mime = "0.3"
|
||||
percent-encoding = "2.1"
|
||||
pin-project-lite = "0.2"
|
||||
rand = "0.8"
|
||||
serde = "1.0"
|
||||
serde_json = "1.0"
|
||||
|
|
@ -71,16 +73,16 @@ features = ["vendored"]
|
|||
optional = true
|
||||
|
||||
[dev-dependencies]
|
||||
actix-web = { version = "4.0.0-beta.3", features = ["openssl"] }
|
||||
actix-http = { version = "3.0.0-beta.3", features = ["openssl"] }
|
||||
actix-http-test = { version = "3.0.0-beta.2", features = ["openssl"] }
|
||||
actix-web = { version = "4.0.0-beta.4", features = ["openssl"] }
|
||||
actix-http = { version = "3.0.0-beta.4", features = ["openssl"] }
|
||||
actix-http-test = { version = "3.0.0-beta.3", features = ["openssl"] }
|
||||
actix-utils = "3.0.0-beta.1"
|
||||
actix-server = "2.0.0-beta.3"
|
||||
actix-tls = { version = "3.0.0-beta.4", features = ["openssl", "rustls"] }
|
||||
|
||||
brotli2 = "0.3.2"
|
||||
env_logger = "0.8"
|
||||
flate2 = "1.0.13"
|
||||
futures-util = { version = "0.3.7", default-features = false }
|
||||
env_logger = "0.8"
|
||||
rcgen = "0.8"
|
||||
webpki = "0.21"
|
||||
|
|
|
|||
|
|
@ -3,19 +3,20 @@
|
|||
> Async HTTP and WebSocket client library.
|
||||
|
||||
[](https://crates.io/crates/awc)
|
||||
[](https://docs.rs/awc/3.0.0-beta.2)
|
||||
[](https://docs.rs/awc/3.0.0-beta.3)
|
||||
|
||||
[](https://deps.rs/crate/awc/3.0.0-beta.2)
|
||||
[](https://deps.rs/crate/awc/3.0.0-beta.3)
|
||||
[](https://gitter.im/actix/actix-web?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
|
||||
|
||||
## Documentation & Resources
|
||||
|
||||
- [API Documentation](https://docs.rs/awc)
|
||||
- [Example Project](https://github.com/actix/examples/tree/HEAD/awc_https)
|
||||
- [Example Project](https://github.com/actix/examples/tree/HEAD/security/awc_https)
|
||||
- [Chat on Gitter](https://gitter.im/actix/actix-web)
|
||||
- Minimum Supported Rust Version (MSRV): 1.46.0
|
||||
|
||||
## Example
|
||||
|
||||
```rust
|
||||
use actix_rt::System;
|
||||
use awc::Client;
|
||||
|
|
@ -26,7 +27,7 @@ fn main() {
|
|||
|
||||
let res = client
|
||||
.get("http://www.rust-lang.org") // <- Create request builder
|
||||
.header("User-Agent", "Actix-web")
|
||||
.insert_header(("User-Agent", "Actix-web"))
|
||||
.send() // <- Send http request
|
||||
.await;
|
||||
|
||||
|
|
|
|||
|
|
@ -10,24 +10,28 @@ use actix_http::{
|
|||
http::{self, header, Error as HttpError, HeaderMap, HeaderName, Uri},
|
||||
};
|
||||
use actix_rt::net::TcpStream;
|
||||
use actix_service::Service;
|
||||
use actix_service::{boxed, Service};
|
||||
|
||||
use crate::connect::ConnectorWrapper;
|
||||
use crate::{Client, ClientConfig};
|
||||
use crate::connect::DefaultConnector;
|
||||
use crate::error::SendRequestError;
|
||||
use crate::middleware::{NestTransform, Redirect, Transform};
|
||||
use crate::{Client, ClientConfig, ConnectRequest, ConnectResponse, ConnectorService};
|
||||
|
||||
/// An HTTP Client builder
|
||||
///
|
||||
/// This type can be used to construct an instance of `Client` through a
|
||||
/// builder-like pattern.
|
||||
pub struct ClientBuilder<T = (), U = ()> {
|
||||
pub struct ClientBuilder<S = (), M = ()> {
|
||||
default_headers: bool,
|
||||
max_http_version: Option<http::Version>,
|
||||
stream_window_size: Option<u32>,
|
||||
conn_window_size: Option<u32>,
|
||||
headers: HeaderMap,
|
||||
timeout: Option<Duration>,
|
||||
connector: Connector<S>,
|
||||
middleware: M,
|
||||
local_address: Option<IpAddr>,
|
||||
connector: Connector<T, U>,
|
||||
max_redirects: u8,
|
||||
}
|
||||
|
||||
impl ClientBuilder {
|
||||
|
|
@ -38,9 +42,10 @@ impl ClientBuilder {
|
|||
Response = TcpConnection<Uri, TcpStream>,
|
||||
Error = TcpConnectError,
|
||||
> + Clone,
|
||||
TcpStream,
|
||||
(),
|
||||
> {
|
||||
ClientBuilder {
|
||||
middleware: (),
|
||||
default_headers: true,
|
||||
headers: HeaderMap::new(),
|
||||
timeout: Some(Duration::from_secs(5)),
|
||||
|
|
@ -49,11 +54,12 @@ impl ClientBuilder {
|
|||
max_http_version: None,
|
||||
stream_window_size: None,
|
||||
conn_window_size: None,
|
||||
max_redirects: 10,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<S, Io> ClientBuilder<S, Io>
|
||||
impl<S, Io, M> ClientBuilder<S, M>
|
||||
where
|
||||
S: Service<TcpConnect<Uri>, Response = TcpConnection<Uri, Io>, Error = TcpConnectError>
|
||||
+ Clone
|
||||
|
|
@ -61,7 +67,7 @@ where
|
|||
Io: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static,
|
||||
{
|
||||
/// Use custom connector service.
|
||||
pub fn connector<S1, Io1>(self, connector: Connector<S1, Io1>) -> ClientBuilder<S1, Io1>
|
||||
pub fn connector<S1, Io1>(self, connector: Connector<S1>) -> ClientBuilder<S1, M>
|
||||
where
|
||||
S1: Service<
|
||||
TcpConnect<Uri>,
|
||||
|
|
@ -72,14 +78,16 @@ where
|
|||
Io1: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static,
|
||||
{
|
||||
ClientBuilder {
|
||||
middleware: self.middleware,
|
||||
default_headers: self.default_headers,
|
||||
headers: self.headers,
|
||||
timeout: self.timeout,
|
||||
local_address: None,
|
||||
local_address: self.local_address,
|
||||
connector,
|
||||
max_http_version: self.max_http_version,
|
||||
stream_window_size: self.stream_window_size,
|
||||
conn_window_size: self.conn_window_size,
|
||||
max_redirects: self.max_redirects,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -112,6 +120,22 @@ where
|
|||
self
|
||||
}
|
||||
|
||||
/// Do not follow redirects.
|
||||
///
|
||||
/// Redirects are allowed by default.
|
||||
pub fn disable_redirects(mut self) -> Self {
|
||||
self.max_redirects = 0;
|
||||
self
|
||||
}
|
||||
|
||||
/// Set max number of redirects.
|
||||
///
|
||||
/// Max redirects is set to 10 by default.
|
||||
pub fn max_redirects(mut self, num: u8) -> Self {
|
||||
self.max_redirects = num;
|
||||
self
|
||||
}
|
||||
|
||||
/// Indicates the initial window size (in octets) for
|
||||
/// HTTP2 stream-level flow control for received data.
|
||||
///
|
||||
|
|
@ -181,8 +205,55 @@ where
|
|||
self.header(header::AUTHORIZATION, format!("Bearer {}", token))
|
||||
}
|
||||
|
||||
/// Registers middleware, in the form of a middleware component (type),
|
||||
/// that runs during inbound and/or outbound processing in the request
|
||||
/// life-cycle (request -> response), modifying request/response as
|
||||
/// necessary, across all requests managed by the Client.
|
||||
pub fn wrap<S1, M1>(
|
||||
self,
|
||||
mw: M1,
|
||||
) -> ClientBuilder<S, NestTransform<M, M1, S1, ConnectRequest>>
|
||||
where
|
||||
M: Transform<S1, ConnectRequest>,
|
||||
M1: Transform<M::Transform, ConnectRequest>,
|
||||
{
|
||||
ClientBuilder {
|
||||
middleware: NestTransform::new(self.middleware, mw),
|
||||
default_headers: self.default_headers,
|
||||
max_http_version: self.max_http_version,
|
||||
stream_window_size: self.stream_window_size,
|
||||
conn_window_size: self.conn_window_size,
|
||||
headers: self.headers,
|
||||
timeout: self.timeout,
|
||||
connector: self.connector,
|
||||
local_address: self.local_address,
|
||||
max_redirects: self.max_redirects,
|
||||
}
|
||||
}
|
||||
|
||||
/// Finish build process and create `Client` instance.
|
||||
pub fn finish(self) -> Client {
|
||||
pub fn finish(self) -> Client
|
||||
where
|
||||
M: Transform<ConnectorService, ConnectRequest> + 'static,
|
||||
M::Transform:
|
||||
Service<ConnectRequest, Response = ConnectResponse, Error = SendRequestError>,
|
||||
{
|
||||
let redirect_time = self.max_redirects;
|
||||
|
||||
if redirect_time > 0 {
|
||||
self.wrap(Redirect::new().max_redirect_times(redirect_time))
|
||||
._finish()
|
||||
} else {
|
||||
self._finish()
|
||||
}
|
||||
}
|
||||
|
||||
fn _finish(self) -> Client
|
||||
where
|
||||
M: Transform<ConnectorService, ConnectRequest> + 'static,
|
||||
M::Transform:
|
||||
Service<ConnectRequest, Response = ConnectResponse, Error = SendRequestError>,
|
||||
{
|
||||
let mut connector = self.connector;
|
||||
|
||||
if let Some(val) = self.max_http_version {
|
||||
|
|
@ -198,10 +269,13 @@ where
|
|||
connector = connector.local_address(val);
|
||||
}
|
||||
|
||||
let connector = boxed::service(DefaultConnector::new(connector.finish()));
|
||||
let connector = boxed::service(self.middleware.new_transform(connector));
|
||||
|
||||
let config = ClientConfig {
|
||||
headers: self.headers,
|
||||
timeout: self.timeout,
|
||||
connector: Box::new(ConnectorWrapper::new(connector.finish())) as _,
|
||||
connector,
|
||||
};
|
||||
|
||||
Client(Rc::new(config))
|
||||
|
|
|
|||
|
|
@ -1,5 +1,7 @@
|
|||
use std::{
|
||||
fmt, io, net,
|
||||
fmt,
|
||||
future::Future,
|
||||
io, net,
|
||||
pin::Pin,
|
||||
task::{Context, Poll},
|
||||
};
|
||||
|
|
@ -9,24 +11,14 @@ use actix_http::{
|
|||
body::Body,
|
||||
client::{Connect as ClientConnect, ConnectError, Connection, SendRequestError},
|
||||
h1::ClientCodec,
|
||||
RequestHead, RequestHeadType, ResponseHead,
|
||||
Payload, RequestHead, RequestHeadType, ResponseHead,
|
||||
};
|
||||
use actix_service::Service;
|
||||
use futures_core::future::LocalBoxFuture;
|
||||
use futures_core::{future::LocalBoxFuture, ready};
|
||||
|
||||
use crate::response::ClientResponse;
|
||||
|
||||
pub(crate) struct ConnectorWrapper<T> {
|
||||
connector: T,
|
||||
}
|
||||
|
||||
impl<T> ConnectorWrapper<T> {
|
||||
pub(crate) fn new(connector: T) -> Self {
|
||||
Self { connector }
|
||||
}
|
||||
}
|
||||
|
||||
pub type ConnectService = Box<
|
||||
pub type ConnectorService = Box<
|
||||
dyn Service<
|
||||
ConnectRequest,
|
||||
Response = ConnectResponse,
|
||||
|
|
@ -65,16 +57,25 @@ impl ConnectResponse {
|
|||
}
|
||||
}
|
||||
|
||||
impl<T> Service<ConnectRequest> for ConnectorWrapper<T>
|
||||
pub(crate) struct DefaultConnector<S> {
|
||||
connector: S,
|
||||
}
|
||||
|
||||
impl<S> DefaultConnector<S> {
|
||||
pub(crate) fn new(connector: S) -> Self {
|
||||
Self { connector }
|
||||
}
|
||||
}
|
||||
|
||||
impl<S> Service<ConnectRequest> for DefaultConnector<S>
|
||||
where
|
||||
T: Service<ClientConnect, Error = ConnectError>,
|
||||
T::Response: Connection,
|
||||
<T::Response as Connection>::Io: 'static,
|
||||
T::Future: 'static,
|
||||
S: Service<ClientConnect, Error = ConnectError>,
|
||||
S::Response: Connection,
|
||||
<S::Response as Connection>::Io: 'static,
|
||||
{
|
||||
type Response = ConnectResponse;
|
||||
type Error = SendRequestError;
|
||||
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
|
||||
type Future = ConnectRequestFuture<S::Future, <S::Response as Connection>::Io>;
|
||||
|
||||
actix_service::forward_ready!(connector);
|
||||
|
||||
|
|
@ -91,26 +92,76 @@ where
|
|||
}),
|
||||
};
|
||||
|
||||
Box::pin(async move {
|
||||
let connection = fut.await?;
|
||||
ConnectRequestFuture::Connection {
|
||||
fut,
|
||||
req: Some(req),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pin_project_lite::pin_project! {
|
||||
#[project = ConnectRequestProj]
|
||||
pub(crate) enum ConnectRequestFuture<Fut, Io> {
|
||||
Connection {
|
||||
#[pin]
|
||||
fut: Fut,
|
||||
req: Option<ConnectRequest>
|
||||
},
|
||||
Client {
|
||||
fut: LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>
|
||||
},
|
||||
Tunnel {
|
||||
fut: LocalBoxFuture<
|
||||
'static,
|
||||
Result<(ResponseHead, Framed<Io, ClientCodec>), SendRequestError>,
|
||||
>,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<Fut, C, Io> Future for ConnectRequestFuture<Fut, Io>
|
||||
where
|
||||
Fut: Future<Output = Result<C, ConnectError>>,
|
||||
C: Connection<Io = Io>,
|
||||
Io: AsyncRead + AsyncWrite + Unpin + 'static,
|
||||
{
|
||||
type Output = Result<ConnectResponse, SendRequestError>;
|
||||
|
||||
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||
match self.as_mut().project() {
|
||||
ConnectRequestProj::Connection { fut, req } => {
|
||||
let connection = ready!(fut.poll(cx))?;
|
||||
let req = req.take().unwrap();
|
||||
match req {
|
||||
ConnectRequest::Client(head, body, ..) => {
|
||||
// send request
|
||||
let (head, payload) = connection.send_request(head, body).await?;
|
||||
|
||||
Ok(ConnectResponse::Client(ClientResponse::new(head, payload)))
|
||||
let fut = ConnectRequestFuture::Client {
|
||||
fut: connection.send_request(head, body),
|
||||
};
|
||||
self.as_mut().set(fut);
|
||||
}
|
||||
ConnectRequest::Tunnel(head, ..) => {
|
||||
// send request
|
||||
let (head, framed) =
|
||||
connection.open_tunnel(RequestHeadType::from(head)).await?;
|
||||
|
||||
let fut = ConnectRequestFuture::Tunnel {
|
||||
fut: connection.open_tunnel(RequestHeadType::from(head)),
|
||||
};
|
||||
self.as_mut().set(fut);
|
||||
}
|
||||
}
|
||||
self.poll(cx)
|
||||
}
|
||||
ConnectRequestProj::Client { fut } => {
|
||||
let (head, payload) = ready!(fut.as_mut().poll(cx))?;
|
||||
Poll::Ready(Ok(ConnectResponse::Client(ClientResponse::new(
|
||||
head, payload,
|
||||
))))
|
||||
}
|
||||
ConnectRequestProj::Tunnel { fut } => {
|
||||
let (head, framed) = ready!(fut.as_mut().poll(cx))?;
|
||||
let framed = framed.into_map_io(|io| BoxedSocket(Box::new(Socket(io))));
|
||||
Ok(ConnectResponse::Tunnel(head, framed))
|
||||
Poll::Ready(Ok(ConnectResponse::Tunnel(head, framed)))
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -18,24 +18,31 @@ pub enum WsClientError {
|
|||
/// Invalid response status
|
||||
#[display(fmt = "Invalid response status")]
|
||||
InvalidResponseStatus(StatusCode),
|
||||
|
||||
/// Invalid upgrade header
|
||||
#[display(fmt = "Invalid upgrade header")]
|
||||
InvalidUpgradeHeader,
|
||||
|
||||
/// Invalid connection header
|
||||
#[display(fmt = "Invalid connection header")]
|
||||
InvalidConnectionHeader(HeaderValue),
|
||||
/// Missing CONNECTION header
|
||||
#[display(fmt = "Missing CONNECTION header")]
|
||||
|
||||
/// Missing Connection header
|
||||
#[display(fmt = "Missing Connection header")]
|
||||
MissingConnectionHeader,
|
||||
/// Missing SEC-WEBSOCKET-ACCEPT header
|
||||
#[display(fmt = "Missing SEC-WEBSOCKET-ACCEPT header")]
|
||||
|
||||
/// Missing Sec-Websocket-Accept header
|
||||
#[display(fmt = "Missing Sec-Websocket-Accept header")]
|
||||
MissingWebSocketAcceptHeader,
|
||||
|
||||
/// Invalid challenge response
|
||||
#[display(fmt = "Invalid challenge response")]
|
||||
InvalidChallengeResponse(String, HeaderValue),
|
||||
InvalidChallengeResponse([u8; 28], HeaderValue),
|
||||
|
||||
/// Protocol error
|
||||
#[display(fmt = "{}", _0)]
|
||||
Protocol(WsProtocolError),
|
||||
|
||||
/// Send request error
|
||||
#[display(fmt = "{}", _0)]
|
||||
SendRequest(SendRequestError),
|
||||
|
|
|
|||
|
|
@ -113,6 +113,7 @@ mod builder;
|
|||
mod connect;
|
||||
pub mod error;
|
||||
mod frozen;
|
||||
pub mod middleware;
|
||||
mod request;
|
||||
mod response;
|
||||
mod sender;
|
||||
|
|
@ -120,14 +121,12 @@ pub mod test;
|
|||
pub mod ws;
|
||||
|
||||
pub use self::builder::ClientBuilder;
|
||||
pub use self::connect::{BoxedSocket, ConnectRequest, ConnectResponse, ConnectService};
|
||||
pub use self::connect::{BoxedSocket, ConnectRequest, ConnectResponse, ConnectorService};
|
||||
pub use self::frozen::{FrozenClientRequest, FrozenSendBuilder};
|
||||
pub use self::request::ClientRequest;
|
||||
pub use self::response::{ClientResponse, JsonBody, MessageBody};
|
||||
pub use self::sender::SendClientRequest;
|
||||
|
||||
use self::connect::ConnectorWrapper;
|
||||
|
||||
/// An asynchronous HTTP and WebSocket client.
|
||||
///
|
||||
/// ## Examples
|
||||
|
|
@ -151,18 +150,14 @@ use self::connect::ConnectorWrapper;
|
|||
pub struct Client(Rc<ClientConfig>);
|
||||
|
||||
pub(crate) struct ClientConfig {
|
||||
pub(crate) connector: ConnectService,
|
||||
pub(crate) connector: ConnectorService,
|
||||
pub(crate) headers: HeaderMap,
|
||||
pub(crate) timeout: Option<Duration>,
|
||||
}
|
||||
|
||||
impl Default for Client {
|
||||
fn default() -> Self {
|
||||
Client(Rc::new(ClientConfig {
|
||||
connector: Box::new(ConnectorWrapper::new(Connector::new().finish())),
|
||||
headers: HeaderMap::new(),
|
||||
timeout: Some(Duration::from_secs(5)),
|
||||
}))
|
||||
ClientBuilder::new().finish()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -180,7 +175,6 @@ impl Client {
|
|||
Response = TcpConnection<Uri, TcpStream>,
|
||||
Error = TcpConnectError,
|
||||
> + Clone,
|
||||
TcpStream,
|
||||
> {
|
||||
ClientBuilder::new()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,71 @@
|
|||
mod redirect;
|
||||
|
||||
pub use self::redirect::Redirect;
|
||||
|
||||
use std::marker::PhantomData;
|
||||
|
||||
use actix_service::Service;
|
||||
|
||||
/// Trait for transform a type to another one.
|
||||
/// Both the input and output type should impl [actix_service::Service] trait.
|
||||
pub trait Transform<S, Req> {
|
||||
type Transform: Service<Req>;
|
||||
|
||||
/// Creates and returns a new Transform component.
|
||||
fn new_transform(self, service: S) -> Self::Transform;
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
/// Helper struct for constructing Nested types that would call `Transform::new_transform`
|
||||
/// in a chain.
|
||||
///
|
||||
/// The child field would be called first and the output `Service` type is
|
||||
/// passed to parent as input type.
|
||||
pub struct NestTransform<T1, T2, S, Req>
|
||||
where
|
||||
T1: Transform<S, Req>,
|
||||
T2: Transform<T1::Transform, Req>,
|
||||
{
|
||||
child: T1,
|
||||
parent: T2,
|
||||
_service: PhantomData<(S, Req)>,
|
||||
}
|
||||
|
||||
impl<T1, T2, S, Req> NestTransform<T1, T2, S, Req>
|
||||
where
|
||||
T1: Transform<S, Req>,
|
||||
T2: Transform<T1::Transform, Req>,
|
||||
{
|
||||
pub(crate) fn new(child: T1, parent: T2) -> Self {
|
||||
NestTransform {
|
||||
child,
|
||||
parent,
|
||||
_service: PhantomData,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T1, T2, S, Req> Transform<S, Req> for NestTransform<T1, T2, S, Req>
|
||||
where
|
||||
T1: Transform<S, Req>,
|
||||
T2: Transform<T1::Transform, Req>,
|
||||
{
|
||||
type Transform = T2::Transform;
|
||||
|
||||
fn new_transform(self, service: S) -> Self::Transform {
|
||||
let service = self.child.new_transform(service);
|
||||
self.parent.new_transform(service)
|
||||
}
|
||||
}
|
||||
|
||||
/// Dummy impl for kick start `NestTransform` type in `ClientBuilder` type
|
||||
impl<S, Req> Transform<S, Req> for ()
|
||||
where
|
||||
S: Service<Req>,
|
||||
{
|
||||
type Transform = S;
|
||||
|
||||
fn new_transform(self, service: S) -> Self::Transform {
|
||||
service
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,351 @@
|
|||
use std::{
|
||||
convert::TryFrom,
|
||||
future::Future,
|
||||
net::SocketAddr,
|
||||
pin::Pin,
|
||||
rc::Rc,
|
||||
task::{Context, Poll},
|
||||
};
|
||||
|
||||
use actix_http::{
|
||||
body::Body,
|
||||
client::{InvalidUrl, SendRequestError},
|
||||
http::{header, Method, StatusCode, Uri},
|
||||
RequestHead, RequestHeadType,
|
||||
};
|
||||
use actix_service::Service;
|
||||
use bytes::Bytes;
|
||||
use futures_core::ready;
|
||||
|
||||
use super::Transform;
|
||||
|
||||
use crate::connect::{ConnectRequest, ConnectResponse};
|
||||
use crate::ClientResponse;
|
||||
|
||||
pub struct Redirect {
|
||||
max_redirect_times: u8,
|
||||
}
|
||||
|
||||
impl Default for Redirect {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl Redirect {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
max_redirect_times: 10,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn max_redirect_times(mut self, times: u8) -> Self {
|
||||
self.max_redirect_times = times;
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl<S> Transform<S, ConnectRequest> for Redirect
|
||||
where
|
||||
S: Service<ConnectRequest, Response = ConnectResponse, Error = SendRequestError> + 'static,
|
||||
{
|
||||
type Transform = RedirectService<S>;
|
||||
|
||||
fn new_transform(self, service: S) -> Self::Transform {
|
||||
RedirectService {
|
||||
max_redirect_times: self.max_redirect_times,
|
||||
connector: Rc::new(service),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct RedirectService<S> {
|
||||
max_redirect_times: u8,
|
||||
connector: Rc<S>,
|
||||
}
|
||||
|
||||
impl<S> Service<ConnectRequest> for RedirectService<S>
|
||||
where
|
||||
S: Service<ConnectRequest, Response = ConnectResponse, Error = SendRequestError> + 'static,
|
||||
{
|
||||
type Response = S::Response;
|
||||
type Error = S::Error;
|
||||
type Future = RedirectServiceFuture<S>;
|
||||
|
||||
actix_service::forward_ready!(connector);
|
||||
|
||||
fn call(&self, req: ConnectRequest) -> Self::Future {
|
||||
match req {
|
||||
ConnectRequest::Tunnel(head, addr) => {
|
||||
let fut = self.connector.call(ConnectRequest::Tunnel(head, addr));
|
||||
RedirectServiceFuture::Tunnel { fut }
|
||||
}
|
||||
ConnectRequest::Client(head, body, addr) => {
|
||||
let connector = self.connector.clone();
|
||||
let max_redirect_times = self.max_redirect_times;
|
||||
|
||||
// backup the uri and method for reuse schema and authority.
|
||||
let (uri, method) = match head {
|
||||
RequestHeadType::Owned(ref head) => (head.uri.clone(), head.method.clone()),
|
||||
RequestHeadType::Rc(ref head, ..) => {
|
||||
(head.uri.clone(), head.method.clone())
|
||||
}
|
||||
};
|
||||
|
||||
let body_opt = match body {
|
||||
Body::Bytes(ref b) => Some(b.clone()),
|
||||
_ => None,
|
||||
};
|
||||
|
||||
let fut = connector.call(ConnectRequest::Client(head, body, addr));
|
||||
|
||||
RedirectServiceFuture::Client {
|
||||
fut,
|
||||
max_redirect_times,
|
||||
uri: Some(uri),
|
||||
method: Some(method),
|
||||
body: body_opt,
|
||||
addr,
|
||||
connector: Some(connector),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pin_project_lite::pin_project! {
|
||||
#[project = RedirectServiceProj]
|
||||
pub enum RedirectServiceFuture<S>
|
||||
where
|
||||
S: Service<ConnectRequest, Response = ConnectResponse, Error = SendRequestError>,
|
||||
S: 'static
|
||||
{
|
||||
Tunnel { #[pin] fut: S::Future },
|
||||
Client {
|
||||
#[pin]
|
||||
fut: S::Future,
|
||||
max_redirect_times: u8,
|
||||
uri: Option<Uri>,
|
||||
method: Option<Method>,
|
||||
body: Option<Bytes>,
|
||||
addr: Option<SocketAddr>,
|
||||
connector: Option<Rc<S>>
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<S> Future for RedirectServiceFuture<S>
|
||||
where
|
||||
S: Service<ConnectRequest, Response = ConnectResponse, Error = SendRequestError> + 'static,
|
||||
{
|
||||
type Output = Result<ConnectResponse, SendRequestError>;
|
||||
|
||||
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||
match self.as_mut().project() {
|
||||
RedirectServiceProj::Tunnel { fut } => fut.poll(cx),
|
||||
RedirectServiceProj::Client {
|
||||
fut,
|
||||
max_redirect_times,
|
||||
uri,
|
||||
method,
|
||||
body,
|
||||
addr,
|
||||
connector,
|
||||
} => match ready!(fut.poll(cx))? {
|
||||
ConnectResponse::Client(res) => match res.head().status {
|
||||
StatusCode::MOVED_PERMANENTLY
|
||||
| StatusCode::FOUND
|
||||
| StatusCode::SEE_OTHER
|
||||
if *max_redirect_times > 0 =>
|
||||
{
|
||||
let org_uri = uri.take().unwrap();
|
||||
// rebuild uri from the location header value.
|
||||
let uri = rebuild_uri(&res, org_uri)?;
|
||||
|
||||
// reset method
|
||||
let method = method.take().unwrap();
|
||||
let method = match method {
|
||||
Method::GET | Method::HEAD => method,
|
||||
_ => Method::GET,
|
||||
};
|
||||
|
||||
// take ownership of states that could be reused
|
||||
let addr = addr.take();
|
||||
let connector = connector.take();
|
||||
let mut max_redirect_times = *max_redirect_times;
|
||||
|
||||
// use a new request head.
|
||||
let mut head = RequestHead::default();
|
||||
head.uri = uri.clone();
|
||||
head.method = method.clone();
|
||||
|
||||
let head = RequestHeadType::Owned(head);
|
||||
|
||||
max_redirect_times -= 1;
|
||||
|
||||
let fut = connector
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
// remove body
|
||||
.call(ConnectRequest::Client(head, Body::None, addr));
|
||||
|
||||
self.as_mut().set(RedirectServiceFuture::Client {
|
||||
fut,
|
||||
max_redirect_times,
|
||||
uri: Some(uri),
|
||||
method: Some(method),
|
||||
// body is dropped on 301,302,303
|
||||
body: None,
|
||||
addr,
|
||||
connector,
|
||||
});
|
||||
|
||||
self.poll(cx)
|
||||
}
|
||||
StatusCode::TEMPORARY_REDIRECT | StatusCode::PERMANENT_REDIRECT
|
||||
if *max_redirect_times > 0 =>
|
||||
{
|
||||
let org_uri = uri.take().unwrap();
|
||||
// rebuild uri from the location header value.
|
||||
let uri = rebuild_uri(&res, org_uri)?;
|
||||
|
||||
// try to reuse body
|
||||
let body = body.take();
|
||||
let body_new = match body {
|
||||
Some(ref bytes) => Body::Bytes(bytes.clone()),
|
||||
// TODO: should this be Body::Empty or Body::None.
|
||||
_ => Body::Empty,
|
||||
};
|
||||
|
||||
let addr = addr.take();
|
||||
let method = method.take().unwrap();
|
||||
let connector = connector.take();
|
||||
let mut max_redirect_times = *max_redirect_times;
|
||||
|
||||
// use a new request head.
|
||||
let mut head = RequestHead::default();
|
||||
head.uri = uri.clone();
|
||||
head.method = method.clone();
|
||||
|
||||
let head = RequestHeadType::Owned(head);
|
||||
|
||||
max_redirect_times -= 1;
|
||||
|
||||
let fut = connector
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.call(ConnectRequest::Client(head, body_new, addr));
|
||||
|
||||
self.as_mut().set(RedirectServiceFuture::Client {
|
||||
fut,
|
||||
max_redirect_times,
|
||||
uri: Some(uri),
|
||||
method: Some(method),
|
||||
body,
|
||||
addr,
|
||||
connector,
|
||||
});
|
||||
|
||||
self.poll(cx)
|
||||
}
|
||||
_ => Poll::Ready(Ok(ConnectResponse::Client(res))),
|
||||
},
|
||||
_ => unreachable!("ConnectRequest::Tunnel is not handled by Redirect"),
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn rebuild_uri(res: &ClientResponse, org_uri: Uri) -> Result<Uri, SendRequestError> {
|
||||
let uri = res
|
||||
.headers()
|
||||
.get(header::LOCATION)
|
||||
.map(|value| {
|
||||
// try to parse the location to a full uri
|
||||
let uri = Uri::try_from(value.as_bytes())
|
||||
.map_err(|e| SendRequestError::Url(InvalidUrl::HttpError(e.into())))?;
|
||||
if uri.scheme().is_none() || uri.authority().is_none() {
|
||||
let uri = Uri::builder()
|
||||
.scheme(org_uri.scheme().cloned().unwrap())
|
||||
.authority(org_uri.authority().cloned().unwrap())
|
||||
.path_and_query(value.as_bytes())
|
||||
.build()?;
|
||||
Ok::<_, SendRequestError>(uri)
|
||||
} else {
|
||||
Ok(uri)
|
||||
}
|
||||
})
|
||||
// TODO: this error type is wrong.
|
||||
.ok_or(SendRequestError::Url(InvalidUrl::MissingScheme))??;
|
||||
|
||||
Ok(uri)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use actix_web::{test::start, web, App, Error, HttpResponse};
|
||||
|
||||
use super::*;
|
||||
|
||||
use crate::ClientBuilder;
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn test_basic_redirect() {
|
||||
let client = ClientBuilder::new()
|
||||
.disable_redirects()
|
||||
.wrap(Redirect::new().max_redirect_times(10))
|
||||
.finish();
|
||||
|
||||
let srv = start(|| {
|
||||
App::new()
|
||||
.service(web::resource("/test").route(web::to(|| async {
|
||||
Ok::<_, Error>(HttpResponse::BadRequest())
|
||||
})))
|
||||
.service(web::resource("/").route(web::to(|| async {
|
||||
Ok::<_, Error>(
|
||||
HttpResponse::Found()
|
||||
.append_header(("location", "/test"))
|
||||
.finish(),
|
||||
)
|
||||
})))
|
||||
});
|
||||
|
||||
let res = client.get(srv.url("/")).send().await.unwrap();
|
||||
|
||||
assert_eq!(res.status().as_u16(), 400);
|
||||
}
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn test_redirect_limit() {
|
||||
let client = ClientBuilder::new()
|
||||
.disable_redirects()
|
||||
.wrap(Redirect::new().max_redirect_times(1))
|
||||
.connector(crate::Connector::new())
|
||||
.finish();
|
||||
|
||||
let srv = start(|| {
|
||||
App::new()
|
||||
.service(web::resource("/").route(web::to(|| async {
|
||||
Ok::<_, Error>(
|
||||
HttpResponse::Found()
|
||||
.append_header(("location", "/test"))
|
||||
.finish(),
|
||||
)
|
||||
})))
|
||||
.service(web::resource("/test").route(web::to(|| async {
|
||||
Ok::<_, Error>(
|
||||
HttpResponse::Found()
|
||||
.append_header(("location", "/test2"))
|
||||
.finish(),
|
||||
)
|
||||
})))
|
||||
.service(web::resource("/test2").route(web::to(|| async {
|
||||
Ok::<_, Error>(HttpResponse::BadRequest())
|
||||
})))
|
||||
});
|
||||
|
||||
let res = client.get(srv.url("/")).send().await.unwrap();
|
||||
|
||||
assert_eq!(res.status().as_u16(), 302);
|
||||
}
|
||||
}
|
||||
|
|
@ -248,30 +248,25 @@ impl ClientRequest {
|
|||
/// Set content length
|
||||
#[inline]
|
||||
pub fn content_length(self, len: u64) -> Self {
|
||||
self.append_header((header::CONTENT_LENGTH, len))
|
||||
let mut buf = itoa::Buffer::new();
|
||||
self.insert_header((header::CONTENT_LENGTH, buf.format(len)))
|
||||
}
|
||||
|
||||
/// Set HTTP basic authorization header
|
||||
pub fn basic_auth<U>(self, username: U, password: Option<&str>) -> Self
|
||||
where
|
||||
U: fmt::Display,
|
||||
{
|
||||
let auth = match password {
|
||||
Some(password) => format!("{}:{}", username, password),
|
||||
None => format!("{}:", username),
|
||||
};
|
||||
self.append_header((
|
||||
/// Set HTTP basic authorization header.
|
||||
///
|
||||
/// If no password is needed, just provide an empty string.
|
||||
pub fn basic_auth(self, username: impl fmt::Display, password: impl fmt::Display) -> Self {
|
||||
let auth = format!("{}:{}", username, password);
|
||||
|
||||
self.insert_header((
|
||||
header::AUTHORIZATION,
|
||||
format!("Basic {}", base64::encode(&auth)),
|
||||
))
|
||||
}
|
||||
|
||||
/// Set HTTP bearer authentication header
|
||||
pub fn bearer_auth<T>(self, token: T) -> Self
|
||||
where
|
||||
T: fmt::Display,
|
||||
{
|
||||
self.append_header((header::AUTHORIZATION, format!("Bearer {}", token)))
|
||||
pub fn bearer_auth(self, token: impl fmt::Display) -> Self {
|
||||
self.insert_header((header::AUTHORIZATION, format!("Bearer {}", token)))
|
||||
}
|
||||
|
||||
/// Set a cookie
|
||||
|
|
@ -643,9 +638,7 @@ mod tests {
|
|||
|
||||
#[actix_rt::test]
|
||||
async fn client_basic_auth() {
|
||||
let req = Client::new()
|
||||
.get("/")
|
||||
.basic_auth("username", Some("password"));
|
||||
let req = Client::new().get("/").basic_auth("username", "password");
|
||||
assert_eq!(
|
||||
req.head
|
||||
.headers
|
||||
|
|
@ -656,7 +649,7 @@ mod tests {
|
|||
"Basic dXNlcm5hbWU6cGFzc3dvcmQ="
|
||||
);
|
||||
|
||||
let req = Client::new().get("/").basic_auth("username", None);
|
||||
let req = Client::new().get("/").basic_auth("username", "");
|
||||
assert_eq!(
|
||||
req.head
|
||||
.headers
|
||||
|
|
|
|||
|
|
@ -492,9 +492,7 @@ mod tests {
|
|||
JsonPayloadError::Payload(PayloadError::Overflow) => {
|
||||
matches!(other, JsonPayloadError::Payload(PayloadError::Overflow))
|
||||
}
|
||||
JsonPayloadError::ContentType => {
|
||||
matches!(other, JsonPayloadError::ContentType)
|
||||
}
|
||||
JsonPayloadError::ContentType => matches!(other, JsonPayloadError::ContentType),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -381,12 +381,14 @@ impl WebsocketsRequest {
|
|||
|
||||
if let Some(hdr_key) = head.headers.get(&header::SEC_WEBSOCKET_ACCEPT) {
|
||||
let encoded = ws::hash_key(key.as_ref());
|
||||
if hdr_key.as_bytes() != encoded.as_bytes() {
|
||||
|
||||
if hdr_key.as_bytes() != encoded {
|
||||
log::trace!(
|
||||
"Invalid challenge response: expected: {} received: {:?}",
|
||||
encoded,
|
||||
"Invalid challenge response: expected: {:?} received: {:?}",
|
||||
&encoded,
|
||||
key
|
||||
);
|
||||
|
||||
return Err(WsClientError::InvalidChallengeResponse(
|
||||
encoded,
|
||||
hdr_key.clone(),
|
||||
|
|
|
|||
|
|
@ -829,7 +829,7 @@ async fn client_basic_auth() {
|
|||
.unwrap()
|
||||
.to_str()
|
||||
.unwrap()
|
||||
== "Basic dXNlcm5hbWU6cGFzc3dvcmQ="
|
||||
== format!("Basic {}", base64::encode("username:password"))
|
||||
{
|
||||
HttpResponse::Ok()
|
||||
} else {
|
||||
|
|
@ -840,7 +840,7 @@ async fn client_basic_auth() {
|
|||
});
|
||||
|
||||
// set authorization header to Basic <base64 encoded username:password>
|
||||
let request = srv.get("/").basic_auth("username", Some("password"));
|
||||
let request = srv.get("/").basic_auth("username", "password");
|
||||
let response = request.send().await.unwrap();
|
||||
assert!(response.status().is_success());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,10 +4,10 @@ coverage:
|
|||
status:
|
||||
project:
|
||||
default:
|
||||
threshold: 10% # make CI green
|
||||
threshold: 100% # make CI green
|
||||
patch:
|
||||
default:
|
||||
threshold: 10% # make CI green
|
||||
threshold: 100% # make CI green
|
||||
|
||||
ignore: # ignore code coverage on following paths
|
||||
- "**/tests"
|
||||
|
|
|
|||
|
|
@ -1,35 +1,44 @@
|
|||
digraph {
|
||||
subgraph cluster_web {
|
||||
label="actix/actix-web"
|
||||
label="actix/web"
|
||||
|
||||
"awc"
|
||||
"actix-web"
|
||||
"actix-files"
|
||||
"actix-http"
|
||||
"actix-multipart"
|
||||
"actix-web-actors"
|
||||
"actix-web-codegen"
|
||||
"actix-http-test"
|
||||
"web"
|
||||
"files"
|
||||
"http"
|
||||
"multipart"
|
||||
"web-actors"
|
||||
"web-codegen"
|
||||
"http-test"
|
||||
|
||||
{ rank=same; "multipart" "web-actors" "http-test" };
|
||||
{ rank=same; "files" "awc" "web" };
|
||||
{ rank=same; "web-codegen" "http" };
|
||||
}
|
||||
|
||||
"actix-web" -> { "actix-codec" "actix-service" "actix-utils" "actix-router" "actix-rt" "actix-server" "macros" "threadpool" "actix-tls" "actix-web-codegen" "actix-http" "awc" }
|
||||
"awc" -> { "actix-codec" "actix-service" "actix-http" "actix-rt" }
|
||||
"actix-web-actors" -> { "actix" "actix-web" "actix-http" "actix-codec" }
|
||||
"actix-multipart" -> { "actix-web" "actix-service" "actix-utils" }
|
||||
"actix-http" -> { "actix-service" "actix-codec" "actix-tls" "actix-utils" "actix-rt" "threadpool" }
|
||||
"actix-http" -> { "actix-tls" }[color=blue] // optional
|
||||
"actix-files" -> { "actix-web" }
|
||||
"actix-http-test" -> { "actix-service" "actix-codec" "actix-tls" "actix-utils" "actix-rt" "actix-server" "awc" }
|
||||
"web" -> { "codec" "service" "utils" "router" "rt" "server" "macros" "web-codegen" "http" "awc" }
|
||||
"web" -> { "tls" }[color=blue] // optional
|
||||
"awc" -> { "codec" "service" "http" "rt" }
|
||||
"web-actors" -> { "actix" "web" "http" "codec" }
|
||||
"multipart" -> { "web" "service" "utils" }
|
||||
"http" -> { "service" "codec" "utils" "rt" }
|
||||
"http" -> { "tls" }[color=blue] // optional
|
||||
"files" -> { "web" }
|
||||
"http-test" -> { "service" "codec" "utils" "rt" "server" "awc" }
|
||||
"http-test" -> { "tls" }[color=blue] // optional
|
||||
|
||||
// net
|
||||
|
||||
"actix-utils" -> { "actix-service" "actix-rt" "actix-codec" }
|
||||
"actix-tracing" -> { "actix-service" }
|
||||
"actix-tls" -> { "actix-service" "actix-codec" "actix-utils" }
|
||||
"actix-server" -> { "actix-service" "actix-rt" "actix-codec" "actix-utils" }
|
||||
"actix-rt" -> { "macros" "threadpool" }
|
||||
"utils" -> { "service" "rt" "codec" }
|
||||
"tracing" -> { "service" }
|
||||
"tls" -> { "service" "codec" "utils" }
|
||||
"server" -> { "service" "rt" "codec" "utils" }
|
||||
"rt" -> { "macros" }
|
||||
|
||||
{ rank=same; "utils" "codec" };
|
||||
{ rank=same; "rt" "macros" "service" "router" };
|
||||
|
||||
// actix
|
||||
|
||||
"actix" -> { "actix-rt" }
|
||||
"actix" -> { "rt" }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ async fn main() -> std::io::Result<()> {
|
|||
.service(
|
||||
web::resource("/resource2/index.html")
|
||||
.wrap(middleware::DefaultHeaders::new().header("X-Version-R2", "0.3"))
|
||||
.default_service(web::route().to(|| HttpResponse::MethodNotAllowed()))
|
||||
.default_service(web::route().to(HttpResponse::MethodNotAllowed))
|
||||
.route(web::get().to(index_async)),
|
||||
)
|
||||
.service(web::resource("/test1.html").to(|| async { "Test\r\n" }))
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
//! properties and pass them to a handler through request-local data.
|
||||
//!
|
||||
//! For an example of extracting a client TLS certificate, see:
|
||||
//! <https://github.com/actix/examples/tree/HEAD/rustls-client-cert>
|
||||
//! <https://github.com/actix/examples/tree/HEAD/security/rustls-client-cert>
|
||||
|
||||
use std::{any::Any, io, net::SocketAddr};
|
||||
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ async fn main() -> std::io::Result<()> {
|
|||
.service(
|
||||
web::resource("/resource2/index.html")
|
||||
.wrap(middleware::DefaultHeaders::new().header("X-Version-R2", "0.3"))
|
||||
.default_service(web::route().to(|| HttpResponse::MethodNotAllowed()))
|
||||
.default_service(web::route().to(HttpResponse::MethodNotAllowed))
|
||||
.route(web::get().to(index_async)),
|
||||
)
|
||||
.service(web::resource("/test1.html").to(|| async { "Test\r\n" }))
|
||||
|
|
|
|||
|
|
@ -1,6 +1,5 @@
|
|||
use std::cell::RefCell;
|
||||
use std::rc::Rc;
|
||||
use std::task::Poll;
|
||||
|
||||
use actix_http::{Extensions, Request, Response};
|
||||
use actix_router::{Path, ResourceDef, Router, Url};
|
||||
|
|
|
|||
13
src/data.rs
13
src/data.rs
|
|
@ -5,6 +5,7 @@ use std::sync::Arc;
|
|||
use actix_http::error::{Error, ErrorInternalServerError};
|
||||
use actix_http::Extensions;
|
||||
use futures_util::future::{err, ok, LocalBoxFuture, Ready};
|
||||
use serde::Serialize;
|
||||
|
||||
use crate::dev::Payload;
|
||||
use crate::extract::FromRequest;
|
||||
|
|
@ -102,6 +103,18 @@ impl<T: ?Sized> From<Arc<T>> for Data<T> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<T> Serialize for Data<T>
|
||||
where
|
||||
T: Serialize,
|
||||
{
|
||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
||||
where
|
||||
S: serde::Serializer,
|
||||
{
|
||||
self.0.serialize(serializer)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: ?Sized + 'static> FromRequest for Data<T> {
|
||||
type Config = ();
|
||||
type Error = Error;
|
||||
|
|
|
|||
|
|
@ -106,6 +106,7 @@ mod tests {
|
|||
HttpResponse,
|
||||
};
|
||||
|
||||
#[allow(clippy::unnecessary_wraps)]
|
||||
fn render_500<B>(mut res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
|
||||
res.response_mut()
|
||||
.headers_mut()
|
||||
|
|
|
|||
|
|
@ -182,6 +182,7 @@ mod tests {
|
|||
use crate::test::{self, TestRequest};
|
||||
use crate::HttpResponse;
|
||||
|
||||
#[allow(clippy::unnecessary_wraps)]
|
||||
fn render_500<B>(mut res: ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> {
|
||||
res.response_mut()
|
||||
.headers_mut()
|
||||
|
|
@ -205,6 +206,7 @@ mod tests {
|
|||
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
|
||||
}
|
||||
|
||||
#[allow(clippy::unnecessary_wraps)]
|
||||
fn render_500_async<B: 'static>(
|
||||
mut res: ServiceResponse<B>,
|
||||
) -> Result<ErrorHandlerResponse<B>> {
|
||||
|
|
|
|||
|
|
@ -363,7 +363,7 @@ impl Format {
|
|||
/// Returns `None` if the format string syntax is incorrect.
|
||||
pub fn new(s: &str) -> Format {
|
||||
log::trace!("Access log format: {}", s);
|
||||
let fmt = Regex::new(r"%(\{([A-Za-z0-9\-_]+)\}([aioe]|xi)|[atPrUsbTD]?)").unwrap();
|
||||
let fmt = Regex::new(r"%(\{([A-Za-z0-9\-_]+)\}([aioe]|xi)|[%atPrUsbTD]?)").unwrap();
|
||||
|
||||
let mut idx = 0;
|
||||
let mut results = Vec::new();
|
||||
|
|
@ -639,6 +639,38 @@ mod tests {
|
|||
let _res = srv.call(req).await.unwrap();
|
||||
}
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn test_escape_percent() {
|
||||
let mut format = Format::new("%%{r}a");
|
||||
|
||||
let req = TestRequest::default()
|
||||
.insert_header((
|
||||
header::FORWARDED,
|
||||
header::HeaderValue::from_static("for=192.0.2.60;proto=http;by=203.0.113.43"),
|
||||
))
|
||||
.to_srv_request();
|
||||
|
||||
let now = OffsetDateTime::now_utc();
|
||||
for unit in &mut format.0 {
|
||||
unit.render_request(now, &req);
|
||||
}
|
||||
|
||||
let resp = HttpResponse::build(StatusCode::OK).force_close().finish();
|
||||
for unit in &mut format.0 {
|
||||
unit.render_response(&resp);
|
||||
}
|
||||
|
||||
let entry_time = OffsetDateTime::now_utc();
|
||||
let render = |fmt: &mut fmt::Formatter<'_>| {
|
||||
for unit in &format.0 {
|
||||
unit.render(fmt, 1024, entry_time)?;
|
||||
}
|
||||
Ok(())
|
||||
};
|
||||
let s = format!("{}", FormatDisplay(&render));
|
||||
assert_eq!(s, "%{r}a");
|
||||
}
|
||||
|
||||
#[actix_rt::test]
|
||||
async fn test_url_path() {
|
||||
let mut format = Format::new("%T %U");
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@ use std::cell::RefCell;
|
|||
use std::fmt;
|
||||
use std::future::Future;
|
||||
use std::rc::Rc;
|
||||
use std::task::Poll;
|
||||
|
||||
use actix_http::{Error, Extensions, Response};
|
||||
use actix_router::IntoPattern;
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@ use std::cell::RefCell;
|
|||
use std::fmt;
|
||||
use std::future::Future;
|
||||
use std::rc::Rc;
|
||||
use std::task::Poll;
|
||||
|
||||
use actix_http::Extensions;
|
||||
use actix_router::{ResourceDef, Router};
|
||||
|
|
|
|||
|
|
@ -12,13 +12,6 @@ use actix_http::{
|
|||
use actix_server::{Server, ServerBuilder};
|
||||
use actix_service::{map_config, IntoServiceFactory, Service, ServiceFactory};
|
||||
|
||||
#[cfg(unix)]
|
||||
use actix_http::Protocol;
|
||||
#[cfg(unix)]
|
||||
use actix_service::pipeline_factory;
|
||||
#[cfg(unix)]
|
||||
use futures_util::future::ok;
|
||||
|
||||
#[cfg(feature = "openssl")]
|
||||
use actix_tls::accept::openssl::{AlpnError, SslAcceptor, SslAcceptorBuilder};
|
||||
#[cfg(feature = "rustls")]
|
||||
|
|
@ -489,7 +482,9 @@ where
|
|||
#[cfg(unix)]
|
||||
/// Start listening for unix domain (UDS) connections on existing listener.
|
||||
pub fn listen_uds(mut self, lst: std::os::unix::net::UnixListener) -> io::Result<Self> {
|
||||
use actix_http::Protocol;
|
||||
use actix_rt::net::UnixStream;
|
||||
use actix_service::pipeline_factory;
|
||||
|
||||
let cfg = self.config.clone();
|
||||
let factory = self.factory.clone();
|
||||
|
|
@ -511,13 +506,16 @@ where
|
|||
c.host.clone().unwrap_or_else(|| format!("{}", socket_addr)),
|
||||
);
|
||||
|
||||
pipeline_factory(|io: UnixStream| ok((io, Protocol::Http1, None))).and_then({
|
||||
pipeline_factory(|io: UnixStream| async { Ok((io, Protocol::Http1, None)) })
|
||||
.and_then({
|
||||
let svc = HttpService::build()
|
||||
.keep_alive(c.keep_alive)
|
||||
.client_timeout(c.client_timeout);
|
||||
|
||||
let svc = if let Some(handler) = on_connect_fn.clone() {
|
||||
svc.on_connect_ext(move |io: &_, ext: _| (&*handler)(io as &dyn Any, ext))
|
||||
svc.on_connect_ext(move |io: &_, ext: _| {
|
||||
(&*handler)(io as &dyn Any, ext)
|
||||
})
|
||||
} else {
|
||||
svc
|
||||
};
|
||||
|
|
@ -534,7 +532,9 @@ where
|
|||
where
|
||||
A: AsRef<std::path::Path>,
|
||||
{
|
||||
use actix_http::Protocol;
|
||||
use actix_rt::net::UnixStream;
|
||||
use actix_service::pipeline_factory;
|
||||
|
||||
let cfg = self.config.clone();
|
||||
let factory = self.factory.clone();
|
||||
|
|
@ -555,7 +555,8 @@ where
|
|||
socket_addr,
|
||||
c.host.clone().unwrap_or_else(|| format!("{}", socket_addr)),
|
||||
);
|
||||
pipeline_factory(|io: UnixStream| ok((io, Protocol::Http1, None))).and_then(
|
||||
pipeline_factory(|io: UnixStream| async { Ok((io, Protocol::Http1, None)) })
|
||||
.and_then(
|
||||
HttpService::build()
|
||||
.keep_alive(c.keep_alive)
|
||||
.client_timeout(c.client_timeout)
|
||||
|
|
|
|||
|
|
@ -106,6 +106,18 @@ impl<T> ops::DerefMut for Form<T> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<T> Serialize for Form<T>
|
||||
where
|
||||
T: Serialize,
|
||||
{
|
||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
||||
where
|
||||
S: serde::Serializer,
|
||||
{
|
||||
self.0.serialize(serializer)
|
||||
}
|
||||
}
|
||||
|
||||
/// See [here](#extractor) for example of usage as an extractor.
|
||||
impl<T> FromRequest for Form<T>
|
||||
where
|
||||
|
|
@ -400,12 +412,8 @@ mod tests {
|
|||
UrlencodedError::Overflow { .. } => {
|
||||
matches!(other, UrlencodedError::Overflow { .. })
|
||||
}
|
||||
UrlencodedError::UnknownLength => {
|
||||
matches!(other, UrlencodedError::UnknownLength)
|
||||
}
|
||||
UrlencodedError::ContentType => {
|
||||
matches!(other, UrlencodedError::ContentType)
|
||||
}
|
||||
UrlencodedError::UnknownLength => matches!(other, UrlencodedError::UnknownLength),
|
||||
UrlencodedError::ContentType => matches!(other, UrlencodedError::ContentType),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -114,6 +114,18 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
impl<T> Serialize for Json<T>
|
||||
where
|
||||
T: Serialize,
|
||||
{
|
||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
||||
where
|
||||
S: serde::Serializer,
|
||||
{
|
||||
self.0.serialize(serializer)
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates response with OK status code, correct content type header, and serialized JSON payload.
|
||||
///
|
||||
/// If serialization failed
|
||||
|
|
@ -441,9 +453,7 @@ mod tests {
|
|||
fn json_eq(err: JsonPayloadError, other: JsonPayloadError) -> bool {
|
||||
match err {
|
||||
JsonPayloadError::Overflow => matches!(other, JsonPayloadError::Overflow),
|
||||
JsonPayloadError::ContentType => {
|
||||
matches!(other, JsonPayloadError::ContentType)
|
||||
}
|
||||
JsonPayloadError::ContentType => matches!(other, JsonPayloadError::ContentType),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ async fn test_start() {
|
|||
}
|
||||
|
||||
#[cfg(feature = "openssl")]
|
||||
fn ssl_acceptor() -> std::io::Result<SslAcceptorBuilder> {
|
||||
fn ssl_acceptor() -> SslAcceptorBuilder {
|
||||
use openssl::{
|
||||
pkey::PKey,
|
||||
ssl::{SslAcceptor, SslMethod},
|
||||
|
|
@ -89,7 +89,7 @@ fn ssl_acceptor() -> std::io::Result<SslAcceptorBuilder> {
|
|||
builder.set_certificate(&cert).unwrap();
|
||||
builder.set_private_key(&key).unwrap();
|
||||
|
||||
Ok(builder)
|
||||
builder
|
||||
}
|
||||
|
||||
#[actix_rt::test]
|
||||
|
|
@ -102,7 +102,7 @@ async fn test_start_ssl() {
|
|||
|
||||
thread::spawn(move || {
|
||||
let sys = actix_rt::System::new();
|
||||
let builder = ssl_acceptor().unwrap();
|
||||
let builder = ssl_acceptor();
|
||||
|
||||
let srv = HttpServer::new(|| {
|
||||
App::new().service(web::resource("/").route(web::to(|req: HttpRequest| {
|
||||
|
|
|
|||
Loading…
Reference in New Issue