mirrors/ntex
1
0
Fork 0
mirror of https://github.com/ntex-rs/ntex.git synced 2025-04-06 22:37:39 +03:00
Code Issues Projects Releases Packages Wiki Activity

update ServiceFactory api usage

Browse source
This commit is contained in:
Nikolay Kim 2021-12-24 03:55:14 +06:00
parent 15025b89c1
commit 7557c287b5
82 changed files with 475 additions and 796 deletions
Download patch file Download diff file Expand all files Collapse all files

4
ntex/examples/basic.rs
View file

@ -28,9 +28,7 @@ async fn main() -> std::io::Result<()> {
.service((index, no_params))
.service(
web::resource("/resource2/index.html")
.wrap(
middleware::DefaultHeaders::new().header("X-Version-R2", "0.3"),
)
.wrap(middleware::DefaultHeaders::new().header("X-Version-R2", "0.3"))
.default_service(
web::route().to(|| async { HttpResponse::MethodNotAllowed() }),
)

4
ntex/examples/uds.rs
View file

@ -29,9 +29,7 @@ async fn main() -> std::io::Result<()> {
.service((index, no_params))
.service(
web::resource("/resource2/index.html")
.wrap(
middleware::DefaultHeaders::new().header("X-Version-R2", "0.3"),
)
.wrap(middleware::DefaultHeaders::new().header("X-Version-R2", "0.3"))
.default_service(
web::route().to(|| async { HttpResponse::MethodNotAllowed() }),
)

4
ntex/src/connect/mod.rs
View file

@ -26,7 +26,5 @@ where
T: Address + 'static,
Connect<T>: From<U>,
{
service::ConnectServiceResponse::new(Box::pin(
Resolver::new().lookup(message.into()),
))
service::ConnectServiceResponse::new(Box::pin(Resolver::new().lookup(message.into())))
}

13
ntex/src/connect/openssl.rs
View file

@ -78,7 +78,7 @@ impl<T: Address + 'static> Connector<T> {
}
/// Produce sealed io stream (IoBoxed)
pub fn seal(self) -> SealedService<Connector<T>> {
pub fn seal(self) -> SealedService<Connector<T>, Connect<T>> {
SealedService::new(self)
}
}
@ -92,22 +92,20 @@ impl<T> Clone for Connector<T> {
}
}
impl<T: Address + 'static> ServiceFactory for Connector<T> {
type Request = Connect<T>;
impl<T: Address, C> ServiceFactory<Connect<T>, C> for Connector<T> {
type Response = Io<SslFilter<Base>>;
type Error = ConnectError;
type Config = ();
type Service = Connector<T>;
type InitError = ();
type Future = Ready<Self::Service, Self::InitError>;
fn new_service(&self, _: ()) -> Self::Future {
#[inline]
fn new_service(&self, _: C) -> Self::Future {
Ready::Ok(self.clone())
}
}
impl<T: Address + 'static> Service for Connector<T> {
type Request = Connect<T>;
impl<T: Address> Service<Connect<T>> for Connector<T> {
type Response = Io<SslFilter<Base>>;
type Error = ConnectError;
type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
@ -117,6 +115,7 @@ impl<T: Address + 'static> Service for Connector<T> {
Poll::Ready(Ok(()))
}
#[inline]
fn call(&self, req: Connect<T>) -> Self::Future {
Box::pin(self.connect(req))
}

6
ntex/src/connect/resolve.rs
View file

@ -102,15 +102,15 @@ impl<T> Clone for Resolver<T> {
}
}
impl<T: Address> ServiceFactory<Connect<T>> for Resolver<T> {
impl<T: Address, C> ServiceFactory<Connect<T>, C> for Resolver<T> {
type Response = Connect<T>;
type Error = ConnectError;
type Config = ();
type Service = Resolver<T>;
type InitError = ();
type Future = Ready<Self::Service, Self::InitError>;
fn new_service(&self, _: ()) -> Self::Future {
#[inline]
fn new_service(&self, _: C) -> Self::Future {
Ready::Ok(self.clone())
}
}

20
ntex/src/connect/rustls.rs
View file

@ -82,7 +82,7 @@ impl<T: Address + 'static> Connector<T> {
}
/// Produce sealed io stream (IoBoxed)
pub fn seal(self) -> SealedService<Connector<T>> {
pub fn seal(self) -> SealedService<Connector<T>, Connect<T>> {
SealedService::new(self)
}
}
@ -96,22 +96,20 @@ impl<T> Clone for Connector<T> {
}
}
impl<T: Address + 'static> ServiceFactory for Connector<T> {
type Request = Connect<T>;
impl<T: Address, C> ServiceFactory<Connect<T>, C> for Connector<T> {
type Response = Io<TlsFilter<Base>>;
type Error = ConnectError;
type Config = ();
type Service = Connector<T>;
type InitError = ();
type Future = Ready<Self::Service, Self::InitError>;
fn new_service(&self, _: ()) -> Self::Future {
#[inline]
fn new_service(&self, _: C) -> Self::Future {
Ready::Ok(self.clone())
}
}
impl<T: Address + 'static> Service for Connector<T> {
type Request = Connect<T>;
impl<T: Address> Service<Connect<T>> for Connector<T> {
type Response = Io<TlsFilter<Base>>;
type Error = ConnectError;
type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
@ -140,15 +138,15 @@ mod tests {
});
let mut cert_store = RootCertStore::empty();
cert_store.add_server_trust_anchors(
webpki_roots::TLS_SERVER_ROOTS.0.iter().map(|ta| {
cert_store.add_server_trust_anchors(webpki_roots::TLS_SERVER_ROOTS.0.iter().map(
|ta| {
OwnedTrustAnchor::from_subject_spki_name_constraints(
ta.subject,
ta.spki,
ta.name_constraints,
)
}),
);
},
));
let config = ClientConfig::builder()
.with_safe_defaults()
.with_root_certificates(cert_store)

10
ntex/src/connect/service.rs
View file

@ -34,10 +34,7 @@ impl<T> Connector<T> {
impl<T: Address> Connector<T> {
/// Resolve and connect to remote host
pub fn connect<U>(
&self,
message: U,
) -> impl Future<Output = Result<Io, ConnectError>>
pub fn connect<U>(&self, message: U) -> impl Future<Output = Result<Io, ConnectError>>
where
Connect<T>: From<U>,
{
@ -68,16 +65,15 @@ impl<T> Clone for Connector<T> {
}
}
impl<T: Address> ServiceFactory<Connect<T>> for Connector<T> {
impl<T: Address, C> ServiceFactory<Connect<T>, C> for Connector<T> {
type Response = Io;
type Error = ConnectError;
type Config = ();
type Service = Connector<T>;
type InitError = ();
type Future = Ready<Self::Service, Self::InitError>;
#[inline]
fn new_service(&self, _: ()) -> Self::Future {
fn new_service(&self, _: C) -> Self::Future {
Ready::Ok(self.clone())
}
}

11
ntex/src/http/body.rs
View file

@ -117,10 +117,7 @@ impl<B: MessageBody> MessageBody for ResponseBody<B> {
impl<B: MessageBody + Unpin> Stream for ResponseBody<B> {
type Item = Result<Bytes, Box<dyn Error>>;
fn poll_next(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Option<Self::Item>> {
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
match self.get_mut() {
ResponseBody::Body(ref mut body) => body.poll_next_chunk(cx),
ResponseBody::Other(ref mut body) => body.poll_next_chunk(cx),
@ -662,8 +659,7 @@ mod tests {
assert!(Body::Empty == Body::Empty);
assert!(Body::Empty != Body::None);
assert!(
Body::Bytes(Bytes::from_static(b"1"))
== Body::Bytes(Bytes::from_static(b"1"))
Body::Bytes(Bytes::from_static(b"1")) == Body::Bytes(Bytes::from_static(b"1"))
);
assert!(Body::Bytes(Bytes::from_static(b"1")) != Body::None);
}
@ -690,8 +686,7 @@ mod tests {
#[crate::rt_test]
async fn body_stream() {
let st =
BodyStream::new(stream::once(Ready::<_, io::Error>::Ok(Bytes::from("1"))));
let st = BodyStream::new(stream::once(Ready::<_, io::Error>::Ok(Bytes::from("1"))));
let body: Body = st.into();
assert!(format!("{:?}", body).contains("Body::Message(_)"));
assert!(body != Body::None);

12
ntex/src/http/builder.rs
View file

@ -46,13 +46,13 @@ impl<F, S> HttpServiceBuilder<F, S, ExpectHandler, UpgradeHandler<F>> {
impl<F, S, X, U> HttpServiceBuilder<F, S, X, U>
where
F: Filter,
S: ServiceFactory<Request, Config = ()> + 'static,
S: ServiceFactory<Request> + 'static,
S::Error: ResponseError,
S::InitError: fmt::Debug,
X: ServiceFactory<Request, Config = (), Response = Request> + 'static,
X: ServiceFactory<Request, Response = Request> + 'static,
X::Error: ResponseError,
X::InitError: fmt::Debug,
U: ServiceFactory<(Request, Io<F>, Codec), Config = (), Response = ()> + 'static,
U: ServiceFactory<(Request, Io<F>, Codec), Response = ()> + 'static,
U::Error: fmt::Display + Error,
U::InitError: fmt::Debug,
{
@ -110,7 +110,7 @@ where
pub fn expect<XF, X1>(self, expect: XF) -> HttpServiceBuilder<F, S, X1, U>
where
XF: IntoServiceFactory<X1, Request>,
X1: ServiceFactory<Request, Config = (), Response = Request> + 'static,
X1: ServiceFactory<Request, Response = Request>,
X1::InitError: fmt::Debug,
{
HttpServiceBuilder {
@ -132,8 +132,7 @@ where
pub fn upgrade<UF, U1>(self, upgrade: UF) -> HttpServiceBuilder<F, S, X, U1>
where
UF: IntoServiceFactory<U1, (Request, Io<F>, Codec)>,
U1: ServiceFactory<(Request, Io<F>, Codec), Config = (), Response = ()>
+ 'static,
U1: ServiceFactory<(Request, Io<F>, Codec), Response = ()>,
U1::Error: fmt::Display + Error,
U1::InitError: fmt::Debug,
{
@ -169,7 +168,6 @@ where
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>>,
S::Future: 'static,
{
let cfg = ServiceConfig::new(
self.keep_alive,

11
ntex/src/http/client/connection.rs
View file

@ -71,22 +71,17 @@ impl Connection {
}
}
pub(super) async fn send_request<
B: MessageBody + 'static,
H: Into<RequestHeadType>,
>(
pub(super) async fn send_request<B: MessageBody + 'static, H: Into<RequestHeadType>>(
mut self,
head: H,
body: B,
) -> Result<(ResponseHead, Payload), SendRequestError> {
match self.io.take().unwrap() {
ConnectionType::H1(io) => {
h1proto::send_request(io, head.into(), body, self.created, self.pool)
.await
h1proto::send_request(io, head.into(), body, self.created, self.pool).await
}
ConnectionType::H2(io) => {
h2proto::send_request(io, head.into(), body, self.created, self.pool)
.await
h2proto::send_request(io, head.into(), body, self.created, self.pool).await
}
}
}

21
ntex/src/http/client/connector.rs
View file

@ -177,11 +177,8 @@ impl Connector {
/// Use custom connector to open un-secured connections.
pub fn connector<T, F>(mut self, connector: T) -> Self
where
T: Service<
TcpConnect<Uri>,
Response = Io<F>,
Error = crate::connect::ConnectError,
> + 'static,
T: Service<TcpConnect<Uri>, Response = Io<F>, Error = crate::connect::ConnectError>
+ 'static,
F: Filter,
{
self.connector =
@ -192,11 +189,8 @@ impl Connector {
/// Use custom connector to open secure connections.
pub fn secure_connector<T, F>(mut self, connector: T) -> Self
where
T: Service<
TcpConnect<Uri>,
Response = Io<F>,
Error = crate::connect::ConnectError,
> + 'static,
T: Service<TcpConnect<Uri>, Response = Io<F>, Error = crate::connect::ConnectError>
+ 'static,
F: Filter,
{
self.ssl_connector = Some(boxed::service(
@ -224,8 +218,7 @@ impl Connector {
pub fn finish(
self,
) -> impl Service<Connect, Response = Connection, Error = ConnectError> + Clone {
let tcp_service =
connector(self.connector, self.timeout, self.disconnect_timeout);
let tcp_service = connector(self.connector, self.timeout, self.disconnect_timeout);
let ssl_pool = if let Some(ssl_connector) = self.ssl_connector {
let srv = connector(ssl_connector, self.timeout, self.disconnect_timeout);
@ -257,8 +250,8 @@ fn connector(
connector: BoxedConnector,
timeout: Millis,
disconnect_timeout: Millis,
) -> impl Service<Connect, Response = IoBoxed, Error = ConnectError, Future = impl Unpin>
+ Unpin {
) -> impl Service<Connect, Response = IoBoxed, Error = ConnectError, Future = impl Unpin> + Unpin
{
TimeoutService::new(
timeout,
apply_fn(connector, |msg: Connect, srv| {

3
ntex/src/http/client/pool.rs
View file

@ -243,8 +243,7 @@ impl Inner {
continue;
}
let is_valid = s.with_read_buf(|buf| {
if buf.is_empty() || (buf.len() == 2 && &buf[..] == b"\r\n")
{
if buf.is_empty() || (buf.len() == 2 && &buf[..] == b"\r\n") {
buf.clear();
true
} else {

9
ntex/src/http/client/request.rs
View file

@ -502,10 +502,8 @@ impl ClientRequest {
if let Some(ref mut jar) = self.cookies {
let mut cookie = String::new();
for c in jar.delta() {
let name = percent_encode(
c.name().as_bytes(),
crate::http::helpers::USERINFO,
);
let name =
percent_encode(c.name().as_bytes(), crate::http::helpers::USERINFO);
let value = percent_encode(
c.value().as_bytes(),
crate::http::helpers::USERINFO,
@ -534,8 +532,7 @@ impl ClientRequest {
} else {
#[cfg(any(feature = "compress"))]
{
slf =
slf.set_header_if_none(header::ACCEPT_ENCODING, "gzip, deflate")
slf = slf.set_header_if_none(header::ACCEPT_ENCODING, "gzip, deflate")
}
};
}

16
ntex/src/http/client/response.rs
View file

@ -45,8 +45,8 @@ impl HttpMessage for ClientResponse {
if self.message_extensions().get::<Cookies>().is_none() {
let mut cookies = Vec::new();
for hdr in self.message_headers().get_all(&SET_COOKIE) {
let s = std::str::from_utf8(hdr.as_bytes())
.map_err(CookieParseError::from)?;
let s =
std::str::from_utf8(hdr.as_bytes()).map_err(CookieParseError::from)?;
cookies.push(Cookie::parse_encoded(s)?.into_owned());
}
self.message_extensions_mut().insert(Cookies(cookies));
@ -140,10 +140,7 @@ impl ClientResponse {
impl Stream for ClientResponse {
type Item = Result<Bytes, PayloadError>;
fn poll_next(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Option<Self::Item>> {
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
Pin::new(&mut self.get_mut().payload).poll_next(cx)
}
}
@ -301,9 +298,7 @@ where
if let Some(len) = self.length.take() {
if len > self.fut.as_ref().unwrap().limit {
return Poll::Ready(Err(JsonPayloadError::Payload(
PayloadError::Overflow,
)));
return Poll::Ready(Err(JsonPayloadError::Payload(PayloadError::Overflow)));
}
}
@ -370,8 +365,7 @@ mod tests {
_ => unreachable!("error"),
}
let mut req =
TestResponse::with_header(header::CONTENT_LENGTH, "1000000").finish();
let mut req = TestResponse::with_header(header::CONTENT_LENGTH, "1000000").finish();
match req.body().await.err().unwrap() {
PayloadError::Overflow => (),
_ => unreachable!("error"),

16
ntex/src/http/client/sender.rs
View file

@ -160,8 +160,7 @@ impl RequestHeadType {
Err(e) => return SendRequestError::Error(Box::new(e)).into(),
};
if let Err(e) = self.set_header_if_none(header::CONTENT_TYPE, "application/json")
{
if let Err(e) = self.set_header_if_none(header::CONTENT_TYPE, "application/json") {
return e.into();
}
@ -188,10 +187,9 @@ impl RequestHeadType {
};
// set content-type
if let Err(e) = self.set_header_if_none(
header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
) {
if let Err(e) = self
.set_header_if_none(header::CONTENT_TYPE, "application/x-www-form-urlencoded")
{
return e.into();
}
@ -235,11 +233,7 @@ impl RequestHeadType {
self.send_body(addr, response_decompress, timeout, config, Body::None)
}
fn set_header_if_none<V>(
&mut self,
key: HeaderName,
value: V,
) -> Result<(), HttpError>
fn set_header_if_none<V>(&mut self, key: HeaderName, value: V) -> Result<(), HttpError>
where
HeaderValue: TryFrom<V>,
<HeaderValue as TryFrom<V>>::Error: Into<HttpError>,

12
ntex/src/http/encoding/decoder.rs
View file

@ -26,15 +26,15 @@ where
#[inline]
pub fn new(stream: S, encoding: ContentEncoding) -> Decoder<S> {
let decoder = match encoding {
ContentEncoding::Br => Some(ContentDecoder::Br(Box::new(
BrotliDecoder::new(Writer::new()),
))),
ContentEncoding::Br => Some(ContentDecoder::Br(Box::new(BrotliDecoder::new(
Writer::new(),
)))),
ContentEncoding::Deflate => Some(ContentDecoder::Deflate(Box::new(
ZlibDecoder::new(Writer::new()),
))),
ContentEncoding::Gzip => Some(ContentDecoder::Gzip(Box::new(
GzDecoder::new(Writer::new()),
))),
ContentEncoding::Gzip => Some(ContentDecoder::Gzip(Box::new(GzDecoder::new(
Writer::new(),
)))),
_ => None,
};
Decoder {

8
ntex/src/http/encoding/encoder.rs
View file

@ -92,9 +92,7 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
if let Some(ref mut fut) = self.fut {
let mut encoder = match Pin::new(fut).poll(cx) {
Poll::Ready(Ok(Ok(item))) => item,
Poll::Ready(Ok(Err(e))) => {
return Poll::Ready(Some(Err(Box::new(e))))
}
Poll::Ready(Ok(Err(e))) => return Poll::Ready(Some(Err(Box::new(e)))),
Poll::Ready(Err(_)) => {
return Poll::Ready(Some(Err(Box::new(io::Error::new(
io::ErrorKind::Other,
@ -177,9 +175,7 @@ enum ContentEncoder {
impl ContentEncoder {
fn can_encode(encoding: ContentEncoding) -> bool {
match encoding {
ContentEncoding::Deflate | ContentEncoding::Gzip | ContentEncoding::Br => {
true
}
ContentEncoding::Deflate | ContentEncoding::Gzip | ContentEncoding::Br => true,
_ => false,
}
}

6
ntex/src/http/error.rs
View file

@ -287,16 +287,14 @@ mod tests {
#[test]
fn test_payload_error() {
let err: PayloadError =
io::Error::new(io::ErrorKind::Other, "ParseError").into();
let err: PayloadError = io::Error::new(io::ErrorKind::Other, "ParseError").into();
assert!(format!("{}", err).contains("ParseError"));
let err: PayloadError = BlockingError::Canceled.into();
assert!(format!("{}", err).contains("Operation is canceled"));
let err: PayloadError =
BlockingError::Error(io::Error::new(io::ErrorKind::Other, "ParseError"))
.into();
BlockingError::Error(io::Error::new(io::ErrorKind::Other, "ParseError")).into();
assert!(format!("{}", err).contains("ParseError"));
let err = PayloadError::Incomplete(None);

4
ntex/src/http/h1/client.rs
View file

@ -134,9 +134,7 @@ impl Decoder for ClientCodec {
PayloadType::None => {
self.inner.payload.borrow_mut().take();
}
PayloadType::Payload(pl) => {
*self.inner.payload.borrow_mut() = Some(pl)
}
PayloadType::Payload(pl) => *self.inner.payload.borrow_mut() = Some(pl),
PayloadType::Stream(pl) => {
*self.inner.payload.borrow_mut() = Some(pl);
let mut flags = self.inner.flags.get();

15
ntex/src/http/h1/decoder.rs
View file

@ -79,8 +79,7 @@ pub(super) trait MessageType: Sized {
let headers = self.headers_mut();
for idx in raw_headers.iter() {
let name =
HeaderName::from_bytes(&slice[idx.name.0..idx.name.1]).unwrap();
let name = HeaderName::from_bytes(&slice[idx.name.0..idx.name.1]).unwrap();
// Unsafe: httparse check header value for valid utf-8
let value = unsafe {
@ -121,8 +120,7 @@ pub(super) trait MessageType: Sized {
header::TRANSFER_ENCODING => {
seen_te = true;
if let Ok(s) = value.to_str().map(str::trim) {
if s.eq_ignore_ascii_case("chunked")
&& content_length.is_none()
if s.eq_ignore_ascii_case("chunked") && content_length.is_none()
{
chunked = true
} else if s.eq_ignore_ascii_case("identity") {
@ -600,9 +598,9 @@ impl ChunkedState {
match byte!(rdr) {
b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
// strictly 0x20 (space) should be disallowed but we don't parse quoted strings here
0x00..=0x08 | 0x0a..=0x1f | 0x7f => Poll::Ready(Err(
ParseError::InvalidInput("Invalid character in chunk extension"),
)),
0x00..=0x08 | 0x0a..=0x1f | 0x7f => Poll::Ready(Err(ParseError::InvalidInput(
"Invalid character in chunk extension",
))),
_ => Poll::Ready(Ok(ChunkedState::Extension)), // no supported extensions
}
}
@ -770,8 +768,7 @@ mod tests {
#[test]
fn test_parse_body() {
let mut buf =
BytesMut::from("GET /test HTTP/1.1\r\nContent-Length: 4\r\n\r\nbody");
let mut buf = BytesMut::from("GET /test HTTP/1.1\r\nContent-Length: 4\r\n\r\nbody");
let reader = MessageDecoder::<Request>::default();
let (req, pl) = reader.decode(&mut buf).unwrap().unwrap();

53
ntex/src/http/h1/dispatcher.rs
View file

@ -89,10 +89,7 @@ where
U::Error: Error + fmt::Display,
{
/// Construct new `Dispatcher` instance with outgoing messages stream.
pub(in crate::http) fn new(
io: Io<F>,
config: Rc<DispatcherConfig<S, X, U>>,
) -> Self {
pub(in crate::http) fn new(io: Io<F>, config: Rc<DispatcherConfig<S, X, U>>) -> Self {
let mut expire = now();
let state = io.get_ref();
let codec = Codec::new(config.timer.clone(), config.keep_alive_enabled());
@ -156,9 +153,7 @@ where
let (res, body) = res.into().into_parts();
*this.st = this.inner.send_response(res, body)
}
Err(e) => {
*this.st = this.inner.handle_error(e, false)
}
Err(e) => *this.st = this.inner.handle_error(e, false),
},
Poll::Pending => {
// we might need to read more data into a request payload
@ -184,9 +179,7 @@ where
CallStateProject::Expect { fut } => match ready!(fut.poll(cx)) {
Ok(req) => {
let result = this.inner.state.with_write_buf(|buf| {
buf.extend_from_slice(
b"HTTP/1.1 100 Continue\r\n\r\n",
)
buf.extend_from_slice(b"HTTP/1.1 100 Continue\r\n\r\n")
});
if result.is_err() {
*this.st = State::Stop;
@ -348,8 +341,7 @@ where
Err(Either::Left(err)) => {
// Malformed requests, respond with 400
log::trace!("malformed request: {:?}", err);
let (res, body) =
Response::BadRequest().finish().into_parts();
let (res, body) = Response::BadRequest().finish().into_parts();
this.inner.error = Some(DispatchError::Parse(err));
*this.st = this.inner.send_response(res, body.into_body());
}
@ -374,8 +366,7 @@ where
if !this.inner.state.is_io_open() {
let e = this.inner.state.take_error().into();
set_error!(this, e);
} else if let Poll::Ready(Err(e)) =
this.inner.poll_request_payload(cx)
} else if let Poll::Ready(Err(e)) = this.inner.poll_request_payload(cx)
{
set_error!(this, e);
} else {
@ -397,13 +388,11 @@ where
let req = req.take().unwrap();
// Handle UPGRADE request
crate::rt::spawn(
this.inner.config.upgrade.as_ref().unwrap().call((
req,
io,
this.inner.codec.clone(),
)),
);
crate::rt::spawn(this.inner.config.upgrade.as_ref().unwrap().call((
req,
io,
this.inner.codec.clone(),
)));
return Poll::Ready(Ok(()));
}
// prepare to shutdown
@ -423,13 +412,11 @@ where
));
}
return Poll::Ready(
if let Some(err) = this.inner.error.take() {
Err(err)
} else {
Ok(())
},
);
return Poll::Ready(if let Some(err) = this.inner.error.take() {
Err(err)
} else {
Ok(())
});
} else {
return Poll::Pending;
}
@ -616,9 +603,7 @@ where
self.payload = None;
return Poll::Ready(Err(match e {
Either::Left(e) => DispatchError::Parse(e),
Either::Right(e) => {
DispatchError::Disconnect(Some(e))
}
Either::Right(e) => DispatchError::Disconnect(Some(e)),
}));
}
Poll::Pending => break,
@ -780,8 +765,7 @@ mod tests {
assert!(h1.inner.state.is_closed());
sleep(Millis(50)).await;
client
.local_buffer(|buf| assert_eq!(&buf[..26], b"HTTP/1.1 400 Bad Request\r\n"));
client.local_buffer(|buf| assert_eq!(&buf[..26], b"HTTP/1.1 400 Bad Request\r\n"));
client.close().await;
assert!(lazy(|cx| Pin::new(&mut h1).poll(cx)).await.is_ready());
@ -978,8 +962,7 @@ mod tests {
assert_eq!(client.remote_buffer(|buf| buf.len()), 0);
// io should be drained only by no more than MAX_BUFFER_SIZE
let random_bytes: Vec<u8> =
(0..1_048_576).map(|_| rand::random::<u8>()).collect();
let random_bytes: Vec<u8> = (0..1_048_576).map(|_| rand::random::<u8>()).collect();
client.write(random_bytes);
sleep(Millis(50)).await;

38
ntex/src/http/h1/encoder.rs
View file

@ -64,9 +64,9 @@ pub(super) trait MessageType: Sized {
// Content length
if let Some(status) = self.status() {
match status {
StatusCode::NO_CONTENT
| StatusCode::CONTINUE
| StatusCode::PROCESSING => length = BodySize::None,
StatusCode::NO_CONTENT | StatusCode::CONTINUE | StatusCode::PROCESSING => {
length = BodySize::None
}
StatusCode::SWITCHING_PROTOCOLS => {
skip_len = true;
length = BodySize::Stream;
@ -259,10 +259,7 @@ impl MessageType for RequestHeadType {
Version::HTTP_10 => "HTTP/1.0",
Version::HTTP_11 => "HTTP/1.1",
_ =>
return Err(io::Error::new(
io::ErrorKind::Other,
"unsupported version"
)),
return Err(io::Error::new(io::ErrorKind::Other, "unsupported version")),
}
)
.map_err(|e| io::Error::new(io::ErrorKind::Other, e))
@ -271,11 +268,7 @@ impl MessageType for RequestHeadType {
impl<T: MessageType> MessageEncoder<T> {
/// Encode message
pub(super) fn encode_chunk(
&self,
msg: &[u8],
buf: &mut BytesMut,
) -> io::Result<bool> {
pub(super) fn encode_chunk(&self, msg: &[u8], buf: &mut BytesMut) -> io::Result<bool> {
let mut te = self.te.get();
let result = te.encode(msg, buf);
self.te.set(te);
@ -480,11 +473,7 @@ fn write_status_line(version: Version, mut n: u16, bytes: &mut BytesMut) {
} else {
let d1 = n << 1;
curr -= 2;
ptr::copy_nonoverlapping(
lut_ptr.offset(d1 as isize),
buf_ptr.offset(curr),
2,
);
ptr::copy_nonoverlapping(lut_ptr.offset(d1 as isize), buf_ptr.offset(curr), 2);
}
}
@ -498,15 +487,15 @@ fn write_status_line(version: Version, mut n: u16, bytes: &mut BytesMut) {
fn write_content_length(mut n: u64, bytes: &mut BytesMut) {
if n < 10 {
let mut buf: [u8; 21] = [
b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l', b'e',
b'n', b'g', b't', b'h', b':', b' ', b'0', b'\r', b'\n',
b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l', b'e', b'n',
b'g', b't', b'h', b':', b' ', b'0', b'\r', b'\n',
];
buf[18] = (n as u8) + b'0';
bytes.extend_from_slice(&buf);
} else if n < 100 {
let mut buf: [u8; 22] = [
b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l', b'e',
b'n', b'g', b't', b'h', b':', b' ', b'0', b'0', b'\r', b'\n',
b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l', b'e', b'n',
b'g', b't', b'h', b':', b' ', b'0', b'0', b'\r', b'\n',
];
let d1 = n << 1;
unsafe {
@ -519,8 +508,8 @@ fn write_content_length(mut n: u64, bytes: &mut BytesMut) {
bytes.extend_from_slice(&buf);
} else if n < 1000 {
let mut buf: [u8; 23] = [
b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l', b'e',
b'n', b'g', b't', b'h', b':', b' ', b'0', b'0', b'0', b'\r', b'\n',
b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l', b'e', b'n',
b'g', b't', b'h', b':', b' ', b'0', b'0', b'0', b'\r', b'\n',
];
// decode 2 more chars, if > 2 chars
let d1 = (n % 100) << 1;
@ -640,8 +629,7 @@ mod tests {
ConnectionType::Close,
&DateService::default(),
);
let data =
String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
let data = String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
assert!(data.contains("content-length: 0\r\n"));
assert!(data.contains("connection: close\r\n"));
assert!(data.contains("authorization: another authorization\r\n"));

1
ntex/src/http/h1/expect.rs
View file

@ -7,7 +7,6 @@ use crate::{util::Ready, Service, ServiceFactory};
pub struct ExpectHandler;
impl ServiceFactory<Request> for ExpectHandler {
type Config = ();
type Response = Request;
type Error = io::Error;
type Service = ExpectHandler;

39
ntex/src/http/h1/service.rs
View file

@ -29,7 +29,7 @@ pub struct H1Service<F, S, B, X = ExpectHandler, U = UpgradeHandler<F>> {
impl<F, S, B> H1Service<F, S, B>
where
S: ServiceFactory<Request, Config = ()>,
S: ServiceFactory<Request>,
S::Error: ResponseError + 'static,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>>,
@ -63,21 +63,17 @@ mod openssl {
impl<F, S, B, X, U> H1Service<SslFilter<F>, S, B, X, U>
where
F: Filter,
S: ServiceFactory<Request, Config = ()>,
S: ServiceFactory<Request>,
S::Error: ResponseError + 'static,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>>,
S::Future: 'static,
B: MessageBody,
X: ServiceFactory<Request, Config = (), Response = Request>,
X: ServiceFactory<Request, Response = Request>,
X::Error: ResponseError + 'static,
X::InitError: fmt::Debug,
X::Future: 'static,
U: ServiceFactory<
(Request, Io<SslFilter<F>>, Codec),
Config = (),
Response = (),
> + 'static,
U: ServiceFactory<(Request, Io<SslFilter<F>>, Codec), Response = ()> + 'static,
U::Error: fmt::Display + Error,
U::InitError: fmt::Debug,
{
@ -87,7 +83,6 @@ mod openssl {
acceptor: SslAcceptor,
) -> impl ServiceFactory<
Io<F>,
Config = (),
Response = (),
Error = SslError<DispatchError>,
InitError = (),
@ -116,21 +111,17 @@ mod rustls {
impl<F, S, B, X, U> H1Service<TlsFilter<F>, S, B, X, U>
where
F: Filter,
S: ServiceFactory<Request, Config = ()>,
S: ServiceFactory<Request>,
S::Error: ResponseError + 'static,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>>,
S::Future: 'static,
B: MessageBody,
X: ServiceFactory<Request, Config = (), Response = Request>,
X: ServiceFactory<Request, Response = Request>,
X::Error: ResponseError + 'static,
X::InitError: fmt::Debug,
X::Future: 'static,
U: ServiceFactory<
(Request, Io<TlsFilter<F>>, Codec),
Config = (),
Response = (),
> + 'static,
U: ServiceFactory<(Request, Io<TlsFilter<F>>, Codec), Response = ()> + 'static,
U::Error: fmt::Display + Error,
U::InitError: fmt::Debug,
{
@ -140,7 +131,6 @@ mod rustls {
config: ServerConfig,
) -> impl ServiceFactory<
Io<F>,
Config = (),
Response = (),
Error = SslError<DispatchError>,
InitError = (),
@ -159,7 +149,7 @@ mod rustls {
impl<F, S, B, X, U> H1Service<F, S, B, X, U>
where
F: Filter,
S: ServiceFactory<Request, Config = ()>,
S: ServiceFactory<Request>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>>,
S::InitError: fmt::Debug,
@ -214,21 +204,20 @@ where
impl<F, S, B, X, U> ServiceFactory<Io<F>> for H1Service<F, S, B, X, U>
where
F: Filter + 'static,
S: ServiceFactory<Request, Config = ()>,
S: ServiceFactory<Request>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>>,
S::InitError: fmt::Debug,
S::Future: 'static,
B: MessageBody,
X: ServiceFactory<Request, Config = (), Response = Request>,
X: ServiceFactory<Request, Response = Request>,
X::Error: ResponseError + 'static,
X::InitError: fmt::Debug,
X::Future: 'static,
U: ServiceFactory<(Request, Io<F>, Codec), Config = (), Response = ()> + 'static,
U: ServiceFactory<(Request, Io<F>, Codec), Response = ()> + 'static,
U::Error: fmt::Display + Error,
U::InitError: fmt::Debug,
{
type Config = ();
type Response = ();
type Error = DispatchError;
type InitError = ();
@ -336,11 +325,7 @@ where
}
}
fn poll_shutdown(
&self,
cx: &mut task::Context<'_>,
is_error: bool,
) -> task::Poll<()> {
fn poll_shutdown(&self, cx: &mut task::Context<'_>, is_error: bool) -> task::Poll<()> {
let ready = self.config.expect.poll_shutdown(cx, is_error).is_ready();
let ready = self.config.service.poll_shutdown(cx, is_error).is_ready() && ready;
let ready = if let Some(ref upg) = self.config.upgrade {

1
ntex/src/http/h1/upgrade.rs
View file

@ -11,7 +11,6 @@ impl<F> ServiceFactory<(Request, Io<F>, Codec)> for UpgradeHandler<F> {
type Response = ();
type Error = io::Error;
type Config = ();
type Service = UpgradeHandler<F>;
type InitError = io::Error;
type Future = Ready<Self::Service, Self::InitError>;

16
ntex/src/http/h2/dispatcher.rs
View file

@ -1,7 +1,5 @@
use std::task::{Context, Poll};
use std::{
convert::TryFrom, future::Future, marker::PhantomData, pin::Pin, rc::Rc, time,
};
use std::{convert::TryFrom, future::Future, marker::PhantomData, pin::Pin, rc::Rc, time};
use h2::server::{Connection, SendResponse};
use h2::SendStream;
@ -51,12 +49,10 @@ where
) -> Self {
// keep-alive timer
let (ka_expire, ka_timer) = if let Some(delay) = timeout {
let expire =
config.timer.now() + std::time::Duration::from(config.keep_alive);
let expire = config.timer.now() + std::time::Duration::from(config.keep_alive);
(expire, Some(delay))
} else if let Some(delay) = config.keep_alive_timer() {
let expire =
config.timer.now() + std::time::Duration::from(config.keep_alive);
let expire = config.timer.now() + std::time::Duration::from(config.keep_alive);
(expire, Some(delay))
} else {
(now(), None)
@ -233,8 +229,7 @@ where
let mut send = send.take().unwrap();
let mut size = body.size();
let h2_res =
self.as_mut().prepare_response(res.head(), &mut size);
let h2_res = self.as_mut().prepare_response(res.head(), &mut size);
this = self.as_mut().project();
let stream = match send.send_response(h2_res, size.is_eof()) {
@ -260,8 +255,7 @@ where
let mut send = send.take().unwrap();
let mut size = body.size();
let h2_res =
self.as_mut().prepare_response(res.head(), &mut size);
let h2_res = self.as_mut().prepare_response(res.head(), &mut size);
this = self.as_mut().project();
let stream = match send.send_response(h2_res, size.is_eof()) {

5
ntex/src/http/h2/mod.rs
View file

@ -26,10 +26,7 @@ impl Payload {
impl Stream for Payload {
type Item = Result<Bytes, PayloadError>;
fn poll_next(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Option<Self::Item>> {
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
let this = self.get_mut();
match Pin::new(&mut this.pl).poll_data(cx) {

35
ntex/src/http/h2/service.rs
View file

@ -26,12 +26,10 @@ pub struct H2Service<F, S, B> {
impl<F, S, B> H2Service<F, S, B>
where
S: ServiceFactory<Request, Config = ()>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>> + 'static,
S::Future: 'static,
<S::Service as Service<Request>>::Future: 'static,
B: MessageBody + 'static,
S: ServiceFactory<Request>,
S::Error: ResponseError,
S::Response: Into<Response<B>>,
B: MessageBody,
{
/// Create new `HttpService` instance with config.
pub(crate) fn with_config<U: IntoServiceFactory<S, Request>>(
@ -61,7 +59,7 @@ mod openssl {
impl<F, S, B> H2Service<SslFilter<F>, S, B>
where
F: Filter,
S: ServiceFactory<Config = (), Request = Request> + 'static,
S: ServiceFactory<Request> + 'static,
S::Error: ResponseError,
S::Response: Into<Response<B>>,
B: MessageBody + 'static,
@ -71,8 +69,7 @@ mod openssl {
self,
acceptor: SslAcceptor,
) -> impl ServiceFactory<
Config = (),
Request = Io<F>,
Io<F>,
Response = (),
Error = SslError<DispatchError>,
InitError = S::InitError,
@ -99,11 +96,9 @@ mod rustls {
impl<F, S, B> H2Service<TlsFilter<F>, S, B>
where
F: Filter,
S: ServiceFactory<Config = (), Request = Request>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>> + 'static,
S::Future: 'static,
<S::Service as Service>::Future: 'static,
S: ServiceFactory<Request> + 'static,
S::Error: ResponseError,
S::Response: Into<Response<B>>,
B: MessageBody + 'static,
{
/// Create openssl based service
@ -111,8 +106,7 @@ mod rustls {
self,
mut config: ServerConfig,
) -> impl ServiceFactory<
Config = (),
Request = Io<F>,
Io<F>,
Response = (),
Error = SslError<DispatchError>,
InitError = S::InitError,
@ -134,14 +128,11 @@ mod rustls {
impl<F, S, B> ServiceFactory<Io<F>> for H2Service<F, S, B>
where
F: Filter,
S: ServiceFactory<Request, Config = ()>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>> + 'static,
S::Future: 'static,
<S::Service as Service<Request>>::Future: 'static,
S: ServiceFactory<Request> + 'static,
S::Error: ResponseError,
S::Response: Into<Response<B>>,
B: MessageBody + 'static,
{
type Config = ();
type Response = ();
type Error = DispatchError;
type InitError = S::InitError;

25
ntex/src/http/header/mod.rs
View file

@ -84,21 +84,20 @@ pub use http::header::{
ACCEPT, ACCEPT_CHARSET, ACCEPT_ENCODING, ACCEPT_LANGUAGE, ACCEPT_RANGES,
ACCESS_CONTROL_ALLOW_CREDENTIALS, ACCESS_CONTROL_ALLOW_HEADERS,
ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN,
ACCESS_CONTROL_EXPOSE_HEADERS, ACCESS_CONTROL_MAX_AGE,
ACCESS_CONTROL_REQUEST_HEADERS, ACCESS_CONTROL_REQUEST_METHOD, AGE, ALLOW, ALT_SVC,
AUTHORIZATION, CACHE_CONTROL, CONNECTION, CONTENT_DISPOSITION, CONTENT_ENCODING,
CONTENT_LANGUAGE, CONTENT_LENGTH, CONTENT_LOCATION, CONTENT_RANGE,
CONTENT_SECURITY_POLICY, CONTENT_SECURITY_POLICY_REPORT_ONLY, CONTENT_TYPE, COOKIE,
DATE, DNT, ETAG, EXPECT, EXPIRES, FORWARDED, FROM, HOST, IF_MATCH,
IF_MODIFIED_SINCE, IF_NONE_MATCH, IF_RANGE, IF_UNMODIFIED_SINCE, LAST_MODIFIED,
LINK, LOCATION, MAX_FORWARDS, ORIGIN, PRAGMA, PROXY_AUTHENTICATE,
PROXY_AUTHORIZATION, PUBLIC_KEY_PINS, PUBLIC_KEY_PINS_REPORT_ONLY, RANGE, REFERER,
REFERRER_POLICY, REFRESH, RETRY_AFTER, SEC_WEBSOCKET_ACCEPT,
ACCESS_CONTROL_EXPOSE_HEADERS, ACCESS_CONTROL_MAX_AGE, ACCESS_CONTROL_REQUEST_HEADERS,
ACCESS_CONTROL_REQUEST_METHOD, AGE, ALLOW, ALT_SVC, AUTHORIZATION, CACHE_CONTROL,
CONNECTION, CONTENT_DISPOSITION, CONTENT_ENCODING, CONTENT_LANGUAGE, CONTENT_LENGTH,
CONTENT_LOCATION, CONTENT_RANGE, CONTENT_SECURITY_POLICY,
CONTENT_SECURITY_POLICY_REPORT_ONLY, CONTENT_TYPE, COOKIE, DATE, DNT, ETAG, EXPECT,
EXPIRES, FORWARDED, FROM, HOST, IF_MATCH, IF_MODIFIED_SINCE, IF_NONE_MATCH, IF_RANGE,
IF_UNMODIFIED_SINCE, LAST_MODIFIED, LINK, LOCATION, MAX_FORWARDS, ORIGIN, PRAGMA,
PROXY_AUTHENTICATE, PROXY_AUTHORIZATION, PUBLIC_KEY_PINS, PUBLIC_KEY_PINS_REPORT_ONLY,
RANGE, REFERER, REFERRER_POLICY, REFRESH, RETRY_AFTER, SEC_WEBSOCKET_ACCEPT,
SEC_WEBSOCKET_EXTENSIONS, SEC_WEBSOCKET_KEY, SEC_WEBSOCKET_PROTOCOL,
SEC_WEBSOCKET_VERSION, SERVER, SET_COOKIE, STRICT_TRANSPORT_SECURITY, TE, TRAILER,
TRANSFER_ENCODING, UPGRADE, UPGRADE_INSECURE_REQUESTS, USER_AGENT, VARY, VIA,
WARNING, WWW_AUTHENTICATE, X_CONTENT_TYPE_OPTIONS, X_DNS_PREFETCH_CONTROL,
X_FRAME_OPTIONS, X_XSS_PROTECTION,
TRANSFER_ENCODING, UPGRADE, UPGRADE_INSECURE_REQUESTS, USER_AGENT, VARY, VIA, WARNING,
WWW_AUTHENTICATE, X_CONTENT_TYPE_OPTIONS, X_DNS_PREFETCH_CONTROL, X_FRAME_OPTIONS,
X_XSS_PROTECTION,
};
#[cfg(test)]

11
ntex/src/http/httpmessage.rs
View file

@ -186,11 +186,9 @@ mod tests {
let req = TestRequest::with_header("content-type", "applicatjson").finish();
assert_eq!(Some(ContentTypeError::ParseError), req.encoding().err());
let req = TestRequest::with_header(
"content-type",
"application/json; charset=kkkttktk",
)
.finish();
let req =
TestRequest::with_header("content-type", "application/json; charset=kkkttktk")
.finish();
assert_eq!(
Some(ContentTypeError::UnknownEncoding),
req.encoding().err()
@ -202,8 +200,7 @@ mod tests {
let req = TestRequest::default().finish();
assert!(!req.chunked().unwrap());
let req =
TestRequest::with_header(header::TRANSFER_ENCODING, "chunked").finish();
let req = TestRequest::with_header(header::TRANSFER_ENCODING, "chunked").finish();
assert!(req.chunked().unwrap());
let req = TestRequest::default()

5
ntex/src/http/payload.rs
View file

@ -76,10 +76,7 @@ impl Stream for Payload {
type Item = Result<Bytes, PayloadError>;
#[inline]
fn poll_next(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Option<Self::Item>> {
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
match self.get_mut() {
Payload::None => Poll::Ready(None),
Payload::H1(ref mut pl) => pl.readany(cx),

3
ntex/src/http/response.rs
View file

@ -945,8 +945,7 @@ mod tests {
#[test]
fn test_serde_json_in_body() {
use serde_json::json;
let resp =
Response::build(StatusCode::OK).body(json!({"test-key":"test-value"}));
let resp = Response::build(StatusCode::OK).body(json!({"test-key":"test-value"}));
assert_eq!(resp.body().get_ref(), br#"{"test-key":"test-value"}"#);
}

68
ntex/src/http/service.rs
View file

@ -29,7 +29,7 @@ pub struct HttpService<F, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler<F>
impl<F, S, B> HttpService<F, S, B>
where
S: ServiceFactory<Request, Config = ()>,
S: ServiceFactory<Request>,
S::Error: ResponseError + 'static,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>> + 'static,
@ -46,7 +46,7 @@ where
impl<F, S, B> HttpService<F, S, B>
where
F: Filter,
S: ServiceFactory<Request, Config = ()>,
S: ServiceFactory<Request>,
S::Error: ResponseError + 'static,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>> + 'static,
@ -92,7 +92,7 @@ where
impl<F, S, B, X, U> HttpService<F, S, B, X, U>
where
F: Filter,
S: ServiceFactory<Request, Config = ()>,
S: ServiceFactory<Request>,
S::Error: ResponseError + 'static,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>> + 'static,
@ -107,10 +107,9 @@ where
/// request will be forwarded to main service.
pub fn expect<X1>(self, expect: X1) -> HttpService<F, S, B, X1, U>
where
X1: ServiceFactory<Request, Config = (), Response = Request>,
X1: ServiceFactory<Request, Response = Request>,
X1::Error: ResponseError,
X1::InitError: fmt::Debug,
X1::Future: 'static,
{
HttpService {
expect,
@ -128,10 +127,9 @@ where
/// and this service get called with original request and framed object.
pub fn upgrade<U1>(self, upgrade: Option<U1>) -> HttpService<F, S, B, X, U1>
where
U1: ServiceFactory<(Request, Io<F>, h1::Codec), Config = (), Response = ()>,
U1::Error: fmt::Display + error::Error + 'static,
U1: ServiceFactory<(Request, Io<F>, h1::Codec), Response = ()>,
U1::Error: fmt::Display + error::Error,
U1::InitError: fmt::Debug,
U1::Future: 'static,
{
HttpService {
upgrade,
@ -162,23 +160,17 @@ mod openssl {
impl<F, S, B, X, U> HttpService<SslFilter<F>, S, B, X, U>
where
F: Filter,
S: ServiceFactory<Config = (), Request = Request>,
S::Error: ResponseError + 'static,
S: ServiceFactory<Request> + 'static,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>> + 'static,
S::Response: Into<Response<B>>,
S::Future: 'static,
<S::Service as Service>::Future: 'static,
B: MessageBody + 'static,
X: ServiceFactory<Config = (), Request = Request, Response = Request>,
X::Error: ResponseError + 'static,
X: ServiceFactory<Request, Response = Request> + 'static,
X::Error: ResponseError,
X::InitError: fmt::Debug,
X::Future: 'static,
<X::Service as Service>::Future: 'static,
U: ServiceFactory<
Config = (),
Request = (Request, Io<SslFilter<F>>, h1::Codec),
Response = (),
> + 'static,
U: ServiceFactory<(Request, Io<SslFilter<F>>, h1::Codec), Response = ()> + 'static,
U::Error: fmt::Display + error::Error,
U::InitError: fmt::Debug,
{
@ -187,8 +179,7 @@ mod openssl {
self,
acceptor: SslAcceptor,
) -> impl ServiceFactory<
Config = (),
Request = Io<F>,
Io<F>,
Response = (),
Error = SslError<DispatchError>,
InitError = (),
@ -215,23 +206,15 @@ mod rustls {
impl<F, S, B, X, U> HttpService<TlsFilter<F>, S, B, X, U>
where
F: Filter,
S: ServiceFactory<Config = (), Request = Request>,
S::Error: ResponseError + 'static,
S: ServiceFactory<Request> + 'static,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Future: 'static,
S::Response: Into<Response<B>> + 'static,
<S::Service as Service>::Future: 'static,
S::Response: Into<Response<B>>,
B: MessageBody + 'static,
X: ServiceFactory<Config = (), Request = Request, Response = Request>,
X::Error: ResponseError + 'static,
X: ServiceFactory<Request, Response = Request> + 'static,
X::Error: ResponseError,
X::InitError: fmt::Debug,
X::Future: 'static,
<X::Service as Service>::Future: 'static,
U: ServiceFactory<
Config = (),
Request = (Request, Io<TlsFilter<F>>, h1::Codec),
Response = (),
> + 'static,
U: ServiceFactory<(Request, Io<TlsFilter<F>>, h1::Codec), Response = ()> + 'static,
U::Error: fmt::Display + error::Error,
U::InitError: fmt::Debug,
{
@ -240,8 +223,7 @@ mod rustls {
self,
mut config: ServerConfig,
) -> impl ServiceFactory<
Config = (),
Request = Io<F>,
Io<F>,
Response = (),
Error = SslError<DispatchError>,
InitError = (),
@ -263,19 +245,18 @@ mod rustls {
impl<F, S, B, X, U> ServiceFactory<Io<F>> for HttpService<F, S, B, X, U>
where
F: Filter + 'static,
S: ServiceFactory<Request, Config = ()> + 'static,
S: ServiceFactory<Request> + 'static,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>>,
B: MessageBody + 'static,
X: ServiceFactory<Request, Config = (), Response = Request> + 'static,
X: ServiceFactory<Request, Response = Request> + 'static,
X::Error: ResponseError,
X::InitError: fmt::Debug,
U: ServiceFactory<(Request, Io<F>, h1::Codec), Config = (), Response = ()> + 'static,
U: ServiceFactory<(Request, Io<F>, h1::Codec), Response = ()> + 'static,
U::Error: fmt::Display + error::Error,
U::InitError: fmt::Debug,
{
type Config = ();
type Response = ();
type Error = DispatchError;
type InitError = ();
@ -308,8 +289,7 @@ where
None
};
let config =
DispatcherConfig::new(cfg, service, expect, upgrade, on_request);
let config = DispatcherConfig::new(cfg, service, expect, upgrade, on_request);
Ok(HttpServiceHandler {
config: Rc::new(config),

5
ntex/src/http/test.rs
View file

@ -156,8 +156,7 @@ impl TestRequest {
let mut cookie = String::new();
for c in inner.cookies.delta() {
let name = percent_encode(c.name().as_bytes(), super::helpers::USERINFO);
let value =
percent_encode(c.value().as_bytes(), super::helpers::USERINFO);
let value = percent_encode(c.value().as_bytes(), super::helpers::USERINFO);
let _ = write!(&mut cookie, "; {}={}", name, value);
}
if !cookie.is_empty() {
@ -209,7 +208,7 @@ fn parts(parts: &mut Option<Inner>) -> &mut Inner {
pub fn server<F, R>(factory: F) -> TestServer
where
F: Fn() -> R + Send + Clone + 'static,
R: ServiceFactory<Io, Config = ()>,
R: ServiceFactory<Io>,
{
let (tx, rx) = mpsc::channel();

4
ntex/src/lib.rs
View file

@ -41,8 +41,8 @@ pub mod ws;
pub use self::service::{
apply_fn, boxed, fn_factory, fn_factory_with_config, fn_service, into_service,
pipeline, pipeline_factory, IntoService, IntoServiceFactory, Service,
ServiceFactory, Transform,
pipeline, pipeline_factory, IntoService, IntoServiceFactory, Service, ServiceFactory,
Transform,
};
pub use futures_core::stream::Stream;

12
ntex/src/server/accept.rs
View file

@ -1,6 +1,4 @@
use std::{
cell::Cell, io, sync::mpsc, sync::Arc, thread, time::Duration, time::Instant,
};
use std::{cell::Cell, io, sync::mpsc, sync::Arc, thread, time::Duration, time::Instant};
use polling::{Event, Poller};
@ -138,8 +136,7 @@ impl Accept {
.name("ntex-server accept loop".to_owned())
.spawn(move || {
System::set_current(sys);
Accept::new(rx, poller, socks, workers, srv, notify, status_handler)
.poll()
Accept::new(rx, poller, socks, workers, srv, notify, status_handler).poll()
});
}
@ -276,10 +273,7 @@ impl Accept {
let info = &mut self.sockets[key];
if let Some(inst) = info.timeout.get() {
if now > inst && !self.backpressure {
log::info!(
"Resuming socket listener on {} after timeout",
info.addr
);
log::info!("Resuming socket listener on {} after timeout", info.addr);
info.timeout.take();
self.add_source(key);
}

19
ntex/src/server/builder.rs
View file

@ -1,6 +1,4 @@
use std::{
fmt, future::Future, io, marker, mem, net, pin::Pin, task::Context, task::Poll,
};
use std::{fmt, future::Future, io, marker, mem, net, pin::Pin, task::Context, task::Poll};
use async_channel::{unbounded, Receiver};
use async_oneshot as oneshot;
@ -198,7 +196,7 @@ impl ServerBuilder {
where
U: net::ToSocketAddrs,
F: Fn(Config) -> R + Send + Clone + 'static,
R: ServiceFactory<Io, Config = ()>,
R: ServiceFactory<Io>,
{
let sockets = bind_addr(addr, self.backlog)?;
@ -210,11 +208,8 @@ impl ServerBuilder {
factory.clone(),
lst.local_addr()?,
));
self.sockets.push((
token,
name.as_ref().to_string(),
Listener::from_tcp(lst),
));
self.sockets
.push((token, name.as_ref().to_string(), Listener::from_tcp(lst)));
}
Ok(self)
}
@ -226,7 +221,7 @@ impl ServerBuilder {
N: AsRef<str>,
U: AsRef<std::path::Path>,
F: Fn(Config) -> R + Send + Clone + 'static,
R: ServiceFactory<Io, Config = ()>,
R: ServiceFactory<Io>,
{
use std::os::unix::net::UnixListener;
@ -255,7 +250,7 @@ impl ServerBuilder {
) -> io::Result<Self>
where
F: Fn(Config) -> R + Send + Clone + 'static,
R: ServiceFactory<Io, Config = ()>,
R: ServiceFactory<Io>,
{
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
let token = self.token.next();
@ -280,7 +275,7 @@ impl ServerBuilder {
) -> io::Result<Self>
where
F: Fn(Config) -> R + Send + Clone + 'static,
R: ServiceFactory<Io, Config = ()>,
R: ServiceFactory<Io>,
{
let token = self.token.next();
self.services.push(Factory::create(

20
ntex/src/server/config.rs
View file

@ -79,11 +79,7 @@ impl ServiceConfig {
}
/// Add new service to the server.
pub fn listen<N: AsRef<str>>(
&mut self,
name: N,
lst: net::TcpListener,
) -> &mut Self {
pub fn listen<N: AsRef<str>>(&mut self, name: N, lst: net::TcpListener) -> &mut Self {
if !self.applied {
self.apply = Box::new(ConfigWrapper {
f: |_| {
@ -153,8 +149,7 @@ impl InternalServiceFactory for ConfiguredService {
fn create(
&self,
) -> Pin<Box<dyn Future<Output = Result<Vec<(Token, BoxedServerService)>, ()>>>>
{
) -> Pin<Box<dyn Future<Output = Result<Vec<(Token, BoxedServerService)>, ()>>>> {
// configure services
let rt = ServiceRuntime::new(self.topics.clone());
let cfg_fut = self.rt.configure(ServiceRuntime(rt.0.clone()));
@ -283,7 +278,7 @@ impl ServiceRuntime {
pub fn service<T, F>(&self, name: &str, service: F)
where
F: service::IntoServiceFactory<T, Io>,
T: service::ServiceFactory<Io, Config = ()> + 'static,
T: service::ServiceFactory<Io> + 'static,
T::Future: 'static,
T::Service: 'static,
T::InitError: fmt::Debug,
@ -298,7 +293,7 @@ impl ServiceRuntime {
pub fn service_in<T, F>(&self, name: &str, pool: PoolId, service: F)
where
F: service::IntoServiceFactory<T, Io>,
T: service::ServiceFactory<Io, Config = ()> + 'static,
T: service::ServiceFactory<Io> + 'static,
T::Future: 'static,
T::Service: 'static,
T::InitError: fmt::Debug,
@ -333,7 +328,6 @@ type BoxedNewService = Box<
Response = (),
Error = (),
InitError = (),
Config = (),
Service = BoxedServerService,
Future = Pin<Box<dyn Future<Output = Result<BoxedServerService, ()>>>>,
>,
@ -344,10 +338,9 @@ struct ServiceFactory<T> {
pool: PoolId,
}
impl<T> service::ServiceFactory<(Option<CounterGuard>, ServerMessage)>
for ServiceFactory<T>
impl<T> service::ServiceFactory<(Option<CounterGuard>, ServerMessage)> for ServiceFactory<T>
where
T: service::ServiceFactory<Io, Config = ()>,
T: service::ServiceFactory<Io>,
T::Future: 'static,
T::Service: 'static,
T::Error: 'static,
@ -356,7 +349,6 @@ where
type Response = ();
type Error = ();
type InitError = ();
type Config = ();
type Service = BoxedServerService;
type Future = Pin<Box<dyn Future<Output = Result<BoxedServerService, ()>>>>;

10
ntex/src/server/service.rs
View file

@ -21,7 +21,7 @@ pub(super) enum ServerMessage {
}
pub(super) trait StreamServiceFactory: Send + Clone + 'static {
type Factory: ServiceFactory<Io, Config = ()>;
type Factory: ServiceFactory<Io>;
fn create(&self, _: Config) -> Self::Factory;
}
@ -155,8 +155,7 @@ where
fn create(
&self,
) -> Pin<Box<dyn Future<Output = Result<Vec<(Token, BoxedServerService)>, ()>>>>
{
) -> Pin<Box<dyn Future<Output = Result<Vec<(Token, BoxedServerService)>, ()>>>> {
let token = self.token;
let cfg = Config::default();
let fut = self.inner.create(cfg.clone()).new_service(());
@ -185,8 +184,7 @@ impl InternalServiceFactory for Box<dyn InternalServiceFactory> {
fn create(
&self,
) -> Pin<Box<dyn Future<Output = Result<Vec<(Token, BoxedServerService)>, ()>>>>
{
) -> Pin<Box<dyn Future<Output = Result<Vec<(Token, BoxedServerService)>, ()>>>> {
self.as_ref().create()
}
}
@ -194,7 +192,7 @@ impl InternalServiceFactory for Box<dyn InternalServiceFactory> {
impl<F, T> StreamServiceFactory for F
where
F: Fn(Config) -> T + Send + Clone + 'static,
T: ServiceFactory<Io, Config = ()>,
T: ServiceFactory<Io>,
{
type Factory = T;

2
ntex/src/server/test.rs
View file

@ -41,7 +41,7 @@ use crate::{io::Io, service::ServiceFactory};
pub fn test_server<F, R>(factory: F) -> TestServer
where
F: Fn() -> R + Send + Clone + 'static,
R: ServiceFactory<Io, Config = ()>,
R: ServiceFactory<Io>,
{
let (tx, rx) = mpsc::channel();

3
ntex/src/server/worker.rs
View file

@ -456,8 +456,7 @@ impl Future for Worker {
self.factories[idx].name(token)
);
self.availability.set(false);
self.services[token.0].status =
WorkerServiceStatus::Restarting;
self.services[token.0].status = WorkerServiceStatus::Restarting;
self.state = WorkerState::Restarting(
idx,
token,

4
ntex/src/util/buffer.rs
View file

@ -1,9 +1,7 @@
//! Service that buffers incomming requests.
use std::cell::{Cell, RefCell};
use std::task::{Context, Poll};
use std::{
collections::VecDeque, future::Future, marker::PhantomData, pin::Pin, rc::Rc,
};
use std::{collections::VecDeque, future::Future, marker::PhantomData, pin::Pin, rc::Rc};
use crate::channel::oneshot;
use crate::service::{IntoService, Service, Transform};

6
ntex/src/util/keepalive.rs
View file

@ -43,18 +43,18 @@ where
}
}
impl<R, E, F> ServiceFactory<R> for KeepAlive<E, F>
impl<R, E, F, C> ServiceFactory<R, C> for KeepAlive<E, F>
where
F: Fn() -> E + Clone,
{
type Response = R;
type Error = E;
type InitError = Infallible;
type Config = ();
type Service = KeepAliveService<E, F>;
type Future = Ready<Self::Service, Self::InitError>;
fn new_service(&self, _: ()) -> Self::Future {
#[inline]
fn new_service(&self, _: C) -> Self::Future {
Ready::Ok(KeepAliveService::new(self.ka, self.f.clone()))
}
}

2
ntex/src/util/mod.rs
View file

@ -6,7 +6,7 @@ pub mod keepalive;
pub mod sink;
pub mod stream;
pub mod timeout;
pub mod variant;
//pub mod variant;
pub use self::extensions::Extensions;

3
ntex/src/util/stream.rs
View file

@ -93,8 +93,7 @@ where
}
}
Poll::Ready(Ok(_)) => {
if let Poll::Ready(Some(item)) = Pin::new(&mut this.rx).poll_next(cx)
{
if let Poll::Ready(Some(item)) = Pin::new(&mut this.rx).poll_next(cx) {
match item {
Ok(Some(item)) => {
if let Err(e) = Pin::new(this.sink.as_mut().unwrap())

3
ntex/src/util/timeout.rs
View file

@ -3,8 +3,7 @@
//! If the response does not complete within the specified timeout, the response
//! will be aborted.
use std::{
fmt, future::Future, marker, marker::PhantomData, pin::Pin, task::Context,
task::Poll,
fmt, future::Future, marker, marker::PhantomData, pin::Pin, task::Context, task::Poll,
};
use crate::service::{IntoService, Service, Transform};

31
ntex/src/web/app.rs
View file

@ -79,7 +79,6 @@ impl<M, T, Err> App<M, T, Err>
where
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -281,12 +280,8 @@ where
pub fn default_service<F, U>(mut self, f: F) -> Self
where
F: IntoServiceFactory<U, WebRequest<Err>>,
U: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebResponse,
Error = Err::Container,
> + 'static,
U: ServiceFactory<WebRequest<Err>, Response = WebResponse, Error = Err::Container>
+ 'static,
U::InitError: fmt::Debug,
{
// create and configure default resource
@ -362,7 +357,6 @@ where
M,
impl ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -372,7 +366,6 @@ where
where
S: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -449,7 +442,6 @@ where
M::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
F: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -479,7 +471,6 @@ where
self,
) -> impl ServiceFactory<
Request,
Config = (),
Response = WebResponse,
Error = Err::Container,
InitError = (),
@ -510,7 +501,6 @@ where
cfg: AppConfig,
) -> impl ServiceFactory<
Request,
Config = (),
Response = WebResponse,
Error = Err::Container,
InitError = (),
@ -519,13 +509,13 @@ where
}
}
impl<M, F, Err> IntoServiceFactory<AppFactory<M, F, Err>, Request> for App<M, F, Err>
impl<M, F, Err> IntoServiceFactory<AppFactory<M, F, Err>, Request, AppConfig>
for App<M, F, Err>
where
M: Transform<AppService<F::Service, Err>> + 'static,
M::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
F: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -580,7 +570,6 @@ impl<Err: ErrorRenderer> Filter<Err> {
}
impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for Filter<Err> {
type Config = ();
type Response = WebRequest<Err>;
type Error = Err::Container;
type InitError = ();
@ -599,10 +588,7 @@ impl<Err: ErrorRenderer> Service<WebRequest<Err>> for Filter<Err> {
type Future = Ready<WebRequest<Err>, Err::Container>;
#[inline]
fn poll_ready(
&self,
_: &mut task::Context<'_>,
) -> task::Poll<Result<(), Self::Error>> {
fn poll_ready(&self, _: &mut task::Context<'_>) -> task::Poll<Result<(), Self::Error>> {
task::Poll::Ready(Ok(()))
}
@ -621,15 +607,14 @@ mod tests {
use crate::util::{Bytes, Ready};
use crate::web::test::{call_service, init_service, read_body, TestRequest};
use crate::web::{
self, middleware::DefaultHeaders, request::WebRequest, DefaultError,
HttpRequest, HttpResponse,
self, middleware::DefaultHeaders, request::WebRequest, DefaultError, HttpRequest,
HttpResponse,
};
#[crate::rt_test]
async fn test_default_resource() {
let srv = init_service(
App::new()
.service(web::resource("/test").to(|| async { HttpResponse::Ok() })),
App::new().service(web::resource("/test").to(|| async { HttpResponse::Ok() })),
)
.await;
let req = TestRequest::with_uri("/test").to_request();

19
ntex/src/web/app_service.rs
View file

@ -33,7 +33,6 @@ pub struct AppFactory<T, F, Err: ErrorRenderer>
where
F: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -52,13 +51,12 @@ where
pub(super) case_insensitive: bool,
}
impl<T, F, Err> ServiceFactory<Request> for AppFactory<T, F, Err>
impl<T, F, Err> ServiceFactory<Request, AppConfig> for AppFactory<T, F, Err>
where
T: Transform<AppService<F::Service, Err>> + 'static,
T::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
F: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -66,7 +64,6 @@ where
F::Future: 'static,
Err: ErrorRenderer,
{
type Config = AppConfig;
type Response = WebResponse;
type Error = Err::Container;
type InitError = ();
@ -84,8 +81,7 @@ where
});
// App config
let mut config =
WebServiceConfig::new(config, default.clone(), self.data.clone());
let mut config = WebServiceConfig::new(config, default.clone(), self.data.clone());
// register services
std::mem::take(&mut *self.services.borrow_mut())
@ -366,11 +362,12 @@ mod tests {
let data = Arc::new(AtomicBool::new(false));
{
let app =
init_service(App::new().data(DropData(data.clone())).service(
web::resource("/test").to(|| async { HttpResponse::Ok() }),
))
.await;
let app = init_service(
App::new()
.data(DropData(data.clone()))
.service(web::resource("/test").to(|| async { HttpResponse::Ok() })),
)
.await;
let req = TestRequest::with_uri("/test").to_request();
let _ = app.call(req).await.unwrap();
}

6
ntex/src/web/error.rs
View file

@ -998,12 +998,10 @@ mod tests {
let r: HttpResponse = ErrorGatewayTimeout::<_, DefaultError>("err").into();
assert_eq!(r.status(), StatusCode::GATEWAY_TIMEOUT);
let r: HttpResponse =
ErrorHttpVersionNotSupported::<_, DefaultError>("err").into();
let r: HttpResponse = ErrorHttpVersionNotSupported::<_, DefaultError>("err").into();
assert_eq!(r.status(), StatusCode::HTTP_VERSION_NOT_SUPPORTED);
let r: HttpResponse =
ErrorVariantAlsoNegotiates::<_, DefaultError>("err").into();
let r: HttpResponse = ErrorVariantAlsoNegotiates::<_, DefaultError>("err").into();
assert_eq!(r.status(), StatusCode::VARIANT_ALSO_NEGOTIATES);
let r: HttpResponse = ErrorInsufficientStorage::<_, DefaultError>("err").into();

4
ntex/src/web/error_default.rs
View file

@ -83,9 +83,7 @@ impl fmt::Debug for Error {
}
/// Return `GATEWAY_TIMEOUT` for `TimeoutError`
impl<E: WebResponseError<DefaultError>> WebResponseError<DefaultError>
for TimeoutError<E>
{
impl<E: WebResponseError<DefaultError>> WebResponseError<DefaultError> for TimeoutError<E> {
fn status_code(&self) -> StatusCode {
match self {
TimeoutError::Service(e) => e.status_code(),

3
ntex/src/web/extract.rs
View file

@ -147,8 +147,7 @@ where
E: ErrorRenderer,
{
type Error = T::Error;
type Future =
Pin<Box<dyn Future<Output = Result<Result<T, T::Error>, Self::Error>>>>;
type Future = Pin<Box<dyn Future<Output = Result<Result<T, T::Error>, Self::Error>>>>;
#[inline]
fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {

19
ntex/src/web/httprequest.rs
View file

@ -344,8 +344,7 @@ mod tests {
#[test]
fn test_debug() {
let req =
TestRequest::with_header("content-type", "text/plain").to_http_request();
let req = TestRequest::with_header("content-type", "text/plain").to_http_request();
let dbg = format!("{:?}", req);
assert!(dbg.contains("HttpRequest"));
@ -483,15 +482,15 @@ mod tests {
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
let srv = init_service(App::new().app_data(10u32).service(
web::resource("/").to(|req: HttpRequest| async move {
let srv = init_service(App::new().app_data(10u32).service(web::resource("/").to(
|req: HttpRequest| async move {
if req.app_data::<usize>().is_some() {
HttpResponse::Ok()
} else {
HttpResponse::BadRequest()
}
}),
))
},
)))
.await;
let req = TestRequest::default().to_request();
@ -516,14 +515,14 @@ mod tests {
let tracker = Rc::new(RefCell::new(Tracker { dropped: false }));
{
let tracker2 = Rc::clone(&tracker);
let srv = init_service(App::new().data(10u32).service(
web::resource("/").to(move |req: HttpRequest| {
let srv = init_service(App::new().data(10u32).service(web::resource("/").to(
move |req: HttpRequest| {
req.extensions_mut().insert(Foo {
tracker: Rc::clone(&tracker2),
});
async { HttpResponse::Ok() }
}),
))
},
)))
.await;
let req = TestRequest::default().to_request();

25
ntex/src/web/middleware/compress.rs
View file

@ -26,26 +26,30 @@ use crate::web::{BodyEncoding, ErrorRenderer, WebRequest, WebResponse};
/// );
/// }
/// ```
pub struct Compress {
pub struct Compress<E> {
enc: ContentEncoding,
_t: marker::PhantomData<E>,
}
impl Compress {
impl<E> Compress<E> {
/// Create new `Compress` middleware with default encoding.
pub fn new(encoding: ContentEncoding) -> Self {
Compress { enc: encoding }
Compress {
enc: encoding,
_t: marker::PhantomData,
}
}
}
impl Default for Compress {
impl<E> Default for Compress<E> {
fn default() -> Self {
Compress::new(ContentEncoding::Auto)
}
}
impl<S, E> Transform<S> for Compress
impl<S, E> Transform<S> for Compress<E>
where
S: Service<Request = WebRequest<E>, Response = WebResponse>,
S: Service<WebRequest<E>, Response = WebResponse>,
E: ErrorRenderer,
{
type Service = CompressMiddleware<S, E>;
@ -65,12 +69,11 @@ pub struct CompressMiddleware<S, E> {
_t: marker::PhantomData<E>,
}
impl<S, E> Service for CompressMiddleware<S, E>
impl<S, E> Service<WebRequest<E>> for CompressMiddleware<S, E>
where
S: Service<Request = WebRequest<E>, Response = WebResponse>,
S: Service<WebRequest<E>, Response = WebResponse>,
E: ErrorRenderer,
{
type Request = WebRequest<E>;
type Response = WebResponse;
type Error = S::Error;
type Future = CompressResponse<S, E>;
@ -107,7 +110,7 @@ where
pin_project_lite::pin_project! {
#[doc(hidden)]
pub struct CompressResponse<S: Service, E>
pub struct CompressResponse<S: Service<WebRequest<E>>, E>
{
#[pin]
fut: S::Future,
@ -118,7 +121,7 @@ pin_project_lite::pin_project! {
impl<S, E> Future for CompressResponse<S, E>
where
S: Service<Request = WebRequest<E>, Response = WebResponse>,
S: Service<WebRequest<E>, Response = WebResponse>,
E: ErrorRenderer,
{
type Output = Result<WebResponse, S::Error>;

11
ntex/src/web/middleware/defaultheaders.rs
View file

@ -178,12 +178,11 @@ mod tests {
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
let req = TestRequest::default().to_srv_request();
let srv =
|req: WebRequest<DefaultError>| async move {
Ok::<_, Error>(req.into_response(
HttpResponse::Ok().header(CONTENT_TYPE, "0002").finish(),
))
};
let srv = |req: WebRequest<DefaultError>| async move {
Ok::<_, Error>(
req.into_response(HttpResponse::Ok().header(CONTENT_TYPE, "0002").finish()),
)
};
let mw = DefaultHeaders::new()
.header(CONTENT_TYPE, "0001")
.new_transform(srv.into_service());

4
ntex/src/web/mod.rs
View file

@ -130,9 +130,7 @@ pub mod dev {
pub use crate::web::info::ConnectionInfo;
pub use crate::web::rmap::ResourceMap;
pub use crate::web::route::IntoRoutes;
pub use crate::web::service::{
WebServiceAdapter, WebServiceConfig, WebServiceFactory,
};
pub use crate::web::service::{WebServiceAdapter, WebServiceConfig, WebServiceFactory};
pub(crate) fn insert_slesh(mut patterns: Vec<String>) -> Vec<String> {
for path in &mut patterns {

61
ntex/src/web/resource.rs
View file

@ -77,7 +77,6 @@ impl<Err, M, T> Resource<Err, M, T>
where
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -252,7 +251,6 @@ where
M,
impl ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -261,7 +259,6 @@ where
where
U: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -306,19 +303,14 @@ where
pub fn default_service<F, S>(mut self, f: F) -> Self
where
F: IntoServiceFactory<S, WebRequest<Err>>,
S: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebResponse,
Error = Err::Container,
> + 'static,
S: ServiceFactory<WebRequest<Err>, Response = WebResponse, Error = Err::Container>
+ 'static,
S::InitError: fmt::Debug,
{
// create and configure default resource
self.default = Rc::new(RefCell::new(Some(Rc::new(boxed::factory(
f.into_factory().map_init_err(|e| {
log::error!("Cannot construct default service: {:?}", e)
}),
f.into_factory()
.map_init_err(|e| log::error!("Cannot construct default service: {:?}", e)),
)))));
self
@ -329,7 +321,6 @@ impl<Err, M, T> WebServiceFactory<Err> for Resource<Err, M, T>
where
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -384,7 +375,6 @@ impl<Err, M, T>
where
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -423,14 +413,12 @@ where
M::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
F: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
> + 'static,
Err: ErrorRenderer,
{
type Config = ();
type Response = WebResponse;
type Error = Err::Container;
type Service = M::Service;
@ -524,7 +512,6 @@ struct ResourceRouterFactory<Err: ErrorRenderer> {
}
impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for ResourceRouterFactory<Err> {
type Config = ();
type Response = WebResponse;
type Error = Err::Container;
type InitError = ();
@ -598,9 +585,7 @@ mod tests {
use crate::time::{sleep, Millis};
use crate::web::middleware::DefaultHeaders;
use crate::web::test::{call_service, init_service, TestRequest};
use crate::web::{
self, guard, request::WebRequest, App, DefaultError, HttpResponse,
};
use crate::web::{self, guard, request::WebRequest, App, DefaultError, HttpResponse};
use crate::{service::fn_service, util::Ready};
#[crate::rt_test]
@ -626,19 +611,18 @@ mod tests {
#[crate::rt_test]
async fn test_middleware() {
let srv =
init_service(
App::new().service(
web::resource("/test")
.name("test")
.wrap(DefaultHeaders::new().header(
header::CONTENT_TYPE,
HeaderValue::from_static("0001"),
))
.route(web::get().to(|| async { HttpResponse::Ok() })),
),
)
.await;
let srv = init_service(
App::new().service(
web::resource("/test")
.name("test")
.wrap(
DefaultHeaders::new()
.header(header::CONTENT_TYPE, HeaderValue::from_static("0001")),
)
.route(web::get().to(|| async { HttpResponse::Ok() })),
),
)
.await;
let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
@ -650,12 +634,11 @@ mod tests {
#[crate::rt_test]
async fn test_to() {
let srv =
init_service(App::new().service(web::resource("/test").to(|| async {
sleep(Millis(100)).await;
HttpResponse::Ok()
})))
.await;
let srv = init_service(App::new().service(web::resource("/test").to(|| async {
sleep(Millis(100)).await;
HttpResponse::Ok()
})))
.await;
let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);

26
ntex/src/web/responder.rs
View file

@ -123,9 +123,9 @@ where
fn respond_to(self, req: &HttpRequest) -> Self::Future {
match self {
Some(t) => Either::Left(t.respond_to(req)),
None => Either::Right(Ready(Some(
Response::build(StatusCode::NOT_FOUND).finish(),
))),
None => {
Either::Right(Ready(Some(Response::build(StatusCode::NOT_FOUND).finish())))
}
}
}
}
@ -432,15 +432,15 @@ pub(crate) mod tests {
#[crate::rt_test]
async fn test_either_responder() {
let srv = init_service(web::App::new().service(
web::resource("/index.html").to(|req: HttpRequest| async move {
let srv = init_service(web::App::new().service(web::resource("/index.html").to(
|req: HttpRequest| async move {
if req.query_string().is_empty() {
Either::Left(HttpResponse::BadRequest())
} else {
Either::Right("hello")
}
}),
))
},
)))
.await;
let req = TestRequest::with_uri("/index.html").to_request();
@ -604,13 +604,11 @@ pub(crate) mod tests {
assert_eq!(res.body().get_ref(), b"test");
let req = TestRequest::default().to_http_request();
let res = CustomResponder::<_, DefaultError>::new((
"test".to_string(),
StatusCode::OK,
))
.with_header("content-type", "json")
.respond_to(&req)
.await;
let res =
CustomResponder::<_, DefaultError>::new(("test".to_string(), StatusCode::OK))
.with_header("content-type", "json")
.respond_to(&req)
.await;
assert_eq!(res.status(), StatusCode::OK);
assert_eq!(res.body().get_ref(), b"test");
assert_eq!(

5
ntex/src/web/response.rs
View file

@ -166,9 +166,8 @@ mod tests {
assert_eq!(res.response().status(), StatusCode::PAYLOAD_TOO_LARGE);
let res = TestRequest::default().to_srv_response(HttpResponse::Ok().finish());
let mut res = res.checked_expr::<DefaultError, _, _>(|_| {
Ok::<_, http::error::PayloadError>(())
});
let mut res = res
.checked_expr::<DefaultError, _, _>(|_| Ok::<_, http::error::PayloadError>(()));
assert_eq!(res.response_mut().status(), StatusCode::OK);
let res = res.checked_expr::<DefaultError, _, _>(|_| {
Err(http::error::PayloadError::Overflow)

11
ntex/src/web/route.rs
View file

@ -26,9 +26,7 @@ impl<Err: ErrorRenderer> Route<Err> {
/// Create new route which matches any request.
pub fn new() -> Route<Err> {
Route {
handler: Box::new(HandlerWrapper::new(|| async {
HttpResponse::NotFound()
})),
handler: Box::new(HandlerWrapper::new(|| async { HttpResponse::NotFound() })),
methods: Vec::new(),
guards: Rc::new(Vec::new()),
}
@ -54,7 +52,6 @@ impl<Err: ErrorRenderer> Route<Err> {
}
impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for Route<Err> {
type Config = ();
type Response = WebResponse;
type Error = Err::Container;
type InitError = ();
@ -290,9 +287,9 @@ mod tests {
.service(web::resource("/test").route(vec![
web::get().to(|| async { HttpResponse::Ok() }),
web::put().to(|| async {
Err::<HttpResponse, _>(
error::ErrorBadRequest::<_, DefaultError>("err"),
)
Err::<HttpResponse, _>(error::ErrorBadRequest::<_, DefaultError>(
"err",
))
}),
web::post().to(|| async {
sleep(Millis(100)).await;

95
ntex/src/web/scope.rs
View file

@ -92,7 +92,6 @@ impl<Err, M, T> Scope<Err, M, T>
where
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -293,19 +292,14 @@ where
pub fn default_service<F, S>(mut self, f: F) -> Self
where
F: IntoServiceFactory<S, WebRequest<Err>>,
S: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebResponse,
Error = Err::Container,
> + 'static,
S: ServiceFactory<WebRequest<Err>, Response = WebResponse, Error = Err::Container>
+ 'static,
S::InitError: fmt::Debug,
{
// create and configure default resource
self.default = Rc::new(RefCell::new(Some(Rc::new(boxed::factory(
f.into_factory().map_init_err(|e| {
log::error!("Cannot construct default service: {:?}", e)
}),
f.into_factory()
.map_init_err(|e| log::error!("Cannot construct default service: {:?}", e)),
)))));
self
@ -326,7 +320,6 @@ where
M,
impl ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -335,7 +328,6 @@ where
where
U: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -384,7 +376,6 @@ impl<Err, M, T> WebServiceFactory<Err> for Scope<Err, M, T>
where
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -476,14 +467,12 @@ where
M::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
F: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
> + 'static,
Err: ErrorRenderer,
{
type Config = ();
type Response = WebResponse;
type Error = Err::Container;
type Service = M::Service;
@ -578,7 +567,6 @@ struct ScopeRouterFactory<Err: ErrorRenderer> {
}
impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for ScopeRouterFactory<Err> {
type Config = ();
type Response = WebResponse;
type Error = Err::Container;
type InitError = ();
@ -681,13 +669,13 @@ mod tests {
#[crate::rt_test]
async fn test_scope() {
let srv =
init_service(App::new().service(
web::scope("/app").service(
web::resource("/path1").to(|| async { HttpResponse::Ok() }),
),
))
.await;
let srv = init_service(
App::new().service(
web::scope("/app")
.service(web::resource("/path1").to(|| async { HttpResponse::Ok() })),
),
)
.await;
let req = TestRequest::with_uri("/app/path1").to_request();
let resp = srv.call(req).await.unwrap();
@ -704,9 +692,7 @@ mod tests {
App::new().service(
web::scope("/app")
.service(web::resource("").to(|| async { HttpResponse::Ok() }))
.service(
web::resource("/").to(|| async { HttpResponse::Created() }),
),
.service(web::resource("/").to(|| async { HttpResponse::Created() })),
),
)
.await;
@ -726,9 +712,7 @@ mod tests {
App::new().service(
web::scope(["/app", "/app2"])
.service(web::resource("").to(|| async { HttpResponse::Ok() }))
.service(
web::resource("/").to(|| async { HttpResponse::Created() }),
),
.service(web::resource("/").to(|| async { HttpResponse::Created() })),
),
)
.await;
@ -895,15 +879,16 @@ mod tests {
async fn test_scope_guard() {
let srv = init_service(
App::new()
.service(web::scope("/app").guard(guard::Get()).service(
web::resource("/path1").to(|| async { HttpResponse::Ok() }),
))
.service(
web::scope("/app").guard(guard::Get()).service(
web::resource("/path1").to(|| async { HttpResponse::Ok() }),
),
)
.service(web::scope("/app").guard(guard::Post()).service(
web::resource("/path1").to(|| async { HttpResponse::NotModified() }),
))
.service(
web::resource("/app/path1")
.to(|| async { HttpResponse::NoContent() }),
web::resource("/app/path1").to(|| async { HttpResponse::NoContent() }),
),
)
.await;
@ -931,8 +916,7 @@ mod tests {
async fn test_scope_variable_segment() {
let srv = init_service(App::new().service(web::scope("/ab-{project}").service(
web::resource("/path1").to(|r: HttpRequest| async move {
HttpResponse::Ok()
.body(format!("project: {}", &r.match_info()["project"]))
HttpResponse::Ok().body(format!("project: {}", &r.match_info()["project"]))
}),
)))
.await;
@ -955,8 +939,7 @@ mod tests {
async fn test_scope_variable_segment2() {
let srv = init_service(App::new().service(web::scope("/ab-{project}").service(
web::resource(["", "/"]).to(|r: HttpRequest| async move {
HttpResponse::Ok()
.body(format!("project: {}", &r.match_info()["project"]))
HttpResponse::Ok().body(format!("project: {}", &r.match_info()["project"]))
}),
)))
.await;
@ -986,12 +969,13 @@ mod tests {
#[crate::rt_test]
async fn test_nested_scope() {
let srv = init_service(App::new().service(web::scope("/app").service(
web::scope("/t1").service(
web::resource("/path1").to(|| async { HttpResponse::Created() }),
),
)))
.await;
let srv =
init_service(App::new().service(web::scope("/app").service(
web::scope("/t1").service(
web::resource("/path1").to(|| async { HttpResponse::Created() }),
),
)))
.await;
let req = TestRequest::with_uri("/app/t1/path1").to_request();
let resp = srv.call(req).await.unwrap();
@ -1000,12 +984,13 @@ mod tests {
#[crate::rt_test]
async fn test_nested_scope_no_slash() {
let srv = init_service(App::new().service(web::scope("/app").service(
web::scope("t1").service(
web::resource("/path1").to(|| async { HttpResponse::Created() }),
),
)))
.await;
let srv =
init_service(App::new().service(web::scope("/app").service(
web::scope("t1").service(
web::resource("/path1").to(|| async { HttpResponse::Created() }),
),
)))
.await;
let req = TestRequest::with_uri("/app/t1/path1").to_request();
let resp = srv.call(req).await.unwrap();
@ -1039,11 +1024,13 @@ mod tests {
#[crate::rt_test]
async fn test_nested_scope_filter() {
let srv =
init_service(App::new().service(web::scope("/app").service(
web::scope("/t1").guard(guard::Get()).service(
web::resource("/path1").to(|| async { HttpResponse::Ok() }),
init_service(App::new().service(
web::scope("/app").service(
web::scope("/t1").guard(guard::Get()).service(
web::resource("/path1").to(|| async { HttpResponse::Ok() }),
),
),
)))
))
.await;
let req = TestRequest::with_uri("/app/t1/path1")

106
ntex/src/web/server.rs
View file

@ -43,8 +43,8 @@ struct Config {
pub struct HttpServer<F, I, S, B>
where
F: Fn() -> I + Send + Clone + 'static,
I: IntoServiceFactory<S, Request>,
S: ServiceFactory<Request, Config = AppConfig>,
I: IntoServiceFactory<S, Request, AppConfig>,
S: ServiceFactory<Request, AppConfig>,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>>,
@ -60,8 +60,8 @@ where
impl<F, I, S, B> HttpServer<F, I, S, B>
where
F: Fn() -> I + Send + Clone + 'static,
I: IntoServiceFactory<S, Request>,
S: ServiceFactory<Request, Config = AppConfig> + 'static,
I: IntoServiceFactory<S, Request, AppConfig>,
S: ServiceFactory<Request, AppConfig> + 'static,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>>,
@ -235,25 +235,23 @@ where
let factory = self.factory.clone();
let addr = lst.local_addr().unwrap();
self.builder = self.builder.listen(
format!("ntex-web-service-{}", addr),
lst,
move |r| {
let c = cfg.lock().unwrap();
let cfg = AppConfig::new(
false,
addr,
c.host.clone().unwrap_or_else(|| format!("{}", addr)),
);
r.memory_pool(c.pool);
self.builder =
self.builder
.listen(format!("ntex-web-service-{}", addr), lst, move |r| {
let c = cfg.lock().unwrap();
let cfg = AppConfig::new(
false,
addr,
c.host.clone().unwrap_or_else(|| format!("{}", addr)),
);
r.memory_pool(c.pool);
HttpService::build()
.keep_alive(c.keep_alive)
.client_timeout(c.client_timeout)
.disconnect_timeout(c.client_disconnect)
.finish(map_config(factory(), move |_| cfg.clone()))
},
)?;
HttpService::build()
.keep_alive(c.keep_alive)
.client_timeout(c.client_timeout)
.disconnect_timeout(c.client_disconnect)
.finish(map_config(factory(), move |_| cfg.clone()))
})?;
Ok(self)
}
@ -279,27 +277,25 @@ where
let cfg = self.config.clone();
let addr = lst.local_addr().unwrap();
self.builder = self.builder.listen(
format!("ntex-web-service-{}", addr),
lst,
move |r| {
let c = cfg.lock().unwrap();
let cfg = AppConfig::new(
true,
addr,
c.host.clone().unwrap_or_else(|| format!("{}", addr)),
);
r.memory_pool(c.pool);
self.builder =
self.builder
.listen(format!("ntex-web-service-{}", addr), lst, move |r| {
let c = cfg.lock().unwrap();
let cfg = AppConfig::new(
true,
addr,
c.host.clone().unwrap_or_else(|| format!("{}", addr)),
);
r.memory_pool(c.pool);
HttpService::build()
.keep_alive(c.keep_alive)
.client_timeout(c.client_timeout)
.disconnect_timeout(c.client_disconnect)
.ssl_handshake_timeout(c.handshake_timeout)
.finish(map_config(factory(), move |_| cfg.clone()))
.openssl(acceptor.clone())
},
)?;
HttpService::build()
.keep_alive(c.keep_alive)
.client_timeout(c.client_timeout)
.disconnect_timeout(c.client_disconnect)
.ssl_handshake_timeout(c.handshake_timeout)
.finish(map_config(factory(), move |_| cfg.clone()))
.openssl(acceptor.clone())
})?;
Ok(self)
}
@ -362,10 +358,7 @@ where
Ok(self)
}
fn bind2<A: net::ToSocketAddrs>(
&self,
addr: A,
) -> io::Result<Vec<net::TcpListener>> {
fn bind2<A: net::ToSocketAddrs>(&self, addr: A) -> io::Result<Vec<net::TcpListener>> {
let mut err = None;
let mut succ = false;
let mut sockets = Vec::new();
@ -435,16 +428,11 @@ where
/// Start listening for unix domain connections on existing listener.
///
/// This method is available with `uds` feature.
pub fn listen_uds(
mut self,
lst: std::os::unix::net::UnixListener,
) -> io::Result<Self> {
pub fn listen_uds(mut self, lst: std::os::unix::net::UnixListener) -> io::Result<Self> {
let cfg = self.config.clone();
let factory = self.factory.clone();
let socket_addr = net::SocketAddr::new(
net::IpAddr::V4(net::Ipv4Addr::new(127, 0, 0, 1)),
8080,
);
let socket_addr =
net::SocketAddr::new(net::IpAddr::V4(net::Ipv4Addr::new(127, 0, 0, 1)), 8080);
let addr = format!("ntex-web-service-{:?}", lst.local_addr()?);
@ -475,10 +463,8 @@ where
{
let cfg = self.config.clone();
let factory = self.factory.clone();
let socket_addr = net::SocketAddr::new(
net::IpAddr::V4(net::Ipv4Addr::new(127, 0, 0, 1)),
8080,
);
let socket_addr =
net::SocketAddr::new(net::IpAddr::V4(net::Ipv4Addr::new(127, 0, 0, 1)), 8080);
self.builder = self.builder.bind_uds(
format!("ntex-web-service-{:?}", addr.as_ref()),
@ -505,8 +491,8 @@ where
impl<F, I, S, B> HttpServer<F, I, S, B>
where
F: Fn() -> I + Send + Clone + 'static,
I: IntoServiceFactory<S, Request>,
S: ServiceFactory<Request, Config = AppConfig>,
I: IntoServiceFactory<S, Request, AppConfig>,
S: ServiceFactory<Request, AppConfig>,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>>,

11
ntex/src/web/service.rs
View file

@ -137,18 +137,13 @@ impl<Err: ErrorRenderer> WebServiceConfig<Err> {
F: IntoServiceFactory<S, WebRequest<Err>>,
S: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebResponse,
Error = Err::Container,
InitError = (),
> + 'static,
{
self.services.push((
rdef,
boxed::factory(factory.into_factory()),
guards,
nested,
));
self.services
.push((rdef, boxed::factory(factory.into_factory()), guards, nested));
}
}
@ -220,7 +215,6 @@ impl WebServiceAdapter {
F: IntoServiceFactory<T, WebRequest<Err>>,
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebResponse,
Error = Err::Container,
InitError = (),
@ -247,7 +241,6 @@ impl<T, Err> WebServiceFactory<Err> for WebServiceImpl<T>
where
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Response = WebResponse,
Error = Err::Container,
InitError = (),

35
ntex/src/web/test.rs
View file

@ -1,7 +1,6 @@
//! Various helpers for ntex applications to use during testing.
use std::{
convert::TryFrom, error::Error, fmt, net, net::SocketAddr, rc::Rc, sync::mpsc,
thread,
convert::TryFrom, error::Error, fmt, net, net::SocketAddr, rc::Rc, sync::mpsc, thread,
};
#[cfg(feature = "cookie")]
@ -75,8 +74,8 @@ pub async fn init_service<R, S, E>(
app: R,
) -> impl Service<Request, Response = WebResponse, Error = E>
where
R: IntoServiceFactory<S, Request>,
S: ServiceFactory<Request, Config = AppConfig, Response = WebResponse, Error = E>,
R: IntoServiceFactory<S, Request, AppConfig>,
S: ServiceFactory<Request, AppConfig, Response = WebResponse, Error = E>,
S::InitError: std::fmt::Debug,
{
let srv = app.into_factory();
@ -542,8 +541,8 @@ impl TestRequest {
pub fn server<F, I, S, B>(factory: F) -> TestServer
where
F: Fn() -> I + Send + Clone + 'static,
I: IntoServiceFactory<S, Request>,
S: ServiceFactory<Request, Config = AppConfig> + 'static,
I: IntoServiceFactory<S, Request, AppConfig>,
S: ServiceFactory<Request, AppConfig> + 'static,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Response: Into<HttpResponse<B>>,
@ -580,8 +579,8 @@ where
pub fn server_with<F, I, S, B>(cfg: TestServerConfig, factory: F) -> TestServer
where
F: Fn() -> I + Send + Clone + 'static,
I: IntoServiceFactory<S, Request>,
S: ServiceFactory<Request, Config = AppConfig> + 'static,
I: IntoServiceFactory<S, Request, AppConfig>,
S: ServiceFactory<Request, AppConfig> + 'static,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Response: Into<HttpResponse<B>>,
@ -907,10 +906,7 @@ impl TestServer {
}
/// Connect to websocket server at a given path
pub async fn ws_at(
&self,
path: &str,
) -> Result<WsConnection<Sealed>, WsClientError> {
pub async fn ws_at(&self, path: &str) -> Result<WsConnection<Sealed>, WsClientError> {
if self.ssl {
#[cfg(feature = "openssl")]
{
@ -1004,12 +1000,9 @@ mod tests {
App::new().service(
web::resource("/index.html")
.route(web::put().to(|| async { HttpResponse::Ok().body("put!") }))
.route(web::patch().to(|| async { HttpResponse::Ok().body("patch!") }))
.route(
web::patch().to(|| async { HttpResponse::Ok().body("patch!") }),
)
.route(
web::delete()
.to(|| async { HttpResponse::Ok().body("delete!") }),
web::delete().to(|| async { HttpResponse::Ok().body("delete!") }),
),
),
)
@ -1039,9 +1032,11 @@ mod tests {
#[crate::rt_test]
async fn test_response() {
let app =
init_service(App::new().service(web::resource("/index.html").route(
web::post().to(|| async { HttpResponse::Ok().body("welcome!") }),
)))
init_service(App::new().service(
web::resource("/index.html").route(
web::post().to(|| async { HttpResponse::Ok().body("welcome!") }),
),
))
.await;
let req = TestRequest::post()

24
ntex/src/web/types/data.rs
View file

@ -191,25 +191,23 @@ mod tests {
#[crate::rt_test]
async fn test_route_data_extractor() {
let srv =
init_service(App::new().service(web::resource("/").data(10usize).route(
web::get().to(|data: web::types::Data<usize>| async move {
let _ = data.clone();
HttpResponse::Ok()
}),
)))
.await;
let srv = init_service(App::new().service(web::resource("/").data(10usize).route(
web::get().to(|data: web::types::Data<usize>| async move {
let _ = data.clone();
HttpResponse::Ok()
}),
)))
.await;
let req = TestRequest::default().to_request();
let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
// different type
let srv =
init_service(App::new().service(web::resource("/").data(10u32).route(
web::get().to(|_: web::types::Data<usize>| async { HttpResponse::Ok() }),
)))
.await;
let srv = init_service(App::new().service(web::resource("/").data(10u32).route(
web::get().to(|_: web::types::Data<usize>| async { HttpResponse::Ok() }),
)))
.await;
let req = TestRequest::default().to_request();
let res = srv.call(req).await.unwrap();
assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);

6
ntex/src/web/types/form.rs
View file

@ -322,15 +322,13 @@ where
}
if encoding == UTF_8 {
serde_urlencoded::from_bytes::<U>(&body)
.map_err(|_| UrlencodedError::Parse)
serde_urlencoded::from_bytes::<U>(&body).map_err(|_| UrlencodedError::Parse)
} else {
let body = encoding
.decode_without_bom_handling_and_without_replacement(&body)
.map(|s| s.into_owned())
.ok_or(UrlencodedError::Parse)?;
serde_urlencoded::from_str::<U>(&body)
.map_err(|_| UrlencodedError::Parse)
serde_urlencoded::from_str::<U>(&body).map_err(|_| UrlencodedError::Parse)
}
}));
self.poll(cx)

9
ntex/src/web/types/path.rs
View file

@ -224,11 +224,10 @@ mod tests {
assert_eq!((res.0).0, "name");
assert_eq!((res.0).1, "user1");
let res = from_request::<(Path<(String, String)>, Path<(String, String)>)>(
&req, &mut pl,
)
.await
.unwrap();
let res =
from_request::<(Path<(String, String)>, Path<(String, String)>)>(&req, &mut pl)
.await
.unwrap();
assert_eq!((res.0).0, "name");
assert_eq!((res.0).1, "user1");
assert_eq!((res.1).0, "name");

19
ntex/src/web/types/payload.rs
View file

@ -93,10 +93,7 @@ impl<Err: ErrorRenderer> FromRequest<Err> for Payload {
type Future = Ready<Payload, Self::Error>;
#[inline]
fn from_request(
_: &HttpRequest,
payload: &mut crate::http::Payload,
) -> Self::Future {
fn from_request(_: &HttpRequest, payload: &mut crate::http::Payload) -> Self::Future {
Ready::Ok(Payload(payload.take()))
}
}
@ -133,10 +130,7 @@ impl<Err: ErrorRenderer> FromRequest<Err> for Bytes {
>;
#[inline]
fn from_request(
req: &HttpRequest,
payload: &mut crate::http::Payload,
) -> Self::Future {
fn from_request(req: &HttpRequest, payload: &mut crate::http::Payload) -> Self::Future {
let tmp;
let cfg = if let Some(cfg) = req.app_data::<PayloadConfig>() {
cfg
@ -190,10 +184,7 @@ impl<Err: ErrorRenderer> FromRequest<Err> for String {
>;
#[inline]
fn from_request(
req: &HttpRequest,
payload: &mut crate::http::Payload,
) -> Self::Future {
fn from_request(req: &HttpRequest, payload: &mut crate::http::Payload) -> Self::Future {
let tmp;
let cfg = if let Some(cfg) = req.app_data::<PayloadConfig>() {
cfg
@ -378,9 +369,7 @@ impl Future for HttpMessageBody {
if let Some(len) = self.length.take() {
if len > self.limit {
return Poll::Ready(Err(PayloadError::from(
error::PayloadError::Overflow,
)));
return Poll::Ready(Err(PayloadError::from(error::PayloadError::Overflow)));
}
}

4
ntex/src/web/util.rs
View file

@ -285,8 +285,8 @@ where
pub fn server<F, I, S, B>(factory: F) -> HttpServer<F, I, S, B>
where
F: Fn() -> I + Send + Clone + 'static,
I: IntoServiceFactory<S, Request>,
S: ServiceFactory<Request, Config = AppConfig> + 'static,
I: IntoServiceFactory<S, Request, AppConfig>,
S: ServiceFactory<Request, AppConfig> + 'static,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>>,

15
ntex/src/web/ws.rs
View file

@ -20,10 +20,9 @@ pub async fn start<T, F, S, Err>(
factory: F,
) -> Result<HttpResponse, Err>
where
T: ServiceFactory<Frame, Config = WebSocketsSink, Response = Option<Message>>
+ 'static,
T: ServiceFactory<Frame, WebSocketsSink, Response = Option<Message>> + 'static,
T::Error: error::Error,
F: IntoServiceFactory<T, Frame>,
F: IntoServiceFactory<T, Frame, WebSocketsSink>,
S: Stream<Item = Result<Bytes, PayloadError>> + Unpin + 'static,
Err: From<T::InitError> + From<HandshakeError>,
{
@ -41,10 +40,9 @@ pub async fn start_with<T, F, S, Err, Tx, Rx>(
factory: F,
) -> Result<HttpResponse, Err>
where
T: ServiceFactory<Frame, Config = ws::StreamEncoder<Tx>, Response = Option<Message>>
+ 'static,
T: ServiceFactory<Frame, ws::StreamEncoder<Tx>, Response = Option<Message>> + 'static,
T::Error: error::Error,
F: IntoServiceFactory<T, Frame>,
F: IntoServiceFactory<T, Frame, ws::StreamEncoder<Tx>>,
S: Stream<Item = Result<Bytes, PayloadError>> + Unpin + 'static,
Err: From<T::InitError> + From<HandshakeError>,
Tx: Sink<Result<Bytes, Box<dyn error::Error>>> + Clone + Unpin + 'static,
@ -98,10 +96,7 @@ where
{
type Item = Result<I, Box<dyn error::Error>>;
fn poll_next(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Option<Self::Item>> {
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
match self.project().stream.poll_next(cx) {
Poll::Pending => Poll::Pending,
Poll::Ready(Some(Ok(item))) => Poll::Ready(Some(Ok(item))),

17
ntex/src/ws/client.rs
View file

@ -134,9 +134,7 @@ where
T: Service<Connect<Uri>, Response = Io<F>, Error = ConnectError>,
{
/// Complete request construction and connect to a websockets server.
pub fn connect(
&self,
) -> impl Future<Output = Result<WsConnection<F>, WsClientError>> {
pub fn connect(&self) -> impl Future<Output = Result<WsConnection<F>, WsClientError>> {
let head = self.head.clone();
let max_size = self.max_size;
let server_mode = self.server_mode;
@ -215,9 +213,7 @@ where
if let Ok(s) = conn.to_str() {
if !s.to_ascii_lowercase().contains("upgrade") {
log::trace!("Invalid connection header: {}", s);
return Err(WsClientError::InvalidConnectionHeader(
conn.clone(),
));
return Err(WsClientError::InvalidConnectionHeader(conn.clone()));
}
} else {
log::trace!("Invalid connection header: {:?}", conn);
@ -586,10 +582,8 @@ where
if let Some(ref mut jar) = self.cookies {
let mut cookie = String::new();
for c in jar.delta() {
let name = percent_encode(
c.name().as_bytes(),
crate::http::helpers::USERINFO,
);
let name =
percent_encode(c.name().as_bytes(), crate::http::helpers::USERINFO);
let value = percent_encode(
c.value().as_bytes(),
crate::http::helpers::USERINFO,
@ -702,8 +696,7 @@ impl WsConnection<Sealed> {
// TODO: fix close frame handling
/// Start client websockets with `SinkService` and `mpsc::Receiver<Frame>`
pub fn start_default(self) -> mpsc::Receiver<Result<ws::Frame, WsError<()>>> {
let (tx, rx): (_, mpsc::Receiver<Result<ws::Frame, WsError<()>>>) =
mpsc::channel();
let (tx, rx): (_, mpsc::Receiver<Result<ws::Frame, WsError<()>>>) = mpsc::channel();
rt::spawn(async move {
let io = self.io.get_ref();

9
ntex/src/ws/codec.rs
View file

@ -151,11 +151,7 @@ impl Encoder for Codec {
),
Message::Close(reason) => {
self.insert_flags(Flags::CLOSED);
Parser::write_close(
dst,
reason,
!self.flags.get().contains(Flags::SERVER),
)
Parser::write_close(dst, reason, !self.flags.get().contains(Flags::SERVER))
}
Message::Continuation(cont) => match cont {
Item::FirstText(data) => {
@ -224,8 +220,7 @@ impl Decoder for Codec {
type Error = ProtocolError;
fn decode(&self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
match Parser::parse(src, self.flags.get().contains(Flags::SERVER), self.max_size)
{
match Parser::parse(src, self.flags.get().contains(Flags::SERVER), self.max_size) {
Ok(Some((finished, opcode, payload))) => {
// handle continuation
if !finished {

7
ntex/src/ws/frame.rs
View file

@ -77,8 +77,7 @@ impl Parser {
return Ok(None);
}
let mask =
u32::from_le_bytes(TryFrom::try_from(&src[idx..idx + 4]).unwrap());
let mask = u32::from_le_bytes(TryFrom::try_from(&src[idx..idx + 4]).unwrap());
idx += 4;
Some(mask)
} else {
@ -235,9 +234,7 @@ mod tests {
}
}
fn extract(
frm: Result<Option<(bool, OpCode, Option<BytesMut>)>, ProtocolError>,
) -> F {
fn extract(frm: Result<Option<(bool, OpCode, Option<BytesMut>)>, ProtocolError>) -> F {
match frm {
Ok(Some((finished, opcode, payload))) => F {
finished,

4
ntex/src/ws/mask.rs
View file

@ -119,8 +119,8 @@ mod tests {
let mask_u32 = u32::from_le_bytes(mask);
let unmasked = vec![
0xf3, 0x00, 0x01, 0x02, 0x03, 0x80, 0x81, 0x82, 0xff, 0xfe, 0x00, 0x17,
0x74, 0xf9, 0x12, 0x03,
0xf3, 0x00, 0x01, 0x02, 0x03, 0x80, 0x81, 0x82, 0xff, 0xfe, 0x00, 0x17, 0x74,
0xf9, 0x12, 0x03,
];
// Check masking with proper alignment.

4
ntex/src/ws/stream.rs
View file

@ -169,9 +169,7 @@ where
#[cfg(test)]
mod tests {
use super::*;
use crate::{
channel::mpsc, util::next, util::poll_fn, util::send, util::ByteString,
};
use crate::{channel::mpsc, util::next, util::poll_fn, util::send, util::ByteString};
#[crate::rt_test]
async fn test_decoder() {

10
ntex/src/ws/transport.rs
View file

@ -99,11 +99,7 @@ impl<F: Filter> Filter for WsTransport<F> {
None
}
fn release_read_buf(
&self,
mut src: BytesMut,
nbytes: usize,
) -> Result<(), io::Error> {
fn release_read_buf(&self, mut src: BytesMut, nbytes: usize) -> Result<(), io::Error> {
if nbytes == 0 {
if !src.is_empty() {
self.read_buf.set(Some(src));
@ -228,9 +224,7 @@ impl<F: Filter> Filter for WsTransport<F> {
};
self.codec
.encode(Message::Binary(src.freeze()), &mut buf)
.map_err(|_| {
io::Error::new(io::ErrorKind::Other, "Cannot encode ws frame")
})?;
.map_err(|_| io::Error::new(io::ErrorKind::Other, "Cannot encode ws frame"))?;
self.inner.release_write_buf(buf)
}
}

3
ntex/tests/http_awc_openssl_client.rs
View file

@ -50,8 +50,7 @@ async fn test_connection_reuse_h2() {
HttpService::build()
.h2(map_config(
App::new().service(
web::resource("/")
.route(web::to(|| async { HttpResponse::Ok() })),
web::resource("/").route(web::to(|| async { HttpResponse::Ok() })),
),
|_| AppConfig::default(),
))

3
ntex/tests/http_awc_rustls_client.rs
View file

@ -70,8 +70,7 @@ async fn test_connection_reuse_h2() {
HttpService::build()
.h2(map_config(
App::new().service(
web::resource("/")
.route(web::to(|| async { HttpResponse::Ok() })),
web::resource("/").route(web::to(|| async { HttpResponse::Ok() })),
),
|_| AppConfig::default(),
))

5
ntex/tests/http_openssl.rs
View file

@ -404,10 +404,7 @@ async fn test_h2_service_error() {
let mut srv = test_server(move || {
HttpService::build()
.h2(|_| {
err::<Response, _>(InternalError::default(
"error",
StatusCode::BAD_REQUEST,
))
err::<Response, _>(InternalError::default("error", StatusCode::BAD_REQUEST))
})
.openssl(ssl_acceptor())
.map_err(|_| ())

7
ntex/tests/http_server.rs
View file

@ -115,8 +115,8 @@ async fn test_chunked_payload() {
let returned_size = {
let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
let _ = stream
.write_all(b"POST /test HTTP/1.0\r\nTransfer-Encoding: chunked\r\n\r\n");
let _ =
stream.write_all(b"POST /test HTTP/1.0\r\nTransfer-Encoding: chunked\r\n\r\n");
for chunk_size in chunk_sizes.iter() {
let mut bytes = Vec::new();
@ -217,8 +217,7 @@ async fn test_http1_keepalive_close() {
});
let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
let _ =
stream.write_all(b"GET /test/tests/test HTTP/1.1\r\nconnection: close\r\n\r\n");
let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\nconnection: close\r\n\r\n");
let mut data = vec![0; 1024];
let _ = stream.read(&mut data);
assert_eq!(&data[..17], b"HTTP/1.1 200 OK\r\n");

4
ntex/tests/http_ws.rs
View file

@ -58,9 +58,7 @@ impl Service for WsService {
}
}
async fn service(
msg: DispatchItem<ws::Codec>,
) -> Result<Option<ws::Message>, io::Error> {
async fn service(msg: DispatchItem<ws::Codec>) -> Result<Option<ws::Message>, io::Error> {
let msg = match msg {
DispatchItem::Item(msg) => match msg {
ws::Frame::Ping(msg) => ws::Message::Pong(msg),

7
ntex/tests/http_ws_client.rs
View file

@ -33,11 +33,8 @@ async fn test_simple() {
let res = handshake_response(req.head()).finish();
// send handshake respone
io.encode(
h1::Message::Item((res.drop_body(), BodySize::None)),
&codec,
)
.unwrap();
io.encode(h1::Message::Item((res.drop_body(), BodySize::None)), &codec)
.unwrap();
// start websocket service
Dispatcher::new(

44
ntex/tests/web_server.rs
View file

@ -353,14 +353,14 @@ async fn test_body_br_streaming() {
#[ntex::test]
async fn test_head_binary() {
let srv =
test::server_with(test::config().h1(), || {
App::new().service(web::resource("/").route(
web::head().to(move || async {
let srv = test::server_with(test::config().h1(), || {
App::new().service(
web::resource("/")
.route(web::head().to(move || async {
HttpResponse::Ok().content_length(100).body(STR)
}),
))
});
})),
)
});
let mut response = srv.head("/").send().await.unwrap();
assert!(response.status().is_success());
@ -764,14 +764,13 @@ async fn test_brotli_encoding_large_openssl_h1() {
.unwrap();
let data = STR.repeat(10);
let srv =
test::server_with(test::config().openssl(builder.build()).h1(), move || {
App::new().service(web::resource("/").route(web::to(|bytes: Bytes| async {
HttpResponse::Ok()
.encoding(ContentEncoding::Identity)
.body(bytes)
})))
});
let srv = test::server_with(test::config().openssl(builder.build()).h1(), move || {
App::new().service(web::resource("/").route(web::to(|bytes: Bytes| async {
HttpResponse::Ok()
.encoding(ContentEncoding::Identity)
.body(bytes)
})))
});
// body
let mut e = BrotliEncoder::new(Vec::new(), 3);
@ -819,14 +818,13 @@ async fn test_brotli_encoding_large_openssl_h2() {
builder.set_alpn_protos(b"\x08http/1.1\x02h2").unwrap();
let data = STR.repeat(10);
let srv =
test::server_with(test::config().openssl(builder.build()).h2(), move || {
App::new().service(web::resource("/").route(web::to(|bytes: Bytes| async {
HttpResponse::Ok()
.encoding(ContentEncoding::Identity)
.body(bytes)
})))
});
let srv = test::server_with(test::config().openssl(builder.build()).h2(), move || {
App::new().service(web::resource("/").route(web::to(|bytes: Bytes| async {
HttpResponse::Ok()
.encoding(ContentEncoding::Identity)
.body(bytes)
})))
});
// body
let mut e = BrotliEncoder::new(Vec::new(), 3);