mirrors/ntex
1
0
Fork 0
mirror of https://github.com/ntex-rs/ntex.git synced 2025-04-03 21:07: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::route::Route;
use super::service::{
AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, ServiceRequest,
ServiceResponse,
AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, WebRequest,
WebResponse,
};
type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
type HttpNewService = BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
type FnDataFactory =
Box<dyn Fn() -> LocalBoxFuture<'static, Result<Box<dyn DataFactory>, ()>>>;
@ -65,8 +65,8 @@ where
B: MessageBody,
T: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse<B>,
Request = WebRequest,
Response = WebResponse<B>,
Error = Error,
InitError = (),
>,
@ -270,8 +270,8 @@ where
F: IntoServiceFactory<U>,
U: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
> + 'static,
U::InitError: fmt::Debug,
@ -353,8 +353,8 @@ where
) -> App<
impl ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse<B1>,
Request = WebRequest,
Response = WebResponse<B1>,
Error = Error,
InitError = (),
>,
@ -363,8 +363,8 @@ where
where
M: Transform<
T::Service,
Request = ServiceRequest,
Response = ServiceResponse<B1>,
Request = WebRequest,
Response = WebResponse<B1>,
Error = Error,
InitError = (),
>,
@ -420,8 +420,8 @@ where
) -> App<
impl ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse<B1>,
Request = WebRequest,
Response = WebResponse<B1>,
Error = Error,
InitError = (),
>,
@ -429,8 +429,8 @@ where
>
where
B1: MessageBody,
F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone,
R: Future<Output = Result<ServiceResponse<B1>, Error>>,
F: FnMut(WebRequest, &mut T::Service) -> R + Clone,
R: Future<Output = Result<WebResponse<B1>, Error>>,
{
App {
endpoint: apply_fn_factory(self.endpoint, mw),
@ -451,8 +451,8 @@ where
B: MessageBody,
T: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse<B>,
Request = WebRequest,
Response = WebResponse<B>,
Error = Error,
InitError = (),
>,
@ -480,7 +480,7 @@ mod tests {
use crate::http::header::{self, HeaderValue};
use crate::http::{Method, StatusCode};
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::{self, HttpRequest, HttpResponse};
use crate::Service;
@ -504,12 +504,12 @@ mod tests {
.service(web::resource("/test").to(|| HttpResponse::Ok()))
.service(
web::resource("/test2")
.default_service(|r: ServiceRequest| {
.default_service(|r: WebRequest| {
ok(r.into_response(HttpResponse::Created()))
})
.route(web::get().to(|| HttpResponse::Ok())),
)
.default_service(|r: ServiceRequest| {
.default_service(|r: WebRequest| {
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::request::{HttpRequest, HttpRequestPool};
use super::rmap::ResourceMap;
use super::service::{AppServiceFactory, ServiceRequest, ServiceResponse};
use super::service::{AppServiceFactory, WebRequest, WebResponse};
type Guards = Vec<Box<dyn Guard>>;
type HttpService = BoxService<ServiceRequest, ServiceResponse, Error>;
type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
type BoxResponse = LocalBoxFuture<'static, Result<ServiceResponse, Error>>;
type HttpService = BoxService<WebRequest, WebResponse, Error>;
type HttpNewService = BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
type BoxResponse = LocalBoxFuture<'static, Result<WebResponse, Error>>;
type FnDataFactory =
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.
pub struct AppInit<T, B>
where
T: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse<B>,
Request = WebRequest,
Response = WebResponse<B>,
Error = Error,
InitError = (),
>,
{
pub(crate) endpoint: T,
pub(crate) extensions: RefCell<Option<Extensions>>,
pub(crate) data: Rc<Vec<Box<dyn DataFactory>>>,
pub(crate) data_factories: Rc<Vec<FnDataFactory>>,
pub(crate) services: Rc<RefCell<Vec<Box<dyn AppServiceFactory>>>>,
pub(crate) default: Option<Rc<HttpNewService>>,
pub(crate) factory_ref: Rc<RefCell<Option<AppRoutingFactory>>>,
pub(crate) external: RefCell<Vec<ResourceDef>>,
pub(super) endpoint: T,
pub(super) extensions: RefCell<Option<Extensions>>,
pub(super) data: Rc<Vec<Box<dyn DataFactory>>>,
pub(super) data_factories: Rc<Vec<FnDataFactory>>,
pub(super) services: Rc<RefCell<Vec<Box<dyn AppServiceFactory>>>>,
pub(super) default: Option<Rc<HttpNewService>>,
pub(super) factory_ref: Rc<RefCell<Option<AppRoutingFactory>>>,
pub(super) external: RefCell<Vec<ResourceDef>>,
}
impl<T, B> ServiceFactory for AppInit<T, B>
where
T: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse<B>,
Request = WebRequest,
Response = WebResponse<B>,
Error = Error,
InitError = (),
>,
{
type Config = AppConfig;
type Request = Request;
type Response = ServiceResponse<B>;
type Response = WebResponse<B>;
type Error = T::Error;
type InitError = T::InitError;
type Service = AppInitService<T::Service, B>;
@ -69,7 +69,7 @@ where
fn new_service(&self, config: AppConfig) -> Self::Future {
// update resource default service
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()))
})))
});
@ -149,8 +149,8 @@ impl<T, B> Future for AppInitResult<T, B>
where
T: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse<B>,
Request = WebRequest,
Response = WebResponse<B>,
Error = Error,
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>
where
T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
T: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
{
service: T,
rmap: Rc<ResourceMap>,
@ -216,10 +216,10 @@ where
impl<T, B> Service for AppInitService<T, B>
where
T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
T: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
{
type Request = Request;
type Response = ServiceResponse<B>;
type Response = WebResponse<B>;
type Error = T::Error;
type Future = T::Future;
@ -249,13 +249,13 @@ where
self.pool,
)
};
self.service.call(ServiceRequest::new(req))
self.service.call(WebRequest::new(req))
}
}
impl<T, B> Drop for AppInitService<T, B>
where
T: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
T: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
{
fn drop(&mut self) {
self.pool.clear();
@ -269,8 +269,8 @@ pub struct AppRoutingFactory {
impl ServiceFactory for AppRoutingFactory {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse;
type Request = WebRequest;
type Response = WebResponse;
type Error = Error;
type InitError = ();
type Service = AppRouting;
@ -374,13 +374,13 @@ impl Future for AppRoutingFactoryResponse {
pub struct AppRouting {
router: Router<HttpService, Guards>,
ready: Option<(ServiceRequest, ResourceInfo)>,
ready: Option<(WebRequest, ResourceInfo)>,
default: Option<HttpService>,
}
impl Service for AppRouting {
type Request = ServiceRequest;
type Response = ServiceResponse;
type Request = WebRequest;
type Response = WebResponse;
type Error = Error;
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| {
if let Some(ref guards) = guards {
for f in guards {
@ -410,7 +410,7 @@ impl Service for AppRouting {
default.call(req)
} else {
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 {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse;
type Request = WebRequest;
type Response = WebResponse;
type Error = Error;
type InitError = ();
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::route::Route;
use super::service::{
AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, ServiceRequest,
ServiceResponse,
AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, WebRequest,
WebResponse,
};
type Guards = Vec<Box<dyn Guard>>;
type HttpNewService =
boxed::BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
type HttpNewService = boxed::BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
/// Application configuration
pub struct AppService {
@ -108,8 +107,8 @@ impl AppService {
F: IntoServiceFactory<S>,
S: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
InitError = (),
> + 'static,
@ -174,9 +173,9 @@ impl Default for AppConfig {
/// to set of external methods. This could help with
/// modularization of big application configuration.
pub struct ServiceConfig {
pub(crate) services: Vec<Box<dyn AppServiceFactory>>,
pub(crate) data: Vec<Box<dyn DataFactory>>,
pub(crate) external: Vec<ResourceDef>,
pub(super) services: Vec<Box<dyn AppServiceFactory>>,
pub(super) data: Vec<Box<dyn DataFactory>>,
pub(super) external: Vec<ResourceDef>,
}
impl ServiceConfig {

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

@ -14,7 +14,7 @@ use crate::{Service, ServiceFactory};
use super::extract::FromRequest;
use super::request::HttpRequest;
use super::responder::Responder;
use super::service::{ServiceRequest, ServiceResponse};
use super::service::{WebRequest, WebResponse};
/// Async handler converter factory
pub trait Factory<T, R, O>: Clone + 'static
@ -82,16 +82,16 @@ where
O: Responder,
{
type Request = (T, HttpRequest);
type Response = ServiceResponse;
type Response = WebResponse;
type Error = Infallible;
type Future = HandlerServiceResponse<R, O>;
type Future = HandlerWebResponse<R, O>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call(&mut self, (param, req): (T, HttpRequest)) -> Self::Future {
HandlerServiceResponse {
HandlerWebResponse {
fut: self.hnd.call(param),
fut2: None,
req: Some(req),
@ -101,7 +101,7 @@ where
#[doc(hidden)]
#[pin_project]
pub struct HandlerServiceResponse<T, R>
pub struct HandlerWebResponse<T, R>
where
T: Future<Output = R>,
R: Responder,
@ -113,12 +113,12 @@ where
req: Option<HttpRequest>,
}
impl<T, R> Future for HandlerServiceResponse<T, R>
impl<T, R> Future for HandlerWebResponse<T, R>
where
T: Future<Output = R>,
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> {
let this = self.as_mut().project();
@ -126,12 +126,12 @@ where
if let Some(fut) = this.fut2.as_pin_mut() {
return match fut.poll(cx) {
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::Ready(Err(e)) => {
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>
where
S: Service<
Request = (T, HttpRequest),
Response = ServiceResponse,
Error = Infallible,
> + Clone,
S: Service<Request = (T, HttpRequest), Response = WebResponse, Error = Infallible>
+ Clone,
{
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse;
type Error = (Error, ServiceRequest);
type Request = WebRequest;
type Response = WebResponse;
type Error = (Error, WebRequest);
type InitError = ();
type Service = ExtractService<T, S>;
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>
where
S: Service<
Request = (T, HttpRequest),
Response = ServiceResponse,
Error = Infallible,
> + Clone,
S: Service<Request = (T, HttpRequest), Response = WebResponse, Error = Infallible>
+ Clone,
{
type Request = ServiceRequest;
type Response = ServiceResponse;
type Error = (Error, ServiceRequest);
type Request = WebRequest;
type Response = WebResponse;
type Error = (Error, WebRequest);
type Future = ExtractResponse<T, S>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
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 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>
where
S: Service<
Request = (T, HttpRequest),
Response = ServiceResponse,
Error = Infallible,
>,
S: Service<Request = (T, HttpRequest), Response = WebResponse, 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> {
let this = self.as_mut().project();
@ -250,7 +240,7 @@ where
match ready!(this.fut.poll(cx)) {
Err(e) => {
let req = ServiceRequest::new(this.req.clone());
let req = WebRequest::new(this.req.clone());
Poll::Ready(Err((e.into(), req)))
}
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::web::dev::BodyEncoding;
use crate::web::service::{ServiceRequest, ServiceResponse};
use crate::web::service::{WebRequest, WebResponse};
#[derive(Debug, Clone)]
/// `Middleware` for compressing response body.
@ -55,10 +55,10 @@ impl Default for Compress {
impl<S, B> Transform<S> for Compress
where
B: MessageBody,
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
{
type Request = ServiceRequest;
type Response = ServiceResponse<Encoder<B>>;
type Request = WebRequest;
type Response = WebResponse<Encoder<B>>;
type Error = Error;
type InitError = ();
type Transform = CompressMiddleware<S>;
@ -80,10 +80,10 @@ pub struct CompressMiddleware<S> {
impl<S, B> Service for CompressMiddleware<S>
where
B: MessageBody,
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
{
type Request = ServiceRequest;
type Response = ServiceResponse<Encoder<B>>;
type Request = WebRequest;
type Response = WebResponse<Encoder<B>>;
type Error = Error;
type Future = CompressResponse<S, B>;
@ -91,7 +91,7 @@ where
self.service.poll_ready(cx)
}
fn call(&mut self, req: ServiceRequest) -> Self::Future {
fn call(&mut self, req: WebRequest) -> Self::Future {
// negotiate content-encoding
let encoding = if let Some(val) = req.headers().get(&ACCEPT_ENCODING) {
if let Ok(enc) = val.to_str() {
@ -127,9 +127,9 @@ where
impl<S, B> Future for CompressResponse<S, B>
where
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> {
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 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::http::header::{self, HeaderName, HeaderValue};
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
where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
S::Future: 'static,
B: 'static,
{
type Request = ServiceRequest;
type Response = ServiceResponse<B>;
type Request = WebRequest;
type Response = WebResponse<B>;
type Error = Error;
type InitError = ();
type Transform = CorsMiddleware<S>;
@ -678,12 +678,12 @@ impl Inner {
impl<S, B> Service for CorsMiddleware<S>
where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
S::Future: 'static,
B: 'static,
{
type Request = ServiceRequest;
type Response = ServiceResponse<B>;
type Request = WebRequest;
type Response = WebResponse<B>;
type Error = Error;
type Future = Either<
Ready<Result<Self::Response, Error>>,
@ -694,7 +694,7 @@ where
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 let Err(e) = self
.inner
@ -1083,7 +1083,7 @@ mod tests {
.expose_headers(exposed_headers.clone())
.allowed_header(header::CONTENT_TYPE)
.finish()
.new_transform(fn_service(|req: ServiceRequest| {
.new_transform(fn_service(|req: WebRequest| {
ok(req.into_response(
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::header::{HeaderMap, HeaderName, HeaderValue, CONTENT_TYPE};
use crate::service::{Service, Transform};
use crate::web::service::{ServiceRequest, ServiceResponse};
use crate::web::service::{WebRequest, WebResponse};
/// `Middleware` for setting default response headers.
///
@ -91,11 +91,11 @@ impl DefaultHeaders {
impl<S, B> Transform<S> for DefaultHeaders
where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
S::Future: 'static,
{
type Request = ServiceRequest;
type Response = ServiceResponse<B>;
type Request = WebRequest;
type Response = WebResponse<B>;
type Error = Error;
type InitError = ();
type Transform = DefaultHeadersMiddleware<S>;
@ -116,11 +116,11 @@ pub struct DefaultHeadersMiddleware<S> {
impl<S, B> Service for DefaultHeadersMiddleware<S>
where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
S::Future: 'static,
{
type Request = ServiceRequest;
type Response = ServiceResponse<B>;
type Request = WebRequest;
type Response = WebResponse<B>;
type Error = Error;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
@ -128,7 +128,7 @@ where
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 fut = self.service.call(req);
@ -161,7 +161,7 @@ mod tests {
use super::*;
use crate::http::header::CONTENT_TYPE;
use crate::service::IntoService;
use crate::web::service::ServiceRequest;
use crate::web::service::WebRequest;
use crate::web::test::{ok_service, TestRequest};
use crate::web::HttpResponse;
@ -178,7 +178,7 @@ mod tests {
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
let req = TestRequest::default().to_srv_request();
let srv = |req: ServiceRequest| {
let srv = |req: WebRequest| {
ok(req
.into_response(HttpResponse::Ok().header(CONTENT_TYPE, "0002").finish()))
};
@ -193,8 +193,7 @@ mod tests {
#[actix_rt::test]
async fn test_content_type() {
let srv =
|req: ServiceRequest| ok(req.into_response(HttpResponse::Ok().finish()));
let srv = |req: WebRequest| ok(req.into_response(HttpResponse::Ok().finish()));
let mut mw = DefaultHeaders::new()
.content_type()
.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::StatusCode;
use crate::service::{Service, Transform};
use crate::web::service::{ServiceRequest, ServiceResponse};
use crate::web::service::{WebRequest, WebResponse};
use crate::web::HttpResponse;
/// `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
where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
B: MessageBody,
{
type Request = ServiceRequest;
type Response = ServiceResponse<StreamLog<B>>;
type Request = WebRequest;
type Response = WebResponse<StreamLog<B>>;
type Error = Error;
type InitError = ();
type Transform = LoggerMiddleware<S>;
@ -147,11 +147,11 @@ pub struct LoggerMiddleware<S> {
impl<S, B> Service for LoggerMiddleware<S>
where
S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
S: Service<Request = WebRequest, Response = WebResponse<B>, Error = Error>,
B: MessageBody,
{
type Request = ServiceRequest;
type Response = ServiceResponse<StreamLog<B>>;
type Request = WebRequest;
type Response = WebResponse<StreamLog<B>>;
type Error = Error;
type Future = LoggerResponse<S, B>;
@ -159,7 +159,7 @@ where
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()) {
LoggerResponse {
fut: self.service.call(req),
@ -201,9 +201,9 @@ where
impl<S, B> Future for LoggerResponse<S, B>
where
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> {
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 {
FormatText::RequestLine => {
*self = if req.query_string().is_empty() {
@ -488,7 +488,7 @@ mod tests {
#[actix_rt::test]
async fn test_logger() {
let srv = |req: ServiceRequest| {
let srv = |req: WebRequest| {
ok(req.into_response(
HttpResponse::build(StatusCode::OK)
.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::rmap::ResourceMap;
pub use crate::web::service::{
HttpServiceFactory, ServiceRequest, ServiceResponse, WebService,
HttpServiceFactory, WebRequest, WebResponse, WebService,
};
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::responder::Responder;
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 HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
type HttpService = BoxService<WebRequest, WebResponse, Error>;
type HttpNewService = BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
/// *Resource* is an entry in resources table which corresponds to requested URL.
///
@ -79,8 +79,8 @@ impl<T> Resource<T>
where
T: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
InitError = (),
>,
@ -250,8 +250,8 @@ where
) -> Resource<
impl ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
InitError = (),
>,
@ -259,8 +259,8 @@ where
where
M: Transform<
T::Service,
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
InitError = (),
>,
@ -279,7 +279,7 @@ where
/// 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.
///
/// This is similar to `App's` middlewares, but middleware get invoked on resource level.
@ -317,15 +317,15 @@ where
) -> Resource<
impl ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
InitError = (),
>,
>
where
F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone,
R: Future<Output = Result<ServiceResponse, Error>>,
F: FnMut(WebRequest, &mut T::Service) -> R + Clone,
R: Future<Output = Result<WebResponse, Error>>,
{
Resource {
endpoint: apply_fn_factory(self.endpoint, mw),
@ -347,8 +347,8 @@ where
F: IntoServiceFactory<U>,
U: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
> + 'static,
U::InitError: fmt::Debug,
@ -368,8 +368,8 @@ impl<T> HttpServiceFactory for Resource<T>
where
T: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
InitError = (),
> + 'static,
@ -400,8 +400,8 @@ impl<T> IntoServiceFactory<T> for Resource<T>
where
T: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
InitError = (),
>,
@ -425,8 +425,8 @@ pub struct ResourceFactory {
impl ServiceFactory for ResourceFactory {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse;
type Request = WebRequest;
type Response = WebResponse;
type Error = Error;
type InitError = ();
type Service = ResourceService;
@ -519,19 +519,19 @@ pub struct ResourceService {
}
impl Service for ResourceService {
type Request = ServiceRequest;
type Response = ServiceResponse;
type Request = WebRequest;
type Response = WebResponse;
type Error = Error;
type Future = Either<
Ready<Result<ServiceResponse, Error>>,
LocalBoxFuture<'static, Result<ServiceResponse, Error>>,
Ready<Result<WebResponse, Error>>,
LocalBoxFuture<'static, Result<WebResponse, Error>>,
>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
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() {
if route.check(&mut req) {
if let Some(ref data) = self.data {
@ -544,7 +544,7 @@ impl Service for ResourceService {
Either::Right(default.call(req))
} else {
let req = req.into_parts().0;
Either::Left(ok(ServiceResponse::new(
Either::Left(ok(WebResponse::new(
req,
Response::MethodNotAllowed().finish(),
)))
@ -565,8 +565,8 @@ impl ResourceEndpoint {
impl ServiceFactory for ResourceEndpoint {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse;
type Request = WebRequest;
type Response = WebResponse;
type Error = Error;
type InitError = ();
type Service = ResourceService;
@ -587,7 +587,7 @@ mod tests {
use crate::http::header::{self, HeaderValue};
use crate::http::{Error, Method, StatusCode};
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::{self, guard, App, HttpResponse};
use crate::Service;
@ -683,7 +683,7 @@ mod tests {
.service(
web::resource("/test").route(web::get().to(|| HttpResponse::Ok())),
)
.default_service(|r: ServiceRequest| {
.default_service(|r: WebRequest| {
ok(r.into_response(HttpResponse::BadRequest()))
}),
)
@ -702,7 +702,7 @@ mod tests {
App::new().service(
web::resource("/test")
.route(web::get().to(|| HttpResponse::Ok()))
.default_service(|r: ServiceRequest| {
.default_service(|r: WebRequest| {
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::handler::{Extract, Factory, Handler};
use crate::web::responder::Responder;
use crate::web::service::{ServiceRequest, ServiceResponse};
use crate::web::service::{WebRequest, WebResponse};
use crate::web::HttpResponse;
type BoxedRouteService<Req, Res> = Box<
@ -41,7 +41,7 @@ type BoxedRouteNewService<Req, Res> = Box<
/// Route uses builder-like pattern for configuration.
/// If handler is not explicitly set, default *404 Not Found* handler is used.
pub struct Route {
service: BoxedRouteNewService<ServiceRequest, ServiceResponse>,
service: BoxedRouteNewService<WebRequest, WebResponse>,
guards: Rc<Vec<Box<dyn Guard>>>,
}
@ -63,8 +63,8 @@ impl Route {
impl ServiceFactory for Route {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse;
type Request = WebRequest;
type Response = WebResponse;
type Error = Error;
type InitError = ();
type Service = RouteService;
@ -78,10 +78,8 @@ impl ServiceFactory for Route {
}
}
type RouteFuture = LocalBoxFuture<
'static,
Result<BoxedRouteService<ServiceRequest, ServiceResponse>, ()>,
>;
type RouteFuture =
LocalBoxFuture<'static, Result<BoxedRouteService<WebRequest, WebResponse>, ()>>;
#[pin_project::pin_project]
pub struct CreateRouteService {
@ -107,12 +105,12 @@ impl Future for CreateRouteService {
}
pub struct RouteService {
service: BoxedRouteService<ServiceRequest, ServiceResponse>,
service: BoxedRouteService<WebRequest, WebResponse>,
guards: Rc<Vec<Box<dyn Guard>>>,
}
impl RouteService {
pub fn check(&self, req: &mut ServiceRequest) -> bool {
pub fn check(&self, req: &mut WebRequest) -> bool {
for f in self.guards.iter() {
if !f.check(req.head()) {
return false;
@ -123,8 +121,8 @@ impl RouteService {
}
impl Service for RouteService {
type Request = ServiceRequest;
type Response = ServiceResponse;
type Request = WebRequest;
type Response = WebResponse;
type Error = Error;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
@ -132,7 +130,7 @@ impl Service for RouteService {
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()
}
}
@ -239,7 +237,7 @@ impl Route {
struct RouteNewService<T>
where
T: ServiceFactory<Request = ServiceRequest, Error = (Error, ServiceRequest)>,
T: ServiceFactory<Request = WebRequest, Error = (Error, WebRequest)>,
{
service: T,
}
@ -248,9 +246,9 @@ impl<T> RouteNewService<T>
where
T: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Error = (Error, ServiceRequest),
Request = WebRequest,
Response = WebResponse,
Error = (Error, WebRequest),
>,
T::Future: 'static,
T::Service: 'static,
@ -265,20 +263,20 @@ impl<T> ServiceFactory for RouteNewService<T>
where
T: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Error = (Error, ServiceRequest),
Request = WebRequest,
Response = WebResponse,
Error = (Error, WebRequest),
>,
T::Future: 'static,
T::Service: 'static,
<T::Service as Service>::Future: 'static,
{
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse;
type Request = WebRequest;
type Response = WebResponse;
type Error = Error;
type InitError = ();
type Service = BoxedRouteService<ServiceRequest, Self::Response>;
type Service = BoxedRouteService<WebRequest, Self::Response>;
type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
fn new_service(&self, _: ()) -> Self::Future {
@ -304,13 +302,13 @@ impl<T> Service for RouteServiceWrapper<T>
where
T::Future: 'static,
T: Service<
Request = ServiceRequest,
Response = ServiceResponse,
Error = (Error, ServiceRequest),
Request = WebRequest,
Response = WebResponse,
Error = (Error, WebRequest),
>,
{
type Request = ServiceRequest;
type Response = ServiceResponse;
type Request = WebRequest;
type Response = WebResponse;
type Error = Error;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
@ -318,7 +316,7 @@ where
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
.call(req)
.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::route::Route;
use crate::web::service::{
AppServiceFactory, ServiceFactoryWrapper, ServiceRequest, ServiceResponse,
AppServiceFactory, ServiceFactoryWrapper, WebRequest, WebResponse,
};
type Guards = Vec<Box<dyn Guard>>;
type HttpService = BoxService<ServiceRequest, ServiceResponse, Error>;
type HttpNewService = BoxServiceFactory<(), ServiceRequest, ServiceResponse, Error, ()>;
type BoxedResponse = LocalBoxFuture<'static, Result<ServiceResponse, Error>>;
type HttpService = BoxService<WebRequest, WebResponse, Error>;
type HttpNewService = BoxServiceFactory<(), WebRequest, WebResponse, Error, ()>;
type BoxedResponse = LocalBoxFuture<'static, Result<WebResponse, Error>>;
/// Resources scope.
///
@ -89,8 +89,8 @@ impl<T> Scope<T>
where
T: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
InitError = (),
>,
@ -283,8 +283,8 @@ where
F: IntoServiceFactory<U>,
U: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
> + 'static,
U::InitError: fmt::Debug,
@ -305,7 +305,7 @@ where
/// necessary, across all requests managed by the *Scope*. Scope-level
/// middleware is more limited in what it can modify, relative to Route or
/// 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.
pub fn wrap<M>(
@ -314,8 +314,8 @@ where
) -> Scope<
impl ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
InitError = (),
>,
@ -323,8 +323,8 @@ where
where
M: Transform<
T::Service,
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
InitError = (),
>,
@ -346,7 +346,7 @@ where
/// request as necessary, across all requests managed by the *Scope*.
/// Scope-level middleware is more limited in what it can modify, relative
/// to Route or Application level middleware, in that Scope-level middleware
/// can not modify ServiceResponse.
/// can not modify WebResponse.
///
/// ```rust
/// use ntex::service::Service;
@ -379,15 +379,15 @@ where
) -> Scope<
impl ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
InitError = (),
>,
>
where
F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone,
R: Future<Output = Result<ServiceResponse, Error>>,
F: FnMut(WebRequest, &mut T::Service) -> R + Clone,
R: Future<Output = Result<WebResponse, Error>>,
{
Scope {
endpoint: apply_fn_factory(self.endpoint, mw),
@ -406,8 +406,8 @@ impl<T> HttpServiceFactory for Scope<T>
where
T: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
InitError = (),
> + 'static,
@ -477,8 +477,8 @@ pub struct ScopeFactory {
impl ServiceFactory for ScopeFactory {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse;
type Request = WebRequest;
type Response = WebResponse;
type Error = Error;
type InitError = ();
type Service = ScopeService;
@ -593,12 +593,12 @@ pub struct ScopeService {
data: Option<Rc<Extensions>>,
router: Router<HttpService, Vec<Box<dyn Guard>>>,
default: Option<HttpService>,
_ready: Option<(ServiceRequest, ResourceInfo)>,
_ready: Option<(WebRequest, ResourceInfo)>,
}
impl Service for ScopeService {
type Request = ServiceRequest;
type Response = ServiceResponse;
type Request = WebRequest;
type Response = WebResponse;
type Error = Error;
type Future = Either<BoxedResponse, Ready<Result<Self::Response, Self::Error>>>;
@ -606,7 +606,7 @@ impl Service for ScopeService {
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| {
if let Some(ref guards) = guards {
for f in guards {
@ -627,7 +627,7 @@ impl Service for ScopeService {
Either::Left(default.call(req))
} else {
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 {
type Config = ();
type Request = ServiceRequest;
type Response = ServiceResponse;
type Request = WebRequest;
type Response = WebResponse;
type Error = Error;
type InitError = ();
type Service = ScopeService;
@ -667,7 +667,7 @@ mod tests {
use crate::http::{Method, StatusCode};
use crate::service::Service;
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::{self, guard, App, HttpRequest, HttpResponse};
@ -993,7 +993,7 @@ mod tests {
App::new().service(
web::scope("/app")
.service(web::resource("/path1").to(|| HttpResponse::Ok()))
.default_service(|r: ServiceRequest| {
.default_service(|r: WebRequest| {
ok(r.into_response(HttpResponse::BadRequest()))
}),
),
@ -1017,7 +1017,7 @@ mod tests {
web::resource("").to(|| HttpResponse::BadRequest()),
))
.service(web::scope("/app2"))
.default_service(|r: ServiceRequest| {
.default_service(|r: WebRequest| {
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);
}
pub(crate) trait AppServiceFactory {
pub(super) trait AppServiceFactory {
fn register(&mut self, config: &mut AppService);
}
pub(crate) struct ServiceFactoryWrapper<T> {
pub(super) struct ServiceFactoryWrapper<T> {
factory: Option<T>,
}
@ -52,13 +52,13 @@ where
/// An service http request
///
/// ServiceRequest allows mutable access to request's internal structures
pub struct ServiceRequest(HttpRequest);
/// WebRequest allows mutable access to request's internal structures
pub struct WebRequest(HttpRequest);
impl ServiceRequest {
/// Construct service request
impl WebRequest {
/// Construct web request
pub(crate) fn new(req: HttpRequest) -> Self {
ServiceRequest(req)
WebRequest(req)
}
/// Deconstruct request into parts
@ -69,14 +69,14 @@ impl ServiceRequest {
/// 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(
mut req: HttpRequest,
pl: Payload,
) -> Result<Self, (HttpRequest, Payload)> {
if Rc::strong_count(&req.0) == 1 && Rc::weak_count(&req.0) == 0 {
Rc::get_mut(&mut req.0).unwrap().payload = pl;
Ok(ServiceRequest(req))
Ok(WebRequest(req))
} else {
Err((req, pl))
}
@ -84,28 +84,28 @@ impl ServiceRequest {
/// 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
/// weak pointers count is 0.
pub fn from_request(req: HttpRequest) -> Result<Self, HttpRequest> {
if Rc::strong_count(&req.0) == 1 && Rc::weak_count(&req.0) == 0 {
Ok(ServiceRequest(req))
Ok(WebRequest(req))
} else {
Err(req)
}
}
/// Create service response
/// Create web response
#[inline]
pub fn into_response<B, R: Into<Response<B>>>(self, res: R) -> ServiceResponse<B> {
ServiceResponse::new(self.0, res.into())
pub fn into_response<B, R: Into<Response<B>>>(self, res: R) -> WebResponse<B> {
WebResponse::new(self.0, res.into())
}
/// Create service response for error
/// Create web response for error
#[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();
ServiceResponse::new(self.0, res.into_body())
WebResponse::new(self.0, res.into_body())
}
/// 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> {
self.match_info_mut()
}
}
impl HttpMessage for ServiceRequest {
impl HttpMessage for WebRequest {
type Stream = PayloadStream;
#[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 {
writeln!(
f,
"\nServiceRequest {:?} {}:{}",
"\nWebRequest {:?} {}:{}",
self.head().version,
self.head().method,
self.path()
@ -292,37 +292,37 @@ impl fmt::Debug for ServiceRequest {
}
}
pub struct ServiceResponse<B = Body> {
pub struct WebResponse<B = Body> {
request: HttpRequest,
response: Response<B>,
}
impl<B> ServiceResponse<B> {
/// Create service response instance
impl<B> WebResponse<B> {
/// Create web response instance
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 {
let e: Error = err.into();
let res: Response = e.into();
ServiceResponse {
WebResponse {
request,
response: res.into_body(),
}
}
/// Create service response for error
/// Create web response for error
#[inline]
pub fn error_response<E: Into<Error>>(self, err: E) -> Self {
Self::from_err(err, self.request)
}
/// Create service response
/// Create web response
#[inline]
pub fn into_response<B1>(self, response: Response<B1>) -> ServiceResponse<B1> {
ServiceResponse::new(self.request, response)
pub fn into_response<B1>(self, response: Response<B1>) -> WebResponse<B1> {
WebResponse::new(self.request, response)
}
/// Get reference to original request
@ -371,7 +371,7 @@ impl<B> ServiceResponse<B> {
Ok(_) => self,
Err(err) => {
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
pub fn map_body<F, B2>(self, f: F) -> ServiceResponse<B2>
pub fn map_body<F, B2>(self, f: F) -> WebResponse<B2>
where
F: FnOnce(&mut ResponseHead, ResponseBody<B>) -> ResponseBody<B2>,
{
let response = self.response.map_body(f);
ServiceResponse {
WebResponse {
response,
request: self.request,
}
}
}
impl<B> Into<Response<B>> for ServiceResponse<B> {
impl<B> Into<Response<B>> for WebResponse<B> {
fn into(self) -> Response<B> {
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 {
let res = writeln!(
f,
"\nServiceResponse {:?} {}{}",
"\nWebResponse {:?} {}{}",
self.response.head().version,
self.response.head().status,
self.response.head().reason.unwrap_or(""),
@ -451,7 +451,7 @@ impl WebService {
/// use ntex::http;
/// 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()))
/// }
///
@ -475,8 +475,8 @@ impl WebService {
F: IntoServiceFactory<T>,
T: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
InitError = (),
> + 'static,
@ -501,8 +501,8 @@ impl<T> HttpServiceFactory for WebServiceImpl<T>
where
T: ServiceFactory<
Config = (),
Request = ServiceRequest,
Response = ServiceResponse,
Request = WebRequest,
Response = WebResponse,
Error = Error,
InitError = (),
> + 'static,
@ -540,28 +540,28 @@ mod tests {
fn test_service_request() {
let req = TestRequest::default().to_srv_request();
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 (r, pl) = req.into_parts();
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 (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 (r, _pl) = req.into_parts();
let _r2 = r.clone();
assert!(ServiceRequest::from_request(r).is_err());
assert!(WebRequest::from_request(r).is_err());
}
#[actix_rt::test]
async fn test_service() {
let mut srv = init_service(
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;
@ -571,7 +571,7 @@ mod tests {
let mut srv = init_service(
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;
@ -589,7 +589,7 @@ mod tests {
.header("x-test", "111")
.to_srv_request();
let s = format!("{:?}", req);
assert!(s.contains("ServiceRequest"));
assert!(s.contains("WebRequest"));
assert!(s.contains("test=1"));
assert!(s.contains("x-test"));
@ -599,7 +599,7 @@ mod tests {
.to_srv_response(res);
let s = format!("{:?}", res);
assert!(s.contains("ServiceResponse"));
assert!(s.contains("WebResponse"));
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::request::HttpRequestPool;
use crate::web::rmap::ResourceMap;
use crate::web::service::{ServiceRequest, ServiceResponse};
use crate::web::service::{WebRequest, WebResponse};
use crate::web::{HttpRequest, HttpResponse};
/// Create service that always responds with `HttpResponse::Ok()`
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)
}
/// Create service that responds with response with specified status code
pub fn default_service(
status_code: StatusCode,
) -> impl Service<Request = ServiceRequest, Response = ServiceResponse<Body>, Error = Error>
{
(move |req: ServiceRequest| {
) -> impl Service<Request = WebRequest, Response = WebResponse<Body>, Error = Error> {
(move |req: WebRequest| {
ok(req.into_response(HttpResponse::build(status_code).finish()))
})
.into_service()
@ -80,13 +78,13 @@ pub fn default_service(
/// ```
pub async fn init_service<R, S, B, E>(
app: R,
) -> impl Service<Request = Request, Response = ServiceResponse<B>, Error = E>
) -> impl Service<Request = Request, Response = WebResponse<B>, Error = E>
where
R: IntoServiceFactory<S>,
S: ServiceFactory<
Config = AppConfig,
Request = Request,
Response = ServiceResponse<B>,
Response = WebResponse<B>,
Error = E,
>,
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
where
S: Service<Request = R, Response = ServiceResponse<B>, Error = E>,
S: Service<Request = R, Response = WebResponse<B>, Error = E>,
E: std::fmt::Debug,
{
app.call(req).await.unwrap()
@ -154,7 +152,7 @@ where
/// ```
pub async fn read_response<S, B>(app: &mut S, req: Request) -> Bytes
where
S: Service<Request = Request, Response = ServiceResponse<B>, Error = Error>,
S: Service<Request = Request, Response = WebResponse<B>, Error = Error>,
B: MessageBody,
{
let mut resp = app
@ -170,7 +168,7 @@ where
bytes.freeze()
}
/// Helper function that returns a response body of a ServiceResponse.
/// Helper function that returns a response body of a WebResponse.
///
/// ```rust
/// use bytes::Bytes;
@ -197,7 +195,7 @@ where
/// 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
B: MessageBody,
{
@ -257,7 +255,7 @@ where
/// ```
pub async fn read_response_json<S, B, T>(app: &mut S, req: Request) -> T
where
S: Service<Request = Request, Response = ServiceResponse<B>, Error = Error>,
S: Service<Request = Request, Response = WebResponse<B>, Error = Error>,
B: MessageBody,
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.
/// You can generate various types of request via TestRequest's methods:
/// * `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_response` creates `ServiceResponse` instance.
/// * `TestRequest::to_srv_request` creates `WebRequest` instance, which is used for testing middlewares and chain adapters.
/// * `TestRequest::to_srv_response` creates `WebResponse` instance.
/// * `TestRequest::to_http_request` creates `HttpRequest` instance, which is used for testing handlers.
///
/// ```rust
@ -461,13 +459,13 @@ impl TestRequest {
req
}
/// Complete request creation and generate `ServiceRequest` instance
pub fn to_srv_request(mut self) -> ServiceRequest {
/// Complete request creation and generate `WebRequest` instance
pub fn to_srv_request(mut self) -> WebRequest {
let (mut head, payload) = self.req.finish().into_parts();
head.peer_addr = self.peer_addr;
self.path.get_mut().update(&head.uri);
ServiceRequest::new(HttpRequest::new(
WebRequest::new(HttpRequest::new(
self.path,
head,
payload,
@ -478,8 +476,8 @@ impl TestRequest {
))
}
/// Complete request creation and generate `ServiceResponse` instance
pub fn to_srv_response<B>(self, res: HttpResponse<B>) -> ServiceResponse<B> {
/// Complete request creation and generate `WebResponse` instance
pub fn to_srv_response<B>(self, res: HttpResponse<B>) -> WebResponse<B> {
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.
/// This future could be used with `ServiceRequest` and `ServiceFromRequest`.
///
/// Returns error:
///

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

@ -237,7 +237,7 @@ where
/// use ntex::http::Error;
/// 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()))
/// }
///