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

rename ServiceRequest/ServiceResponse to WebRequest/WebResponse

Browse source
This commit is contained in:
Nikolay Kim 2020-02-26 15:02:59 -08:00
parent c910e595a2
commit 80ea71cee5
16 changed files with 292 additions and 309 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -20,11 +20,11 @@ use super::dev::ResourceDef;
use super::resource::Resource; use super::resource::Resource;
use super::route::Route; use super::route::Route;
use super::service::{ use super::service::{
AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, ServiceRequest, AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, WebRequest,
ServiceResponse, WebResponse,
}; };
type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>; type HttpNewService = BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
type FnDataFactory = type FnDataFactory =
Box<dyn Fn() -> LocalBoxFuture<'static, Result<Box<dyn DataFactory>, ()>>>; Box<dyn Fn() -> LocalBoxFuture<'static, Result<Box<dyn DataFactory>, ()>>>;
@ -65,8 +65,8 @@ where
B: MessageBody, B: MessageBody,
T: ServiceFactory< T: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse<B>, Response = WebResponse<B>,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
@ -270,8 +270,8 @@ where
F: IntoServiceFactory<U>, F: IntoServiceFactory<U>,
U: ServiceFactory< U: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
> + 'static, > + 'static,
U::InitError: fmt::Debug, U::InitError: fmt::Debug,
@ -353,8 +353,8 @@ where
) -> App< ) -> App<
impl ServiceFactory< impl ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse<B1>, Response = WebResponse<B1>,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
@ -363,8 +363,8 @@ where
where where
M: Transform< M: Transform<
T::Service, T::Service,
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse<B1>, Response = WebResponse<B1>,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
@ -420,8 +420,8 @@ where
) -> App< ) -> App<
impl ServiceFactory< impl ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse<B1>, Response = WebResponse<B1>,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
@ -429,8 +429,8 @@ where
> >
where where
B1: MessageBody, B1: MessageBody,
F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone, F: FnMut(WebRequest, &mut T::Service) -> R + Clone,
R: Future<Output = Result<ServiceResponse<B1>, Error>>, R: Future<Output = Result<WebResponse<B1>, Error>>,
{ {
App { App {
endpoint: apply_fn_factory(self.endpoint, mw), endpoint: apply_fn_factory(self.endpoint, mw),
@ -451,8 +451,8 @@ where
B: MessageBody, B: MessageBody,
T: ServiceFactory< T: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse<B>, Response = WebResponse<B>,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
@ -480,7 +480,7 @@ mod tests {
use crate::http::header::{self, HeaderValue}; use crate::http::header::{self, HeaderValue};
use crate::http::{Method, StatusCode}; use crate::http::{Method, StatusCode};
use crate::web::middleware::DefaultHeaders; use crate::web::middleware::DefaultHeaders;
use crate::web::service::ServiceRequest; use crate::web::service::WebRequest;
use crate::web::test::{call_service, init_service, read_body, TestRequest}; use crate::web::test::{call_service, init_service, read_body, TestRequest};
use crate::web::{self, HttpRequest, HttpResponse}; use crate::web::{self, HttpRequest, HttpResponse};
use crate::Service; use crate::Service;
@ -504,12 +504,12 @@ mod tests {
.service(web::resource("/test").to(|| HttpResponse::Ok())) .service(web::resource("/test").to(|| HttpResponse::Ok()))
.service( .service(
web::resource("/test2") web::resource("/test2")
.default_service(|r: ServiceRequest| { .default_service(|r: WebRequest| {
ok(r.into_response(HttpResponse::Created())) ok(r.into_response(HttpResponse::Created()))
}) })
.route(web::get().to(|| HttpResponse::Ok())), .route(web::get().to(|| HttpResponse::Ok())),
) )
.default_service(|r: ServiceRequest| { .default_service(|r: WebRequest| {
ok(r.into_response(HttpResponse::MethodNotAllowed())) ok(r.into_response(HttpResponse::MethodNotAllowed()))
}), }),
) )

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

@ -17,50 +17,50 @@ use super::data::DataFactory;
use super::guard::Guard; use super::guard::Guard;
use super::request::{HttpRequest, HttpRequestPool}; use super::request::{HttpRequest, HttpRequestPool};
use super::rmap::ResourceMap; use super::rmap::ResourceMap;
use super::service::{AppServiceFactory, ServiceRequest, ServiceResponse}; use super::service::{AppServiceFactory, WebRequest, WebResponse};
type Guards = Vec<Box<dyn Guard>>; type Guards = Vec<Box<dyn Guard>>;
type HttpService = BoxService<ServiceRequest, ServiceResponse, Error>; type HttpService = BoxService<WebRequest, WebResponse, Error>;
type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>; type HttpNewService = BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
type BoxResponse = LocalBoxFuture<'static, Result<ServiceResponse, Error>>; type BoxResponse = LocalBoxFuture<'static, Result<WebResponse, Error>>;
type FnDataFactory = type FnDataFactory =
Box<dyn Fn() -> LocalBoxFuture<'static, Result<Box<dyn DataFactory>, ()>>>; Box<dyn Fn() -> LocalBoxFuture<'static, Result<Box<dyn DataFactory>, ()>>>;
/// Service factory to convert `Request` to a `ServiceRequest<S>`. /// Service factory to convert `Request` to a `WebRequest<S>`.
/// It also executes data factories. /// It also executes data factories.
pub struct AppInit<T, B> pub struct AppInit<T, B>
where where
T: ServiceFactory< T: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse<B>, Response = WebResponse<B>,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
{ {
pub(crate) endpoint: T, pub(super) endpoint: T,
pub(crate) extensions: RefCell<Option<Extensions>>, pub(super) extensions: RefCell<Option<Extensions>>,
pub(crate) data: Rc<Vec<Box<dyn DataFactory>>>, pub(super) data: Rc<Vec<Box<dyn DataFactory>>>,
pub(crate) data_factories: Rc<Vec<FnDataFactory>>, pub(super) data_factories: Rc<Vec<FnDataFactory>>,
pub(crate) services: Rc<RefCell<Vec<Box<dyn AppServiceFactory>>>>, pub(super) services: Rc<RefCell<Vec<Box<dyn AppServiceFactory>>>>,
pub(crate) default: Option<Rc<HttpNewService>>, pub(super) default: Option<Rc<HttpNewService>>,
pub(crate) factory_ref: Rc<RefCell<Option<AppRoutingFactory>>>, pub(super) factory_ref: Rc<RefCell<Option<AppRoutingFactory>>>,
pub(crate) external: RefCell<Vec<ResourceDef>>, pub(super) external: RefCell<Vec<ResourceDef>>,
} }
impl<T, B> ServiceFactory for AppInit<T, B> impl<T, B> ServiceFactory for AppInit<T, B>
where where
T: ServiceFactory< T: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse<B>, Response = WebResponse<B>,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
{ {
type Config = AppConfig; type Config = AppConfig;
type Request = Request; type Request = Request;
type Response = ServiceResponse<B>; type Response = WebResponse<B>;
type Error = T::Error; type Error = T::Error;
type InitError = T::InitError; type InitError = T::InitError;
type Service = AppInitService<T::Service, B>; type Service = AppInitService<T::Service, B>;
@ -69,7 +69,7 @@ where
fn new_service(&self, config: AppConfig) -> Self::Future { fn new_service(&self, config: AppConfig) -> Self::Future {
// update resource default service // update resource default service
let default = self.default.clone().unwrap_or_else(|| { let default = self.default.clone().unwrap_or_else(|| {
Rc::new(boxed::factory(fn_service(|req: ServiceRequest| { Rc::new(boxed::factory(fn_service(|req: WebRequest| {
ok(req.into_response(Response::NotFound().finish())) ok(req.into_response(Response::NotFound().finish()))
}))) })))
}); });
@ -149,8 +149,8 @@ impl<T, B> Future for AppInitResult<T, B>
where where
T: ServiceFactory< T: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse<B>, Response = WebResponse<B>,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
@ -202,10 +202,10 @@ where
} }
} }
/// Service to convert `Request` to a `ServiceRequest<S>` /// Service to convert `Request` to a `WebRequest<S>`
pub struct AppInitService<T, B> pub struct AppInitService<T, B>
where where
T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>, T: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
{ {
service: T, service: T,
rmap: Rc<ResourceMap>, rmap: Rc<ResourceMap>,
@ -216,10 +216,10 @@ where
impl<T, B> Service for AppInitService<T, B> impl<T, B> Service for AppInitService<T, B>
where where
T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>, T: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
{ {
type Request = Request; type Request = Request;
type Response = ServiceResponse<B>; type Response = WebResponse<B>;
type Error = T::Error; type Error = T::Error;
type Future = T::Future; type Future = T::Future;
@ -249,13 +249,13 @@ where
self.pool, self.pool,
) )
}; };
self.service.call(ServiceRequest::new(req)) self.service.call(WebRequest::new(req))
} }
} }
impl<T, B> Drop for AppInitService<T, B> impl<T, B> Drop for AppInitService<T, B>
where where
T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>, T: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
{ {
fn drop(&mut self) { fn drop(&mut self) {
self.pool.clear(); self.pool.clear();
@ -269,8 +269,8 @@ pub struct AppRoutingFactory {
impl ServiceFactory for AppRoutingFactory { impl ServiceFactory for AppRoutingFactory {
type Config = (); type Config = ();
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = Error; type Error = Error;
type InitError = (); type InitError = ();
type Service = AppRouting; type Service = AppRouting;
@ -374,13 +374,13 @@ impl Future for AppRoutingFactoryResponse {
pub struct AppRouting { pub struct AppRouting {
router: Router<HttpService, Guards>, router: Router<HttpService, Guards>,
ready: Option<(ServiceRequest, ResourceInfo)>, ready: Option<(WebRequest, ResourceInfo)>,
default: Option<HttpService>, default: Option<HttpService>,
} }
impl Service for AppRouting { impl Service for AppRouting {
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = Error; type Error = Error;
type Future = BoxResponse; type Future = BoxResponse;
@ -392,7 +392,7 @@ impl Service for AppRouting {
} }
} }
fn call(&mut self, mut req: ServiceRequest) -> Self::Future { fn call(&mut self, mut req: WebRequest) -> Self::Future {
let res = self.router.recognize_mut_checked(&mut req, |req, guards| { let res = self.router.recognize_mut_checked(&mut req, |req, guards| {
if let Some(ref guards) = guards { if let Some(ref guards) = guards {
for f in guards { for f in guards {
@ -410,7 +410,7 @@ impl Service for AppRouting {
default.call(req) default.call(req)
} else { } else {
let req = req.into_parts().0; let req = req.into_parts().0;
ok(ServiceResponse::new(req, Response::NotFound().finish())).boxed_local() ok(WebResponse::new(req, Response::NotFound().finish())).boxed_local()
} }
} }
} }
@ -428,8 +428,8 @@ impl AppEntry {
impl ServiceFactory for AppEntry { impl ServiceFactory for AppEntry {
type Config = (); type Config = ();
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = Error; type Error = Error;
type InitError = (); type InitError = ();
type Service = AppRouting; type Service = AppRouting;

17
ntex/src/web/config.rs
View file

@ -12,13 +12,12 @@ use super::resource::Resource;
use super::rmap::ResourceMap; use super::rmap::ResourceMap;
use super::route::Route; use super::route::Route;
use super::service::{ use super::service::{
AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, ServiceRequest, AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, WebRequest,
ServiceResponse, WebResponse,
}; };
type Guards = Vec<Box<dyn Guard>>; type Guards = Vec<Box<dyn Guard>>;
type HttpNewService = type HttpNewService = boxed::BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
boxed::BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
/// Application configuration /// Application configuration
pub struct AppService { pub struct AppService {
@ -108,8 +107,8 @@ impl AppService {
F: IntoServiceFactory<S>, F: IntoServiceFactory<S>,
S: ServiceFactory< S: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
> + 'static, > + 'static,
@ -174,9 +173,9 @@ impl Default for AppConfig {
/// to set of external methods. This could help with /// to set of external methods. This could help with
/// modularization of big application configuration. /// modularization of big application configuration.
pub struct ServiceConfig { pub struct ServiceConfig {
pub(crate) services: Vec<Box<dyn AppServiceFactory>>, pub(super) services: Vec<Box<dyn AppServiceFactory>>,
pub(crate) data: Vec<Box<dyn DataFactory>>, pub(super) data: Vec<Box<dyn DataFactory>>,
pub(crate) external: Vec<ResourceDef>, pub(super) external: Vec<ResourceDef>,
} }
impl ServiceConfig { impl ServiceConfig {

56
ntex/src/web/handler.rs
View file

@ -14,7 +14,7 @@ use crate::{Service, ServiceFactory};
use super::extract::FromRequest; use super::extract::FromRequest;
use super::request::HttpRequest; use super::request::HttpRequest;
use super::responder::Responder; use super::responder::Responder;
use super::service::{ServiceRequest, ServiceResponse}; use super::service::{WebRequest, WebResponse};
/// Async handler converter factory /// Async handler converter factory
pub trait Factory<T, R, O>: Clone + 'static pub trait Factory<T, R, O>: Clone + 'static
@ -82,16 +82,16 @@ where
O: Responder, O: Responder,
{ {
type Request = (T, HttpRequest); type Request = (T, HttpRequest);
type Response = ServiceResponse; type Response = WebResponse;
type Error = Infallible; type Error = Infallible;
type Future = HandlerServiceResponse<R, O>; type Future = HandlerWebResponse<R, O>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, (param, req): (T, HttpRequest)) -> Self::Future { fn call(&mut self, (param, req): (T, HttpRequest)) -> Self::Future {
HandlerServiceResponse { HandlerWebResponse {
fut: self.hnd.call(param), fut: self.hnd.call(param),
fut2: None, fut2: None,
req: Some(req), req: Some(req),
@ -101,7 +101,7 @@ where
#[doc(hidden)] #[doc(hidden)]
#[pin_project] #[pin_project]
pub struct HandlerServiceResponse<T, R> pub struct HandlerWebResponse<T, R>
where where
T: Future<Output = R>, T: Future<Output = R>,
R: Responder, R: Responder,
@ -113,12 +113,12 @@ where
req: Option<HttpRequest>, req: Option<HttpRequest>,
} }
impl<T, R> Future for HandlerServiceResponse<T, R> impl<T, R> Future for HandlerWebResponse<T, R>
where where
T: Future<Output = R>, T: Future<Output = R>,
R: Responder, R: Responder,
{ {
type Output = Result<ServiceResponse, Infallible>; type Output = Result<WebResponse, Infallible>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.as_mut().project(); let this = self.as_mut().project();
@ -126,12 +126,12 @@ where
if let Some(fut) = this.fut2.as_pin_mut() { if let Some(fut) = this.fut2.as_pin_mut() {
return match fut.poll(cx) { return match fut.poll(cx) {
Poll::Ready(Ok(res)) => { Poll::Ready(Ok(res)) => {
Poll::Ready(Ok(ServiceResponse::new(this.req.take().unwrap(), res))) Poll::Ready(Ok(WebResponse::new(this.req.take().unwrap(), res)))
} }
Poll::Pending => Poll::Pending, Poll::Pending => Poll::Pending,
Poll::Ready(Err(e)) => { Poll::Ready(Err(e)) => {
let res: Response = e.into().into(); let res: Response = e.into().into();
Poll::Ready(Ok(ServiceResponse::new(this.req.take().unwrap(), res))) Poll::Ready(Ok(WebResponse::new(this.req.take().unwrap(), res)))
} }
}; };
} }
@ -164,16 +164,13 @@ impl<T: FromRequest, S> Extract<T, S> {
impl<T: FromRequest, S> ServiceFactory for Extract<T, S> impl<T: FromRequest, S> ServiceFactory for Extract<T, S>
where where
S: Service< S: Service<Request = (T, HttpRequest), Response = WebResponse, Error = Infallible>
Request = (T, HttpRequest), + Clone,
Response = ServiceResponse,
Error = Infallible,
> + Clone,
{ {
type Config = (); type Config = ();
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = (Error, ServiceRequest); type Error = (Error, WebRequest);
type InitError = (); type InitError = ();
type Service = ExtractService<T, S>; type Service = ExtractService<T, S>;
type Future = Ready<Result<Self::Service, ()>>; type Future = Ready<Result<Self::Service, ()>>;
@ -193,22 +190,19 @@ pub struct ExtractService<T: FromRequest, S> {
impl<T: FromRequest, S> Service for ExtractService<T, S> impl<T: FromRequest, S> Service for ExtractService<T, S>
where where
S: Service< S: Service<Request = (T, HttpRequest), Response = WebResponse, Error = Infallible>
Request = (T, HttpRequest), + Clone,
Response = ServiceResponse,
Error = Infallible,
> + Clone,
{ {
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = (Error, ServiceRequest); type Error = (Error, WebRequest);
type Future = ExtractResponse<T, S>; type Future = ExtractResponse<T, S>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&mut self, req: WebRequest) -> Self::Future {
let (req, mut payload) = req.into_parts(); let (req, mut payload) = req.into_parts();
let fut = T::from_request(&req, &mut payload); let fut = T::from_request(&req, &mut payload);
@ -233,13 +227,9 @@ pub struct ExtractResponse<T: FromRequest, S: Service> {
impl<T: FromRequest, S> Future for ExtractResponse<T, S> impl<T: FromRequest, S> Future for ExtractResponse<T, S>
where where
S: Service< S: Service<Request = (T, HttpRequest), Response = WebResponse, Error = Infallible>,
Request = (T, HttpRequest),
Response = ServiceResponse,
Error = Infallible,
>,
{ {
type Output = Result<ServiceResponse, (Error, ServiceRequest)>; type Output = Result<WebResponse, (Error, WebRequest)>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.as_mut().project(); let this = self.as_mut().project();
@ -250,7 +240,7 @@ where
match ready!(this.fut.poll(cx)) { match ready!(this.fut.poll(cx)) {
Err(e) => { Err(e) => {
let req = ServiceRequest::new(this.req.clone()); let req = WebRequest::new(this.req.clone());
Poll::Ready(Err((e.into(), req))) Poll::Ready(Err((e.into(), req)))
} }
Ok(item) => { Ok(item) => {

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

@ -16,7 +16,7 @@ use crate::http::Error;
use crate::service::{Service, Transform}; use crate::service::{Service, Transform};
use crate::web::dev::BodyEncoding; use crate::web::dev::BodyEncoding;
use crate::web::service::{ServiceRequest, ServiceResponse}; use crate::web::service::{WebRequest, WebResponse};
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
/// `Middleware` for compressing response body. /// `Middleware` for compressing response body.
@ -55,10 +55,10 @@ impl Default for Compress {
impl<S, B> Transform<S> for Compress impl<S, B> Transform<S> for Compress
where where
B: MessageBody, B: MessageBody,
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
{ {
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse<Encoder<B>>; type Response = WebResponse<Encoder<B>>;
type Error = Error; type Error = Error;
type InitError = (); type InitError = ();
type Transform = CompressMiddleware<S>; type Transform = CompressMiddleware<S>;
@ -80,10 +80,10 @@ pub struct CompressMiddleware<S> {
impl<S, B> Service for CompressMiddleware<S> impl<S, B> Service for CompressMiddleware<S>
where where
B: MessageBody, B: MessageBody,
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
{ {
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse<Encoder<B>>; type Response = WebResponse<Encoder<B>>;
type Error = Error; type Error = Error;
type Future = CompressResponse<S, B>; type Future = CompressResponse<S, B>;
@ -91,7 +91,7 @@ where
self.service.poll_ready(cx) self.service.poll_ready(cx)
} }
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&mut self, req: WebRequest) -> Self::Future {
// negotiate content-encoding // negotiate content-encoding
let encoding = if let Some(val) = req.headers().get(&ACCEPT_ENCODING) { let encoding = if let Some(val) = req.headers().get(&ACCEPT_ENCODING) {
if let Ok(enc) = val.to_str() { if let Ok(enc) = val.to_str() {
@ -127,9 +127,9 @@ where
impl<S, B> Future for CompressResponse<S, B> impl<S, B> Future for CompressResponse<S, B>
where where
B: MessageBody, B: MessageBody,
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
{ {
type Output = Result<ServiceResponse<Encoder<B>>, Error>; type Output = Result<WebResponse<Encoder<B>>, Error>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project(); let this = self.project();

18
ntex/src/web/middleware/cors.rs
View file

@ -46,7 +46,7 @@ use std::rc::Rc;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
use actix_service::{Service, Transform}; use actix_service::{Service, Transform};
use actix_web::dev::{RequestHead, ServiceRequest, ServiceResponse}; use actix_web::dev::{RequestHead, WebRequest, WebResponse};
use actix_web::error::{Error, ResponseError, Result}; use actix_web::error::{Error, ResponseError, Result};
use actix_web::http::header::{self, HeaderName, HeaderValue}; use actix_web::http::header::{self, HeaderName, HeaderValue};
use actix_web::http::{self, Error as HttpError, Method, StatusCode, Uri}; use actix_web::http::{self, Error as HttpError, Method, StatusCode, Uri};
@ -535,12 +535,12 @@ pub struct CorsFactory {
impl<S, B> Transform<S> for CorsFactory impl<S, B> Transform<S> for CorsFactory
where where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
S::Future: 'static, S::Future: 'static,
B: 'static, B: 'static,
{ {
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse<B>; type Response = WebResponse<B>;
type Error = Error; type Error = Error;
type InitError = (); type InitError = ();
type Transform = CorsMiddleware<S>; type Transform = CorsMiddleware<S>;
@ -678,12 +678,12 @@ impl Inner {
impl<S, B> Service for CorsMiddleware<S> impl<S, B> Service for CorsMiddleware<S>
where where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
S::Future: 'static, S::Future: 'static,
B: 'static, B: 'static,
{ {
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse<B>; type Response = WebResponse<B>;
type Error = Error; type Error = Error;
type Future = Either< type Future = Either<
Ready<Result<Self::Response, Error>>, Ready<Result<Self::Response, Error>>,
@ -694,7 +694,7 @@ where
self.service.poll_ready(cx) self.service.poll_ready(cx)
} }
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&mut self, req: WebRequest) -> Self::Future {
if self.inner.preflight && Method::OPTIONS == *req.method() { if self.inner.preflight && Method::OPTIONS == *req.method() {
if let Err(e) = self if let Err(e) = self
.inner .inner
@ -1083,7 +1083,7 @@ mod tests {
.expose_headers(exposed_headers.clone()) .expose_headers(exposed_headers.clone())
.allowed_header(header::CONTENT_TYPE) .allowed_header(header::CONTENT_TYPE)
.finish() .finish()
.new_transform(fn_service(|req: ServiceRequest| { .new_transform(fn_service(|req: WebRequest| {
ok(req.into_response( ok(req.into_response(
HttpResponse::Ok().header(header::VARY, "Accept").finish(), HttpResponse::Ok().header(header::VARY, "Accept").finish(),
)) ))

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

@ -8,7 +8,7 @@ use futures::future::{ok, FutureExt, LocalBoxFuture, Ready};
use crate::http::error::{Error, HttpError}; use crate::http::error::{Error, HttpError};
use crate::http::header::{HeaderMap, HeaderName, HeaderValue, CONTENT_TYPE}; use crate::http::header::{HeaderMap, HeaderName, HeaderValue, CONTENT_TYPE};
use crate::service::{Service, Transform}; use crate::service::{Service, Transform};
use crate::web::service::{ServiceRequest, ServiceResponse}; use crate::web::service::{WebRequest, WebResponse};
/// `Middleware` for setting default response headers. /// `Middleware` for setting default response headers.
/// ///
@ -91,11 +91,11 @@ impl DefaultHeaders {
impl<S, B> Transform<S> for DefaultHeaders impl<S, B> Transform<S> for DefaultHeaders
where where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
S::Future: 'static, S::Future: 'static,
{ {
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse<B>; type Response = WebResponse<B>;
type Error = Error; type Error = Error;
type InitError = (); type InitError = ();
type Transform = DefaultHeadersMiddleware<S>; type Transform = DefaultHeadersMiddleware<S>;
@ -116,11 +116,11 @@ pub struct DefaultHeadersMiddleware<S> {
impl<S, B> Service for DefaultHeadersMiddleware<S> impl<S, B> Service for DefaultHeadersMiddleware<S>
where where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
S::Future: 'static, S::Future: 'static,
{ {
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse<B>; type Response = WebResponse<B>;
type Error = Error; type Error = Error;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>; type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
@ -128,7 +128,7 @@ where
self.service.poll_ready(cx) self.service.poll_ready(cx)
} }
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&mut self, req: WebRequest) -> Self::Future {
let inner = self.inner.clone(); let inner = self.inner.clone();
let fut = self.service.call(req); let fut = self.service.call(req);
@ -161,7 +161,7 @@ mod tests {
use super::*; use super::*;
use crate::http::header::CONTENT_TYPE; use crate::http::header::CONTENT_TYPE;
use crate::service::IntoService; use crate::service::IntoService;
use crate::web::service::ServiceRequest; use crate::web::service::WebRequest;
use crate::web::test::{ok_service, TestRequest}; use crate::web::test::{ok_service, TestRequest};
use crate::web::HttpResponse; use crate::web::HttpResponse;
@ -178,7 +178,7 @@ mod tests {
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001"); assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
let req = TestRequest::default().to_srv_request(); let req = TestRequest::default().to_srv_request();
let srv = |req: ServiceRequest| { let srv = |req: WebRequest| {
ok(req ok(req
.into_response(HttpResponse::Ok().header(CONTENT_TYPE, "0002").finish())) .into_response(HttpResponse::Ok().header(CONTENT_TYPE, "0002").finish()))
}; };
@ -193,8 +193,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_content_type() { async fn test_content_type() {
let srv = let srv = |req: WebRequest| ok(req.into_response(HttpResponse::Ok().finish()));
|req: ServiceRequest| ok(req.into_response(HttpResponse::Ok().finish()));
let mut mw = DefaultHeaders::new() let mut mw = DefaultHeaders::new()
.content_type() .content_type()
.new_transform(srv.into_service()) .new_transform(srv.into_service())

24
ntex/src/web/middleware/logger.rs
View file

@ -20,7 +20,7 @@ use crate::http::error::Error;
use crate::http::header::HeaderName; use crate::http::header::HeaderName;
use crate::http::StatusCode; use crate::http::StatusCode;
use crate::service::{Service, Transform}; use crate::service::{Service, Transform};
use crate::web::service::{ServiceRequest, ServiceResponse}; use crate::web::service::{WebRequest, WebResponse};
use crate::web::HttpResponse; use crate::web::HttpResponse;
/// `Middleware` for logging request and response info to the terminal. /// `Middleware` for logging request and response info to the terminal.
@ -121,11 +121,11 @@ impl Default for Logger {
impl<S, B> Transform<S> for Logger impl<S, B> Transform<S> for Logger
where where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
B: MessageBody, B: MessageBody,
{ {
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse<StreamLog<B>>; type Response = WebResponse<StreamLog<B>>;
type Error = Error; type Error = Error;
type InitError = (); type InitError = ();
type Transform = LoggerMiddleware<S>; type Transform = LoggerMiddleware<S>;
@ -147,11 +147,11 @@ pub struct LoggerMiddleware<S> {
impl<S, B> Service for LoggerMiddleware<S> impl<S, B> Service for LoggerMiddleware<S>
where where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
B: MessageBody, B: MessageBody,
{ {
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse<StreamLog<B>>; type Response = WebResponse<StreamLog<B>>;
type Error = Error; type Error = Error;
type Future = LoggerResponse<S, B>; type Future = LoggerResponse<S, B>;
@ -159,7 +159,7 @@ where
self.service.poll_ready(cx) self.service.poll_ready(cx)
} }
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&mut self, req: WebRequest) -> Self::Future {
if self.inner.exclude.contains(req.path()) { if self.inner.exclude.contains(req.path()) {
LoggerResponse { LoggerResponse {
fut: self.service.call(req), fut: self.service.call(req),
@ -201,9 +201,9 @@ where
impl<S, B> Future for LoggerResponse<S, B> impl<S, B> Future for LoggerResponse<S, B>
where where
B: MessageBody, B: MessageBody,
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>, S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
{ {
type Output = Result<ServiceResponse<StreamLog<B>>, Error>; type Output = Result<WebResponse<StreamLog<B>>, Error>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project(); let this = self.project();
@ -418,7 +418,7 @@ impl FormatText {
} }
} }
fn render_request(&mut self, now: OffsetDateTime, req: &ServiceRequest) { fn render_request(&mut self, now: OffsetDateTime, req: &WebRequest) {
match *self { match *self {
FormatText::RequestLine => { FormatText::RequestLine => {
*self = if req.query_string().is_empty() { *self = if req.query_string().is_empty() {
@ -488,7 +488,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_logger() { async fn test_logger() {
let srv = |req: ServiceRequest| { let srv = |req: WebRequest| {
ok(req.into_response( ok(req.into_response(
HttpResponse::build(StatusCode::OK) HttpResponse::build(StatusCode::OK)
.header("X-Test", "ttt") .header("X-Test", "ttt")

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

@ -115,7 +115,7 @@ pub mod dev {
pub use crate::web::info::ConnectionInfo; pub use crate::web::info::ConnectionInfo;
pub use crate::web::rmap::ResourceMap; pub use crate::web::rmap::ResourceMap;
pub use crate::web::service::{ pub use crate::web::service::{
HttpServiceFactory, ServiceRequest, ServiceResponse, WebService, HttpServiceFactory, WebRequest, WebResponse, WebService,
}; };
pub use crate::web::types::form::UrlEncoded; pub use crate::web::types::form::UrlEncoded;

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

@ -20,10 +20,10 @@ use crate::web::guard::Guard;
use crate::web::handler::Factory; use crate::web::handler::Factory;
use crate::web::responder::Responder; use crate::web::responder::Responder;
use crate::web::route::{CreateRouteService, Route, RouteService}; use crate::web::route::{CreateRouteService, Route, RouteService};
use crate::web::service::{ServiceRequest, ServiceResponse}; use crate::web::service::{WebRequest, WebResponse};
type HttpService = BoxService<ServiceRequest, ServiceResponse, Error>; type HttpService = BoxService<WebRequest, WebResponse, Error>;
type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>; type HttpNewService = BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
/// *Resource* is an entry in resources table which corresponds to requested URL. /// *Resource* is an entry in resources table which corresponds to requested URL.
/// ///
@ -79,8 +79,8 @@ impl<T> Resource<T>
where where
T: ServiceFactory< T: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
@ -250,8 +250,8 @@ where
) -> Resource< ) -> Resource<
impl ServiceFactory< impl ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
@ -259,8 +259,8 @@ where
where where
M: Transform< M: Transform<
T::Service, T::Service,
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
@ -279,7 +279,7 @@ where
/// Register a resource middleware function. /// Register a resource middleware function.
/// ///
/// This function accepts instance of `ServiceRequest` type and /// This function accepts instance of `WebRequest` type and
/// mutable reference to the next middleware in chain. /// mutable reference to the next middleware in chain.
/// ///
/// This is similar to `App's` middlewares, but middleware get invoked on resource level. /// This is similar to `App's` middlewares, but middleware get invoked on resource level.
@ -317,15 +317,15 @@ where
) -> Resource< ) -> Resource<
impl ServiceFactory< impl ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
> >
where where
F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone, F: FnMut(WebRequest, &mut T::Service) -> R + Clone,
R: Future<Output = Result<ServiceResponse, Error>>, R: Future<Output = Result<WebResponse, Error>>,
{ {
Resource { Resource {
endpoint: apply_fn_factory(self.endpoint, mw), endpoint: apply_fn_factory(self.endpoint, mw),
@ -347,8 +347,8 @@ where
F: IntoServiceFactory<U>, F: IntoServiceFactory<U>,
U: ServiceFactory< U: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
> + 'static, > + 'static,
U::InitError: fmt::Debug, U::InitError: fmt::Debug,
@ -368,8 +368,8 @@ impl<T> HttpServiceFactory for Resource<T>
where where
T: ServiceFactory< T: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
> + 'static, > + 'static,
@ -400,8 +400,8 @@ impl<T> IntoServiceFactory<T> for Resource<T>
where where
T: ServiceFactory< T: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
@ -425,8 +425,8 @@ pub struct ResourceFactory {
impl ServiceFactory for ResourceFactory { impl ServiceFactory for ResourceFactory {
type Config = (); type Config = ();
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = Error; type Error = Error;
type InitError = (); type InitError = ();
type Service = ResourceService; type Service = ResourceService;
@ -519,19 +519,19 @@ pub struct ResourceService {
} }
impl Service for ResourceService { impl Service for ResourceService {
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = Error; type Error = Error;
type Future = Either< type Future = Either<
Ready<Result<ServiceResponse, Error>>, Ready<Result<WebResponse, Error>>,
LocalBoxFuture<'static, Result<ServiceResponse, Error>>, LocalBoxFuture<'static, Result<WebResponse, Error>>,
>; >;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, mut req: ServiceRequest) -> Self::Future { fn call(&mut self, mut req: WebRequest) -> Self::Future {
for route in self.routes.iter_mut() { for route in self.routes.iter_mut() {
if route.check(&mut req) { if route.check(&mut req) {
if let Some(ref data) = self.data { if let Some(ref data) = self.data {
@ -544,7 +544,7 @@ impl Service for ResourceService {
Either::Right(default.call(req)) Either::Right(default.call(req))
} else { } else {
let req = req.into_parts().0; let req = req.into_parts().0;
Either::Left(ok(ServiceResponse::new( Either::Left(ok(WebResponse::new(
req, req,
Response::MethodNotAllowed().finish(), Response::MethodNotAllowed().finish(),
))) )))
@ -565,8 +565,8 @@ impl ResourceEndpoint {
impl ServiceFactory for ResourceEndpoint { impl ServiceFactory for ResourceEndpoint {
type Config = (); type Config = ();
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = Error; type Error = Error;
type InitError = (); type InitError = ();
type Service = ResourceService; type Service = ResourceService;
@ -587,7 +587,7 @@ mod tests {
use crate::http::header::{self, HeaderValue}; use crate::http::header::{self, HeaderValue};
use crate::http::{Error, Method, StatusCode}; use crate::http::{Error, Method, StatusCode};
use crate::web::middleware::DefaultHeaders; use crate::web::middleware::DefaultHeaders;
use crate::web::service::ServiceRequest; use crate::web::service::WebRequest;
use crate::web::test::{call_service, init_service, TestRequest}; use crate::web::test::{call_service, init_service, TestRequest};
use crate::web::{self, guard, App, HttpResponse}; use crate::web::{self, guard, App, HttpResponse};
use crate::Service; use crate::Service;
@ -683,7 +683,7 @@ mod tests {
.service( .service(
web::resource("/test").route(web::get().to(|| HttpResponse::Ok())), web::resource("/test").route(web::get().to(|| HttpResponse::Ok())),
) )
.default_service(|r: ServiceRequest| { .default_service(|r: WebRequest| {
ok(r.into_response(HttpResponse::BadRequest())) ok(r.into_response(HttpResponse::BadRequest()))
}), }),
) )
@ -702,7 +702,7 @@ mod tests {
App::new().service( App::new().service(
web::resource("/test") web::resource("/test")
.route(web::get().to(|| HttpResponse::Ok())) .route(web::get().to(|| HttpResponse::Ok()))
.default_service(|r: ServiceRequest| { .default_service(|r: WebRequest| {
ok(r.into_response(HttpResponse::BadRequest())) ok(r.into_response(HttpResponse::BadRequest()))
}), }),
), ),

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

@ -12,7 +12,7 @@ use crate::web::extract::FromRequest;
use crate::web::guard::{self, Guard}; use crate::web::guard::{self, Guard};
use crate::web::handler::{Extract, Factory, Handler}; use crate::web::handler::{Extract, Factory, Handler};
use crate::web::responder::Responder; use crate::web::responder::Responder;
use crate::web::service::{ServiceRequest, ServiceResponse}; use crate::web::service::{WebRequest, WebResponse};
use crate::web::HttpResponse; use crate::web::HttpResponse;
type BoxedRouteService<Req, Res> = Box< type BoxedRouteService<Req, Res> = Box<
@ -41,7 +41,7 @@ type BoxedRouteNewService<Req, Res> = Box<
/// Route uses builder-like pattern for configuration. /// Route uses builder-like pattern for configuration.
/// If handler is not explicitly set, default *404 Not Found* handler is used. /// If handler is not explicitly set, default *404 Not Found* handler is used.
pub struct Route { pub struct Route {
service: BoxedRouteNewService<ServiceRequest, ServiceResponse>, service: BoxedRouteNewService<WebRequest, WebResponse>,
guards: Rc<Vec<Box<dyn Guard>>>, guards: Rc<Vec<Box<dyn Guard>>>,
} }
@ -63,8 +63,8 @@ impl Route {
impl ServiceFactory for Route { impl ServiceFactory for Route {
type Config = (); type Config = ();
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = Error; type Error = Error;
type InitError = (); type InitError = ();
type Service = RouteService; type Service = RouteService;
@ -78,10 +78,8 @@ impl ServiceFactory for Route {
} }
} }
type RouteFuture = LocalBoxFuture< type RouteFuture =
'static, LocalBoxFuture<'static, Result<BoxedRouteService<WebRequest, WebResponse>, ()>>;
Result<BoxedRouteService<ServiceRequest, ServiceResponse>, ()>,
>;
#[pin_project::pin_project] #[pin_project::pin_project]
pub struct CreateRouteService { pub struct CreateRouteService {
@ -107,12 +105,12 @@ impl Future for CreateRouteService {
} }
pub struct RouteService { pub struct RouteService {
service: BoxedRouteService<ServiceRequest, ServiceResponse>, service: BoxedRouteService<WebRequest, WebResponse>,
guards: Rc<Vec<Box<dyn Guard>>>, guards: Rc<Vec<Box<dyn Guard>>>,
} }
impl RouteService { impl RouteService {
pub fn check(&self, req: &mut ServiceRequest) -> bool { pub fn check(&self, req: &mut WebRequest) -> bool {
for f in self.guards.iter() { for f in self.guards.iter() {
if !f.check(req.head()) { if !f.check(req.head()) {
return false; return false;
@ -123,8 +121,8 @@ impl RouteService {
} }
impl Service for RouteService { impl Service for RouteService {
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = Error; type Error = Error;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>; type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
@ -132,7 +130,7 @@ impl Service for RouteService {
self.service.poll_ready(cx) self.service.poll_ready(cx)
} }
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&mut self, req: WebRequest) -> Self::Future {
self.service.call(req).boxed_local() self.service.call(req).boxed_local()
} }
} }
@ -239,7 +237,7 @@ impl Route {
struct RouteNewService<T> struct RouteNewService<T>
where where
T: ServiceFactory<Request = ServiceRequest, Error = (Error, ServiceRequest)>, T: ServiceFactory<Request = WebRequest, Error = (Error, WebRequest)>,
{ {
service: T, service: T,
} }
@ -248,9 +246,9 @@ impl<T> RouteNewService<T>
where where
T: ServiceFactory< T: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = (Error, ServiceRequest), Error = (Error, WebRequest),
>, >,
T::Future: 'static, T::Future: 'static,
T::Service: 'static, T::Service: 'static,
@ -265,20 +263,20 @@ impl<T> ServiceFactory for RouteNewService<T>
where where
T: ServiceFactory< T: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = (Error, ServiceRequest), Error = (Error, WebRequest),
>, >,
T::Future: 'static, T::Future: 'static,
T::Service: 'static, T::Service: 'static,
<T::Service as Service>::Future: 'static, <T::Service as Service>::Future: 'static,
{ {
type Config = (); type Config = ();
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = Error; type Error = Error;
type InitError = (); type InitError = ();
type Service = BoxedRouteService<ServiceRequest, Self::Response>; type Service = BoxedRouteService<WebRequest, Self::Response>;
type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>; type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
fn new_service(&self, _: ()) -> Self::Future { fn new_service(&self, _: ()) -> Self::Future {
@ -304,13 +302,13 @@ impl<T> Service for RouteServiceWrapper<T>
where where
T::Future: 'static, T::Future: 'static,
T: Service< T: Service<
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = (Error, ServiceRequest), Error = (Error, WebRequest),
>, >,
{ {
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = Error; type Error = Error;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>; type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
@ -318,7 +316,7 @@ where
self.service.poll_ready(cx).map_err(|(e, _)| e) self.service.poll_ready(cx).map_err(|(e, _)| e)
} }
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&mut self, req: WebRequest) -> Self::Future {
self.service self.service
.call(req) .call(req)
.map(|res| match res { .map(|res| match res {

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

@ -20,13 +20,13 @@ use crate::web::resource::Resource;
use crate::web::rmap::ResourceMap; use crate::web::rmap::ResourceMap;
use crate::web::route::Route; use crate::web::route::Route;
use crate::web::service::{ use crate::web::service::{
AppServiceFactory, ServiceFactoryWrapper, ServiceRequest, ServiceResponse, AppServiceFactory, ServiceFactoryWrapper, WebRequest, WebResponse,
}; };
type Guards = Vec<Box<dyn Guard>>; type Guards = Vec<Box<dyn Guard>>;
type HttpService = BoxService<ServiceRequest, ServiceResponse, Error>; type HttpService = BoxService<WebRequest, WebResponse, Error>;
type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>; type HttpNewService = BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
type BoxedResponse = LocalBoxFuture<'static, Result<ServiceResponse, Error>>; type BoxedResponse = LocalBoxFuture<'static, Result<WebResponse, Error>>;
/// Resources scope. /// Resources scope.
/// ///
@ -89,8 +89,8 @@ impl<T> Scope<T>
where where
T: ServiceFactory< T: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
@ -283,8 +283,8 @@ where
F: IntoServiceFactory<U>, F: IntoServiceFactory<U>,
U: ServiceFactory< U: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
> + 'static, > + 'static,
U::InitError: fmt::Debug, U::InitError: fmt::Debug,
@ -305,7 +305,7 @@ where
/// necessary, across all requests managed by the *Scope*. Scope-level /// necessary, across all requests managed by the *Scope*. Scope-level
/// middleware is more limited in what it can modify, relative to Route or /// middleware is more limited in what it can modify, relative to Route or
/// Application level middleware, in that Scope-level middleware can not modify /// Application level middleware, in that Scope-level middleware can not modify
/// ServiceResponse. /// WebResponse.
/// ///
/// Use middleware when you need to read or modify *every* request in some way. /// Use middleware when you need to read or modify *every* request in some way.
pub fn wrap<M>( pub fn wrap<M>(
@ -314,8 +314,8 @@ where
) -> Scope< ) -> Scope<
impl ServiceFactory< impl ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
@ -323,8 +323,8 @@ where
where where
M: Transform< M: Transform<
T::Service, T::Service,
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
@ -346,7 +346,7 @@ where
/// request as necessary, across all requests managed by the *Scope*. /// request as necessary, across all requests managed by the *Scope*.
/// Scope-level middleware is more limited in what it can modify, relative /// Scope-level middleware is more limited in what it can modify, relative
/// to Route or Application level middleware, in that Scope-level middleware /// to Route or Application level middleware, in that Scope-level middleware
/// can not modify ServiceResponse. /// can not modify WebResponse.
/// ///
/// ```rust /// ```rust
/// use ntex::service::Service; /// use ntex::service::Service;
@ -379,15 +379,15 @@ where
) -> Scope< ) -> Scope<
impl ServiceFactory< impl ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
>, >,
> >
where where
F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone, F: FnMut(WebRequest, &mut T::Service) -> R + Clone,
R: Future<Output = Result<ServiceResponse, Error>>, R: Future<Output = Result<WebResponse, Error>>,
{ {
Scope { Scope {
endpoint: apply_fn_factory(self.endpoint, mw), endpoint: apply_fn_factory(self.endpoint, mw),
@ -406,8 +406,8 @@ impl<T> HttpServiceFactory for Scope<T>
where where
T: ServiceFactory< T: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
> + 'static, > + 'static,
@ -477,8 +477,8 @@ pub struct ScopeFactory {
impl ServiceFactory for ScopeFactory { impl ServiceFactory for ScopeFactory {
type Config = (); type Config = ();
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = Error; type Error = Error;
type InitError = (); type InitError = ();
type Service = ScopeService; type Service = ScopeService;
@ -593,12 +593,12 @@ pub struct ScopeService {
data: Option<Rc<Extensions>>, data: Option<Rc<Extensions>>,
router: Router<HttpService, Vec<Box<dyn Guard>>>, router: Router<HttpService, Vec<Box<dyn Guard>>>,
default: Option<HttpService>, default: Option<HttpService>,
_ready: Option<(ServiceRequest, ResourceInfo)>, _ready: Option<(WebRequest, ResourceInfo)>,
} }
impl Service for ScopeService { impl Service for ScopeService {
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = Error; type Error = Error;
type Future = Either<BoxedResponse, Ready<Result<Self::Response, Self::Error>>>; type Future = Either<BoxedResponse, Ready<Result<Self::Response, Self::Error>>>;
@ -606,7 +606,7 @@ impl Service for ScopeService {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, mut req: ServiceRequest) -> Self::Future { fn call(&mut self, mut req: WebRequest) -> Self::Future {
let res = self.router.recognize_mut_checked(&mut req, |req, guards| { let res = self.router.recognize_mut_checked(&mut req, |req, guards| {
if let Some(ref guards) = guards { if let Some(ref guards) = guards {
for f in guards { for f in guards {
@ -627,7 +627,7 @@ impl Service for ScopeService {
Either::Left(default.call(req)) Either::Left(default.call(req))
} else { } else {
let req = req.into_parts().0; let req = req.into_parts().0;
Either::Right(ok(ServiceResponse::new(req, Response::NotFound().finish()))) Either::Right(ok(WebResponse::new(req, Response::NotFound().finish())))
} }
} }
} }
@ -645,8 +645,8 @@ impl ScopeEndpoint {
impl ServiceFactory for ScopeEndpoint { impl ServiceFactory for ScopeEndpoint {
type Config = (); type Config = ();
type Request = ServiceRequest; type Request = WebRequest;
type Response = ServiceResponse; type Response = WebResponse;
type Error = Error; type Error = Error;
type InitError = (); type InitError = ();
type Service = ScopeService; type Service = ScopeService;
@ -667,7 +667,7 @@ mod tests {
use crate::http::{Method, StatusCode}; use crate::http::{Method, StatusCode};
use crate::service::Service; use crate::service::Service;
use crate::web::middleware::DefaultHeaders; use crate::web::middleware::DefaultHeaders;
use crate::web::service::ServiceRequest; use crate::web::service::WebRequest;
use crate::web::test::{call_service, init_service, read_body, TestRequest}; use crate::web::test::{call_service, init_service, read_body, TestRequest};
use crate::web::{self, guard, App, HttpRequest, HttpResponse}; use crate::web::{self, guard, App, HttpRequest, HttpResponse};
@ -993,7 +993,7 @@ mod tests {
App::new().service( App::new().service(
web::scope("/app") web::scope("/app")
.service(web::resource("/path1").to(|| HttpResponse::Ok())) .service(web::resource("/path1").to(|| HttpResponse::Ok()))
.default_service(|r: ServiceRequest| { .default_service(|r: WebRequest| {
ok(r.into_response(HttpResponse::BadRequest())) ok(r.into_response(HttpResponse::BadRequest()))
}), }),
), ),
@ -1017,7 +1017,7 @@ mod tests {
web::resource("").to(|| HttpResponse::BadRequest()), web::resource("").to(|| HttpResponse::BadRequest()),
)) ))
.service(web::scope("/app2")) .service(web::scope("/app2"))
.default_service(|r: ServiceRequest| { .default_service(|r: WebRequest| {
ok(r.into_response(HttpResponse::MethodNotAllowed())) ok(r.into_response(HttpResponse::MethodNotAllowed()))
}), }),
) )

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

@ -23,11 +23,11 @@ pub trait HttpServiceFactory {
fn register(self, config: &mut AppService); fn register(self, config: &mut AppService);
} }
pub(crate) trait AppServiceFactory { pub(super) trait AppServiceFactory {
fn register(&mut self, config: &mut AppService); fn register(&mut self, config: &mut AppService);
} }
pub(crate) struct ServiceFactoryWrapper<T> { pub(super) struct ServiceFactoryWrapper<T> {
factory: Option<T>, factory: Option<T>,
} }
@ -52,13 +52,13 @@ where
/// An service http request /// An service http request
/// ///
/// ServiceRequest allows mutable access to request's internal structures /// WebRequest allows mutable access to request's internal structures
pub struct ServiceRequest(HttpRequest); pub struct WebRequest(HttpRequest);
impl ServiceRequest { impl WebRequest {
/// Construct service request /// Construct web request
pub(crate) fn new(req: HttpRequest) -> Self { pub(crate) fn new(req: HttpRequest) -> Self {
ServiceRequest(req) WebRequest(req)
} }
/// Deconstruct request into parts /// Deconstruct request into parts
@ -69,14 +69,14 @@ impl ServiceRequest {
/// Construct request from parts. /// Construct request from parts.
/// ///
/// `ServiceRequest` can be re-constructed only if `req` hasnt been cloned. /// `WebRequest` can be re-constructed only if `req` hasnt been cloned.
pub fn from_parts( pub fn from_parts(
mut req: HttpRequest, mut req: HttpRequest,
pl: Payload, pl: Payload,
) -> Result<Self, (HttpRequest, Payload)> { ) -> Result<Self, (HttpRequest, Payload)> {
if Rc::strong_count(&req.0) == 1 && Rc::weak_count(&req.0) == 0 { if Rc::strong_count(&req.0) == 1 && Rc::weak_count(&req.0) == 0 {
Rc::get_mut(&mut req.0).unwrap().payload = pl; Rc::get_mut(&mut req.0).unwrap().payload = pl;
Ok(ServiceRequest(req)) Ok(WebRequest(req))
} else { } else {
Err((req, pl)) Err((req, pl))
} }
@ -84,28 +84,28 @@ impl ServiceRequest {
/// Construct request from request. /// Construct request from request.
/// ///
/// `HttpRequest` implements `Clone` trait via `Rc` type. `ServiceRequest` /// `HttpRequest` implements `Clone` trait via `Rc` type. `WebRequest`
/// can be re-constructed only if rc's strong pointers count eq 1 and /// can be re-constructed only if rc's strong pointers count eq 1 and
/// weak pointers count is 0. /// weak pointers count is 0.
pub fn from_request(req: HttpRequest) -> Result<Self, HttpRequest> { pub fn from_request(req: HttpRequest) -> Result<Self, HttpRequest> {
if Rc::strong_count(&req.0) == 1 && Rc::weak_count(&req.0) == 0 { if Rc::strong_count(&req.0) == 1 && Rc::weak_count(&req.0) == 0 {
Ok(ServiceRequest(req)) Ok(WebRequest(req))
} else { } else {
Err(req) Err(req)
} }
} }
/// Create service response /// Create web response
#[inline] #[inline]
pub fn into_response<B, R: Into<Response<B>>>(self, res: R) -> ServiceResponse<B> { pub fn into_response<B, R: Into<Response<B>>>(self, res: R) -> WebResponse<B> {
ServiceResponse::new(self.0, res.into()) WebResponse::new(self.0, res.into())
} }
/// Create service response for error /// Create web response for error
#[inline] #[inline]
pub fn error_response<B, E: Into<Error>>(self, err: E) -> ServiceResponse<B> { pub fn error_response<B, E: Into<Error>>(self, err: E) -> WebResponse<B> {
let res: Response = err.into().into(); let res: Response = err.into().into();
ServiceResponse::new(self.0, res.into_body()) WebResponse::new(self.0, res.into_body())
} }
/// This method returns reference to the request head /// This method returns reference to the request head
@ -236,13 +236,13 @@ impl ServiceRequest {
} }
} }
impl Resource<Url> for ServiceRequest { impl Resource<Url> for WebRequest {
fn resource_path(&mut self) -> &mut Path<Url> { fn resource_path(&mut self) -> &mut Path<Url> {
self.match_info_mut() self.match_info_mut()
} }
} }
impl HttpMessage for ServiceRequest { impl HttpMessage for WebRequest {
type Stream = PayloadStream; type Stream = PayloadStream;
#[inline] #[inline]
@ -269,11 +269,11 @@ impl HttpMessage for ServiceRequest {
} }
} }
impl fmt::Debug for ServiceRequest { impl fmt::Debug for WebRequest {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
writeln!( writeln!(
f, f,
"\nServiceRequest {:?} {}:{}", "\nWebRequest {:?} {}:{}",
self.head().version, self.head().version,
self.head().method, self.head().method,
self.path() self.path()
@ -292,37 +292,37 @@ impl fmt::Debug for ServiceRequest {
} }
} }
pub struct ServiceResponse<B = Body> { pub struct WebResponse<B = Body> {
request: HttpRequest, request: HttpRequest,
response: Response<B>, response: Response<B>,
} }
impl<B> ServiceResponse<B> { impl<B> WebResponse<B> {
/// Create service response instance /// Create web response instance
pub fn new(request: HttpRequest, response: Response<B>) -> Self { pub fn new(request: HttpRequest, response: Response<B>) -> Self {
ServiceResponse { request, response } WebResponse { request, response }
} }
/// Create service response from the error /// Create web response from the error
pub fn from_err<E: Into<Error>>(err: E, request: HttpRequest) -> Self { pub fn from_err<E: Into<Error>>(err: E, request: HttpRequest) -> Self {
let e: Error = err.into(); let e: Error = err.into();
let res: Response = e.into(); let res: Response = e.into();
ServiceResponse { WebResponse {
request, request,
response: res.into_body(), response: res.into_body(),
} }
} }
/// Create service response for error /// Create web response for error
#[inline] #[inline]
pub fn error_response<E: Into<Error>>(self, err: E) -> Self { pub fn error_response<E: Into<Error>>(self, err: E) -> Self {
Self::from_err(err, self.request) Self::from_err(err, self.request)
} }
/// Create service response /// Create web response
#[inline] #[inline]
pub fn into_response<B1>(self, response: Response<B1>) -> ServiceResponse<B1> { pub fn into_response<B1>(self, response: Response<B1>) -> WebResponse<B1> {
ServiceResponse::new(self.request, response) WebResponse::new(self.request, response)
} }
/// Get reference to original request /// Get reference to original request
@ -371,7 +371,7 @@ impl<B> ServiceResponse<B> {
Ok(_) => self, Ok(_) => self,
Err(err) => { Err(err) => {
let res: Response = err.into().into(); let res: Response = err.into().into();
ServiceResponse::new(self.request, res.into_body()) WebResponse::new(self.request, res.into_body())
} }
} }
} }
@ -382,32 +382,32 @@ impl<B> ServiceResponse<B> {
} }
} }
impl<B> ServiceResponse<B> { impl<B> WebResponse<B> {
/// Set a new body /// Set a new body
pub fn map_body<F, B2>(self, f: F) -> ServiceResponse<B2> pub fn map_body<F, B2>(self, f: F) -> WebResponse<B2>
where where
F: FnOnce(&mut ResponseHead, ResponseBody<B>) -> ResponseBody<B2>, F: FnOnce(&mut ResponseHead, ResponseBody<B>) -> ResponseBody<B2>,
{ {
let response = self.response.map_body(f); let response = self.response.map_body(f);
ServiceResponse { WebResponse {
response, response,
request: self.request, request: self.request,
} }
} }
} }
impl<B> Into<Response<B>> for ServiceResponse<B> { impl<B> Into<Response<B>> for WebResponse<B> {
fn into(self) -> Response<B> { fn into(self) -> Response<B> {
self.response self.response
} }
} }
impl<B: MessageBody> fmt::Debug for ServiceResponse<B> { impl<B: MessageBody> fmt::Debug for WebResponse<B> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let res = writeln!( let res = writeln!(
f, f,
"\nServiceResponse {:?} {}{}", "\nWebResponse {:?} {}{}",
self.response.head().version, self.response.head().version,
self.response.head().status, self.response.head().status,
self.response.head().reason.unwrap_or(""), self.response.head().reason.unwrap_or(""),
@ -451,7 +451,7 @@ impl WebService {
/// use ntex::http; /// use ntex::http;
/// use ntex::web::{self, guard, dev, App, HttpResponse}; /// use ntex::web::{self, guard, dev, App, HttpResponse};
/// ///
/// async fn index(req: dev::ServiceRequest) -> Result<dev::ServiceResponse, http::Error> { /// async fn index(req: dev::WebRequest) -> Result<dev::WebResponse, http::Error> {
/// Ok(req.into_response(HttpResponse::Ok().finish())) /// Ok(req.into_response(HttpResponse::Ok().finish()))
/// } /// }
/// ///
@ -475,8 +475,8 @@ impl WebService {
F: IntoServiceFactory<T>, F: IntoServiceFactory<T>,
T: ServiceFactory< T: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
> + 'static, > + 'static,
@ -501,8 +501,8 @@ impl<T> HttpServiceFactory for WebServiceImpl<T>
where where
T: ServiceFactory< T: ServiceFactory<
Config = (), Config = (),
Request = ServiceRequest, Request = WebRequest,
Response = ServiceResponse, Response = WebResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
> + 'static, > + 'static,
@ -540,28 +540,28 @@ mod tests {
fn test_service_request() { fn test_service_request() {
let req = TestRequest::default().to_srv_request(); let req = TestRequest::default().to_srv_request();
let (r, pl) = req.into_parts(); let (r, pl) = req.into_parts();
assert!(ServiceRequest::from_parts(r, pl).is_ok()); assert!(WebRequest::from_parts(r, pl).is_ok());
let req = TestRequest::default().to_srv_request(); let req = TestRequest::default().to_srv_request();
let (r, pl) = req.into_parts(); let (r, pl) = req.into_parts();
let _r2 = r.clone(); let _r2 = r.clone();
assert!(ServiceRequest::from_parts(r, pl).is_err()); assert!(WebRequest::from_parts(r, pl).is_err());
let req = TestRequest::default().to_srv_request(); let req = TestRequest::default().to_srv_request();
let (r, _pl) = req.into_parts(); let (r, _pl) = req.into_parts();
assert!(ServiceRequest::from_request(r).is_ok()); assert!(WebRequest::from_request(r).is_ok());
let req = TestRequest::default().to_srv_request(); let req = TestRequest::default().to_srv_request();
let (r, _pl) = req.into_parts(); let (r, _pl) = req.into_parts();
let _r2 = r.clone(); let _r2 = r.clone();
assert!(ServiceRequest::from_request(r).is_err()); assert!(WebRequest::from_request(r).is_err());
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_service() { async fn test_service() {
let mut srv = init_service( let mut srv = init_service(
App::new().service(web::service("/test").name("test").finish( App::new().service(web::service("/test").name("test").finish(
|req: ServiceRequest| ok(req.into_response(HttpResponse::Ok().finish())), |req: WebRequest| ok(req.into_response(HttpResponse::Ok().finish())),
)), )),
) )
.await; .await;
@ -571,7 +571,7 @@ mod tests {
let mut srv = init_service( let mut srv = init_service(
App::new().service(web::service("/test").guard(guard::Get()).finish( App::new().service(web::service("/test").guard(guard::Get()).finish(
|req: ServiceRequest| ok(req.into_response(HttpResponse::Ok().finish())), |req: WebRequest| ok(req.into_response(HttpResponse::Ok().finish())),
)), )),
) )
.await; .await;
@ -589,7 +589,7 @@ mod tests {
.header("x-test", "111") .header("x-test", "111")
.to_srv_request(); .to_srv_request();
let s = format!("{:?}", req); let s = format!("{:?}", req);
assert!(s.contains("ServiceRequest")); assert!(s.contains("WebRequest"));
assert!(s.contains("test=1")); assert!(s.contains("test=1"));
assert!(s.contains("x-test")); assert!(s.contains("x-test"));
@ -599,7 +599,7 @@ mod tests {
.to_srv_response(res); .to_srv_response(res);
let s = format!("{:?}", res); let s = format!("{:?}", res);
assert!(s.contains("ServiceResponse")); assert!(s.contains("WebResponse"));
assert!(s.contains("x-test")); assert!(s.contains("x-test"));
} }
} }

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

@ -34,22 +34,20 @@ use crate::{map_config, IntoService, IntoServiceFactory, Service, ServiceFactory
use crate::web::config::AppConfig; use crate::web::config::AppConfig;
use crate::web::request::HttpRequestPool; use crate::web::request::HttpRequestPool;
use crate::web::rmap::ResourceMap; use crate::web::rmap::ResourceMap;
use crate::web::service::{ServiceRequest, ServiceResponse}; use crate::web::service::{WebRequest, WebResponse};
use crate::web::{HttpRequest, HttpResponse}; use crate::web::{HttpRequest, HttpResponse};
/// Create service that always responds with `HttpResponse::Ok()` /// Create service that always responds with `HttpResponse::Ok()`
pub fn ok_service( pub fn ok_service(
) -> impl Service<Request = ServiceRequest, Response = ServiceResponse<Body>, Error = Error> ) -> impl Service<Request = WebRequest, Response = WebResponse<Body>, Error = Error> {
{
default_service(StatusCode::OK) default_service(StatusCode::OK)
} }
/// Create service that responds with response with specified status code /// Create service that responds with response with specified status code
pub fn default_service( pub fn default_service(
status_code: StatusCode, status_code: StatusCode,
) -> impl Service<Request = ServiceRequest, Response = ServiceResponse<Body>, Error = Error> ) -> impl Service<Request = WebRequest, Response = WebResponse<Body>, Error = Error> {
{ (move |req: WebRequest| {
(move |req: ServiceRequest| {
ok(req.into_response(HttpResponse::build(status_code).finish())) ok(req.into_response(HttpResponse::build(status_code).finish()))
}) })
.into_service() .into_service()
@ -80,13 +78,13 @@ pub fn default_service(
/// ``` /// ```
pub async fn init_service<R, S, B, E>( pub async fn init_service<R, S, B, E>(
app: R, app: R,
) -> impl Service<Request = Request, Response = ServiceResponse<B>, Error = E> ) -> impl Service<Request = Request, Response = WebResponse<B>, Error = E>
where where
R: IntoServiceFactory<S>, R: IntoServiceFactory<S>,
S: ServiceFactory< S: ServiceFactory<
Config = AppConfig, Config = AppConfig,
Request = Request, Request = Request,
Response = ServiceResponse<B>, Response = WebResponse<B>,
Error = E, Error = E,
>, >,
S::InitError: std::fmt::Debug, S::InitError: std::fmt::Debug,
@ -120,7 +118,7 @@ where
/// ``` /// ```
pub async fn call_service<S, R, B, E>(app: &mut S, req: R) -> S::Response pub async fn call_service<S, R, B, E>(app: &mut S, req: R) -> S::Response
where where
S: Service<Request = R, Response = ServiceResponse<B>, Error = E>, S: Service<Request = R, Response = WebResponse<B>, Error = E>,
E: std::fmt::Debug, E: std::fmt::Debug,
{ {
app.call(req).await.unwrap() app.call(req).await.unwrap()
@ -154,7 +152,7 @@ where
/// ``` /// ```
pub async fn read_response<S, B>(app: &mut S, req: Request) -> Bytes pub async fn read_response<S, B>(app: &mut S, req: Request) -> Bytes
where where
S: Service<Request = Request, Response = ServiceResponse<B>, Error = Error>, S: Service<Request = Request, Response = WebResponse<B>, Error = Error>,
B: MessageBody, B: MessageBody,
{ {
let mut resp = app let mut resp = app
@ -170,7 +168,7 @@ where
bytes.freeze() bytes.freeze()
} }
/// Helper function that returns a response body of a ServiceResponse. /// Helper function that returns a response body of a WebResponse.
/// ///
/// ```rust /// ```rust
/// use bytes::Bytes; /// use bytes::Bytes;
@ -197,7 +195,7 @@ where
/// assert_eq!(result, Bytes::from_static(b"welcome!")); /// assert_eq!(result, Bytes::from_static(b"welcome!"));
/// } /// }
/// ``` /// ```
pub async fn read_body<B>(mut res: ServiceResponse<B>) -> Bytes pub async fn read_body<B>(mut res: WebResponse<B>) -> Bytes
where where
B: MessageBody, B: MessageBody,
{ {
@ -257,7 +255,7 @@ where
/// ``` /// ```
pub async fn read_response_json<S, B, T>(app: &mut S, req: Request) -> T pub async fn read_response_json<S, B, T>(app: &mut S, req: Request) -> T
where where
S: Service<Request = Request, Response = ServiceResponse<B>, Error = Error>, S: Service<Request = Request, Response = WebResponse<B>, Error = Error>,
B: MessageBody, B: MessageBody,
T: DeserializeOwned, T: DeserializeOwned,
{ {
@ -272,8 +270,8 @@ where
/// For unit testing, actix provides a request builder type and a simple handler runner. TestRequest implements a builder-like pattern. /// For unit testing, actix provides a request builder type and a simple handler runner. TestRequest implements a builder-like pattern.
/// You can generate various types of request via TestRequest's methods: /// You can generate various types of request via TestRequest's methods:
/// * `TestRequest::to_request` creates `actix_http::Request` instance. /// * `TestRequest::to_request` creates `actix_http::Request` instance.
/// * `TestRequest::to_srv_request` creates `ServiceRequest` instance, which is used for testing middlewares and chain adapters. /// * `TestRequest::to_srv_request` creates `WebRequest` instance, which is used for testing middlewares and chain adapters.
/// * `TestRequest::to_srv_response` creates `ServiceResponse` instance. /// * `TestRequest::to_srv_response` creates `WebResponse` instance.
/// * `TestRequest::to_http_request` creates `HttpRequest` instance, which is used for testing handlers. /// * `TestRequest::to_http_request` creates `HttpRequest` instance, which is used for testing handlers.
/// ///
/// ```rust /// ```rust
@ -461,13 +459,13 @@ impl TestRequest {
req req
} }
/// Complete request creation and generate `ServiceRequest` instance /// Complete request creation and generate `WebRequest` instance
pub fn to_srv_request(mut self) -> ServiceRequest { pub fn to_srv_request(mut self) -> WebRequest {
let (mut head, payload) = self.req.finish().into_parts(); let (mut head, payload) = self.req.finish().into_parts();
head.peer_addr = self.peer_addr; head.peer_addr = self.peer_addr;
self.path.get_mut().update(&head.uri); self.path.get_mut().update(&head.uri);
ServiceRequest::new(HttpRequest::new( WebRequest::new(HttpRequest::new(
self.path, self.path,
head, head,
payload, payload,
@ -478,8 +476,8 @@ impl TestRequest {
)) ))
} }
/// Complete request creation and generate `ServiceResponse` instance /// Complete request creation and generate `WebResponse` instance
pub fn to_srv_response<B>(self, res: HttpResponse<B>) -> ServiceResponse<B> { pub fn to_srv_response<B>(self, res: HttpResponse<B>) -> WebResponse<B> {
self.to_srv_request().into_response(res) self.to_srv_request().into_response(res)
} }

1
ntex/src/web/types/json.rs
View file

@ -288,7 +288,6 @@ impl Default for JsonConfig {
} }
/// Request's payload json parser, it resolves to a deserialized `T` value. /// Request's payload json parser, it resolves to a deserialized `T` value.
/// This future could be used with `ServiceRequest` and `ServiceFromRequest`.
/// ///
/// Returns error: /// Returns error:
/// ///

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

@ -237,7 +237,7 @@ where
/// use ntex::http::Error; /// use ntex::http::Error;
/// use ntex::web::{self, dev, guard, App, HttpResponse}; /// use ntex::web::{self, dev, guard, App, HttpResponse};
/// ///
/// async fn my_service(req: dev::ServiceRequest) -> Result<dev::ServiceResponse, Error> { /// async fn my_service(req: dev::WebRequest) -> Result<dev::WebResponse, Error> {
/// Ok(req.into_response(HttpResponse::Ok().finish())) /// Ok(req.into_response(HttpResponse::Ok().finish()))
/// } /// }
/// ///