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

Various refactorings (#8)

Browse source 
* update doc comments

* rename server ServiceFactory to StreamServiceFactory

* refactor web service factories

* run tarpaulin on 1.42

* re-enable extractos tests
This commit is contained in:
Nikolay Kim 2020-04-05 13:26:13 +06:00 • committed by GitHub
parent 6f9c6aabea
commit 167155bc78
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
46 changed files with 1735 additions and 2984 deletions
Download patch file Download diff file Expand all files Collapse all files

8
.github/workflows/linux.yml vendored
View file

@ -49,10 +49,10 @@ jobs:
key: ${{ matrix.version }}-x86_64-unknown-linux-gnu-cargo-build-trimmed-${{ hashFiles('**/Cargo.lock') }}
- name: Cache cargo tarpaulin
if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
if: matrix.version == '1.42.0' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
uses: actions/cache@v1
with:
path: ~/.cargo/bin/cargo-tarpaulin
path: ~/.cargo/bin
key: ${{ matrix.version }}-x86_64-unknown-linux-gnu-tarpaulin
- name: check build
@ -69,13 +69,13 @@ jobs:
args: --all --all-features --no-fail-fast -- --nocapture
- name: Generate coverage file
if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
if: matrix.version == '1.42.0' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
run: |
cargo install cargo-tarpaulin
cargo tarpaulin --out Xml --all --all-features
- name: Upload to Codecov
if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
if: matrix.version == '1.42.0' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
uses: codecov/codecov-action@v1
with:
file: cobertura.xml

17
README.md
View file

@ -1,9 +1,9 @@
<div align="center">
<p><h1>ntex</h1> </p>
<p><strong>This is personal project, please, do not use it</strong> </p>
<p><strong>This is personal project, do not use it</strong> </p>
<p>
![Build Status](https://github.com/ntex-rs/ntex/workflows/CI%20(Linux)/badge.svg)
[![build status](https://github.com/ntex-rs/actix-net/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions?query=workflow%3A"CI+(Linux)")
[![codecov](https://codecov.io/gh/ntex-rs/ntex/branch/master/graph/badge.svg)](https://codecov.io/gh/ntex-rs/ntex)
[![crates.io](https://meritbadge.herokuapp.com/ntex)](https://crates.io/crates/ntex)
[![Documentation](https://docs.rs/ntex/badge.svg)](https://docs.rs/ntex)
@ -13,6 +13,19 @@
</p>
</div>
## Build statuses
| Platform | Build Status |
| ---------------- | ------------ |
| Linux | [![build status](https://github.com/ntex-rs/actix-net/workflows/CI%20%28Linux%29/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions?query=workflow%3A"CI+(Linux)") |
| macOS | [![build status](https://github.com/ntex-rs/actix-net/workflows/CI%20%28OSX%29/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions?query=workflow%3A"CI+(OSX)") |
| Windows | [![build status](https://github.com/ntex-rs/actix-net/workflows/CI%20%28Windows%29/badge.svg?branch=master&event=push)](https://github.com/ntex-rs/ntex/actions?query=workflow%3A"CI+(Windows)") |
## Documentation & community resources
* [Documentation](https://docs.rs/ntex)
* Minimum supported Rust version: 1.42 or later
## License
This project is licensed under

4
ntex/CHANGES.md
View file

@ -1,5 +1,9 @@
# Changes
## [0.1.2] - 2020-04-05
* HTTP1 dispatcher refactoring
## [0.1.1] - 2020-04-01
* Project fork

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

@ -1,9 +1,4 @@
//! Actix connect - tcp connector service
//!
//! ## Package feature
//!
//! * `openssl` - enables ssl support via `openssl` crate
//! * `rustls` - enables ssl support via `rustls` crate
//! Tcp connector service
mod error;
mod message;

2
ntex/src/framed/service.rs
View file

@ -90,7 +90,7 @@ where
<Codec as Encoder>::Error: std::fmt::Debug,
Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
{
/// Construct framed handler new service with specified connect service
/// Construct framed handler service factory with specified connect service
pub fn new<F>(connect: F) -> FactoryBuilder<St, C, Io, Codec, Out>
where
F: IntoServiceFactory<C>,

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

@ -12,7 +12,7 @@ use coo_kie::{Cookie, CookieJar};
use crate::codec::{AsyncRead, AsyncWrite, Framed};
use crate::rt::{net::TcpStream, System};
use crate::server::{Server, ServiceFactory};
use crate::server::{Server, StreamServiceFactory};
use super::client::error::WsClientError;
use super::client::{Client, ClientRequest, ClientResponse, Connector};
@ -213,7 +213,7 @@ fn parts(parts: &mut Option<Inner>) -> &mut Inner {
/// assert!(response.status().is_success());
/// }
/// ```
pub fn server<F: ServiceFactory<TcpStream>>(factory: F) -> TestServer {
pub fn server<F: StreamServiceFactory<TcpStream>>(factory: F) -> TestServer {
let (tx, rx) = mpsc::channel();
// run server in separate thread

9
ntex/src/lib.rs
View file

@ -1,3 +1,12 @@
//! ntex - framework for composable network services
//!
//! ## Package feature
//!
//! * `openssl` - enables ssl support via `openssl` crate
//! * `rustls` - enables ssl support via `rustls` crate
//! * `compress` - enables compression support in http and web modules
//! * `cookie` - enables cookie support in http and web modules
#![warn(
rust_2018_idioms,
unreachable_pub,

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

@ -18,7 +18,7 @@ use crate::rt::{spawn, System};
use super::accept::{AcceptLoop, AcceptNotify, Command};
use super::config::{ConfiguredService, ServiceConfig};
use super::service::{InternalServiceFactory, ServiceFactory, StreamNewService};
use super::service::{Factory, InternalServiceFactory, StreamServiceFactory};
use super::signals::{Signal, Signals};
use super::socket::StdListener;
use super::worker::{self, Worker, WorkerAvailability, WorkerClient};
@ -164,14 +164,14 @@ impl ServerBuilder {
factory: F,
) -> io::Result<Self>
where
F: ServiceFactory<TcpStream>,
F: StreamServiceFactory<TcpStream>,
U: net::ToSocketAddrs,
{
let sockets = bind_addr(addr, self.backlog)?;
for lst in sockets {
let token = self.token.next();
self.services.push(StreamNewService::create(
self.services.push(Factory::create(
name.as_ref().to_string(),
token,
factory.clone(),
@ -187,7 +187,7 @@ impl ServerBuilder {
/// Add new unix domain service to the server.
pub fn bind_uds<F, U, N>(self, name: N, addr: U, factory: F) -> io::Result<Self>
where
F: ServiceFactory<crate::rt::net::UnixStream>,
F: StreamServiceFactory<crate::rt::net::UnixStream>,
N: AsRef<str>,
U: AsRef<std::path::Path>,
{
@ -217,12 +217,12 @@ impl ServerBuilder {
factory: F,
) -> io::Result<Self>
where
F: ServiceFactory<crate::rt::net::UnixStream>,
F: StreamServiceFactory<crate::rt::net::UnixStream>,
{
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
let token = self.token.next();
let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
self.services.push(StreamNewService::create(
self.services.push(Factory::create(
name.as_ref().to_string(),
token,
factory,
@ -241,10 +241,10 @@ impl ServerBuilder {
factory: F,
) -> io::Result<Self>
where
F: ServiceFactory<TcpStream>,
F: StreamServiceFactory<TcpStream>,
{
let token = self.token.next();
self.services.push(StreamNewService::create(
self.services.push(Factory::create(
name.as_ref().to_string(),
token,
factory,

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

@ -39,7 +39,7 @@ impl ServiceConfig {
self.threads = num;
}
/// Add new service to server
/// Add new service to a server
pub fn bind<U, N: AsRef<str>>(&mut self, name: N, addr: U) -> io::Result<&mut Self>
where
U: net::ToSocketAddrs,
@ -53,7 +53,7 @@ impl ServiceConfig {
Ok(self)
}
/// Add new service to server
/// Add new service to a server
pub fn listen<N: AsRef<str>>(
&mut self,
name: N,

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

@ -29,7 +29,7 @@ pub mod rustls;
pub use self::builder::ServerBuilder;
pub use self::config::{ServiceConfig, ServiceRuntime};
pub use self::service::ServiceFactory;
pub use self::service::StreamServiceFactory;
pub use self::test::{build_test_server, test_server, TestServer};
#[doc(hidden)]
@ -48,7 +48,7 @@ impl Token {
}
/// Start server building process
pub fn new() -> ServerBuilder {
pub fn build() -> ServerBuilder {
ServerBuilder::default()
}

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

@ -15,7 +15,7 @@ use super::socket::{FromStream, StdStream};
use super::Token;
/// Server message
pub(crate) enum ServerMessage {
pub(super) enum ServerMessage {
/// New stream
Connect(StdStream),
/// Gracefull shutdown
@ -24,13 +24,13 @@ pub(crate) enum ServerMessage {
ForceShutdown,
}
pub trait ServiceFactory<Stream: FromStream>: Send + Clone + 'static {
pub trait StreamServiceFactory<Stream: FromStream>: Send + Clone + 'static {
type Factory: ActixServiceFactory<Config = (), Request = Stream>;
fn create(&self) -> Self::Factory;
}
pub(crate) trait InternalServiceFactory: Send {
pub(super) trait InternalServiceFactory: Send {
fn name(&self, token: Token) -> &str;
fn clone_factory(&self) -> Box<dyn InternalServiceFactory>;
@ -40,7 +40,7 @@ pub(crate) trait InternalServiceFactory: Send {
) -> LocalBoxFuture<'static, Result<Vec<(Token, BoxedServerService)>, ()>>;
}
pub(crate) type BoxedServerService = Box<
pub(super) type BoxedServerService = Box<
dyn Service<
Request = (Option<CounterGuard>, ServerMessage),
Response = (),
@ -49,7 +49,7 @@ pub(crate) type BoxedServerService = Box<
>,
>;
pub(crate) struct StreamService<T> {
pub(super) struct StreamService<T> {
service: T,
}
@ -104,7 +104,7 @@ where
}
}
pub(crate) struct StreamNewService<F: ServiceFactory<Io>, Io: FromStream> {
pub(super) struct Factory<F: StreamServiceFactory<Io>, Io: FromStream> {
name: String,
inner: F,
token: Token,
@ -112,9 +112,9 @@ pub(crate) struct StreamNewService<F: ServiceFactory<Io>, Io: FromStream> {
_t: PhantomData<Io>,
}
impl<F, Io> StreamNewService<F, Io>
impl<F, Io> Factory<F, Io>
where
F: ServiceFactory<Io>,
F: StreamServiceFactory<Io>,
Io: FromStream + Send + 'static,
{
pub(crate) fn create(
@ -133,9 +133,9 @@ where
}
}
impl<F, Io> InternalServiceFactory for StreamNewService<F, Io>
impl<F, Io> InternalServiceFactory for Factory<F, Io>
where
F: ServiceFactory<Io>,
F: StreamServiceFactory<Io>,
Io: FromStream + Send + 'static,
{
fn name(&self, _: Token) -> &str {
@ -184,7 +184,7 @@ impl InternalServiceFactory for Box<dyn InternalServiceFactory> {
}
}
impl<F, T, I> ServiceFactory<I> for F
impl<F, T, I> StreamServiceFactory<I> for F
where
F: Fn() -> T + Send + Clone + 'static,
T: ActixServiceFactory<Config = (), Request = I>,

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

@ -5,7 +5,7 @@ use std::{io, net, thread};
use net2::TcpBuilder;
use crate::rt::{net::TcpStream, System};
use crate::server::{Server, ServerBuilder, ServiceFactory};
use crate::server::{Server, ServerBuilder, StreamServiceFactory};
/// Start test server
///
@ -38,7 +38,7 @@ use crate::server::{Server, ServerBuilder, ServiceFactory};
/// assert!(response.status().is_success());
/// }
/// ```
pub fn test_server<F: ServiceFactory<TcpStream>>(factory: F) -> TestServer {
pub fn test_server<F: StreamServiceFactory<TcpStream>>(factory: F) -> TestServer {
let (tx, rx) = mpsc::channel();
// run server in separate thread

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

@ -6,7 +6,7 @@ use futures::{future, ready, Future};
use crate::service::{Service, ServiceFactory};
/// Construct `Either` service factor.
/// Construct `Either` service factory.
///
/// Either service allow to combine two different services into a single service.
pub fn either<A, B>(left: A, right: B) -> Either<A, B>

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

@ -1,3 +1,5 @@
//! Service that limits number of in-flight async requests.
use std::convert::Infallible;
use std::future::Future;
use std::pin::Pin;
@ -8,7 +10,7 @@ use futures::future::{ok, Ready};
use super::counter::{Counter, CounterGuard};
use crate::service::{IntoService, Service, Transform};
/// InFlight - new service for service that can limit number of in-flight
/// InFlight - service factory for service that can limit number of in-flight
/// async requests.
///
/// Default number of in-flight requests is 15

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

@ -19,7 +19,7 @@ struct Record<I, E> {
tx: oneshot::Sender<Result<I, E>>,
}
/// Timeout error
/// InOrder error
pub enum InOrderError<E> {
/// Service error
Service(E),

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

@ -161,6 +161,7 @@ where
}
/// `TimeoutService` response future
#[doc(hidden)]
#[pin_project::pin_project]
#[derive(Debug)]
pub struct TimeoutServiceResponse<T: Service> {
@ -194,6 +195,7 @@ where
}
/// `TimeoutService` response future
#[doc(hidden)]
#[pin_project::pin_project]
#[derive(Debug)]
pub struct TimeoutServiceResponse2<T: Service> {

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

@ -17,12 +17,11 @@ use crate::service::{
use super::app_service::{AppEntry, AppFactory, AppRoutingFactory};
use super::config::ServiceConfig;
use super::data::{Data, DataFactory};
use super::request::WebRequest;
use super::resource::Resource;
use super::response::WebResponse;
use super::route::Route;
use super::service::{
AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, WebRequest,
WebResponse,
};
use super::service::{AppServiceFactory, ServiceFactoryWrapper, WebServiceFactory};
use super::{DefaultError, ErrorRenderer};
type HttpNewService<Err: ErrorRenderer> =
@ -242,7 +241,7 @@ where
/// Register http service.
///
/// Http service is any type that implements `HttpServiceFactory` trait.
/// Http service is any type that implements `WebServiceFactory` trait.
///
/// Actix web provides several services implementations:
///
@ -251,7 +250,7 @@ where
/// * "StaticFiles" is a service for static files support
pub fn service<F>(mut self, factory: F) -> Self
where
F: HttpServiceFactory<Err> + 'static,
F: WebServiceFactory<Err> + 'static,
{
self.services
.push(Box::new(ServiceFactoryWrapper::new(factory)));
@ -522,7 +521,7 @@ mod tests {
use crate::http::header::{self, HeaderValue};
use crate::http::{Method, StatusCode};
use crate::web::middleware::DefaultHeaders;
use crate::web::service::WebRequest;
use crate::web::request::WebRequest;
use crate::web::test::{call_service, init_service, read_body, TestRequest};
use crate::web::{self, DefaultError, HttpRequest, HttpResponse};
use crate::Service;

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

@ -12,13 +12,15 @@ use crate::router::{Path, ResourceDef, ResourceInfo, Router};
use crate::service::boxed::{self, BoxService, BoxServiceFactory};
use crate::{fn_service, Service, ServiceFactory};
use super::config::{AppConfig, AppService};
use super::config::AppConfig;
use super::data::DataFactory;
use super::error::ErrorRenderer;
use super::guard::Guard;
use super::request::{HttpRequest, HttpRequestPool};
use super::httprequest::{HttpRequest, HttpRequestPool};
use super::request::WebRequest;
use super::response::WebResponse;
use super::rmap::ResourceMap;
use super::service::{AppServiceFactory, WebRequest, WebResponse};
use super::service::{AppServiceFactory, WebServiceConfig};
type Guards = Vec<Box<dyn Guard>>;
type HttpService<Err: ErrorRenderer> =
@ -82,7 +84,8 @@ where
});
// App config
let mut config = AppService::new(config, default.clone(), self.data.clone());
let mut config =
WebServiceConfig::new(config, default.clone(), self.data.clone());
// register services
std::mem::replace(&mut *self.services.borrow_mut(), Vec::new())

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

@ -1,128 +1,15 @@
use std::net::SocketAddr;
use std::rc::Rc;
use crate::http::Extensions;
use crate::router::ResourceDef;
use crate::service::{boxed, IntoServiceFactory, ServiceFactory};
use super::data::{Data, DataFactory};
use super::guard::Guard;
use super::resource::Resource;
use super::rmap::ResourceMap;
use super::route::Route;
use super::service::{
AppServiceFactory, HttpServiceFactory, ServiceFactoryWrapper, WebRequest,
WebResponse,
};
use super::service::{AppServiceFactory, ServiceFactoryWrapper, WebServiceFactory};
use super::{DefaultError, ErrorRenderer};
type Guards = Vec<Box<dyn Guard>>;
type HttpNewService<Err: ErrorRenderer> =
boxed::BoxServiceFactory<(), WebRequest<Err>, WebResponse, Err::Container, ()>;
/// Application configuration
pub struct AppService<Err: ErrorRenderer> {
config: AppConfig,
root: bool,
default: Rc<HttpNewService<Err>>,
services: Vec<(
ResourceDef,
HttpNewService<Err>,
Option<Guards>,
Option<Rc<ResourceMap>>,
)>,
service_data: Rc<Vec<Box<dyn DataFactory>>>,
}
impl<Err: ErrorRenderer> AppService<Err> {
/// Crate server settings instance
pub(crate) fn new(
config: AppConfig,
default: Rc<HttpNewService<Err>>,
service_data: Rc<Vec<Box<dyn DataFactory>>>,
) -> Self {
AppService {
config,
default,
service_data,
root: true,
services: Vec::new(),
}
}
/// Check if root is beeing configured
pub fn is_root(&self) -> bool {
self.root
}
pub(crate) fn into_services(
self,
) -> (
AppConfig,
Vec<(
ResourceDef,
HttpNewService<Err>,
Option<Guards>,
Option<Rc<ResourceMap>>,
)>,
) {
(self.config, self.services)
}
pub(crate) fn clone_config(&self) -> Self {
AppService {
config: self.config.clone(),
default: self.default.clone(),
services: Vec::new(),
root: false,
service_data: self.service_data.clone(),
}
}
/// Service configuration
pub fn config(&self) -> &AppConfig {
&self.config
}
/// Default resource
pub fn default_service(&self) -> Rc<HttpNewService<Err>> {
self.default.clone()
}
/// Set global route data
pub fn set_service_data(&self, extensions: &mut Extensions) -> bool {
for f in self.service_data.iter() {
f.create(extensions);
}
!self.service_data.is_empty()
}
/// Register http service
pub fn register_service<F, S>(
&mut self,
rdef: ResourceDef,
guards: Option<Vec<Box<dyn Guard>>>,
factory: F,
nested: Option<Rc<ResourceMap>>,
) where
F: IntoServiceFactory<S>,
S: ServiceFactory<
Config = (),
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
InitError = (),
> + 'static,
{
self.services.push((
rdef,
boxed::factory(factory.into_factory()),
guards,
nested,
));
}
}
#[derive(Clone)]
pub struct AppConfig(Rc<AppConfigInner>);
@ -213,7 +100,7 @@ impl<Err: ErrorRenderer> ServiceConfig<Err> {
/// This is same as `App::service()` method.
pub fn service<F>(&mut self, factory: F) -> &mut Self
where
F: HttpServiceFactory<Err> + 'static,
F: WebServiceFactory<Err> + 'static,
{
self.services
.push(Box::new(ServiceFactoryWrapper::new(factory)));
@ -250,7 +137,7 @@ mod tests {
use crate::Service;
#[ntex_rt::test]
async fn test_data() {
async fn test_configure_data() {
let cfg = |cfg: &mut ServiceConfig<_>| {
cfg.data(10usize);
};
@ -264,40 +151,8 @@ mod tests {
assert_eq!(resp.status(), StatusCode::OK);
}
// #[ntex_rt::test]
// async fn test_data_factory() {
// let cfg = |cfg: &mut ServiceConfig| {
// cfg.data_factory(|| {
// sleep(std::time::Duration::from_millis(50)).then(|_| {
// println!("READY");
// Ok::<_, ()>(10usize)
// })
// });
// };
// let mut srv =
// init_service(App::new().configure(cfg).service(
// web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
// ));
// let req = TestRequest::default().to_request();
// let resp = srv.call(req).await.unwrap();
// assert_eq!(resp.status(), StatusCode::OK);
// let cfg2 = |cfg: &mut ServiceConfig| {
// cfg.data_factory(|| Ok::<_, ()>(10u32));
// };
// let mut srv = init_service(
// App::new()
// .service(web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()))
// .configure(cfg2),
// );
// let req = TestRequest::default().to_request();
// let resp = srv.call(req).await.unwrap();
// assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
// }
#[ntex_rt::test]
async fn test_external_resource() {
async fn test_configure_external_resource() {
let mut srv = init_service(
App::new()
.configure(|cfg| {
@ -325,7 +180,7 @@ mod tests {
}
#[ntex_rt::test]
async fn test_service() {
async fn test_configure_service() {
let mut srv = init_service(App::new().configure(|cfg| {
cfg.service(
web::resource("/test")

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

@ -7,7 +7,7 @@ use crate::http::{Extensions, Payload};
use super::error::{DataExtractorError, ErrorRenderer};
use super::extract::FromRequest;
use super::request::HttpRequest;
use super::httprequest::HttpRequest;
/// Application data factory
pub(crate) trait DataFactory {

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

@ -16,7 +16,7 @@ use super::HttpResponse;
#[derive(Clone, Copy, Default)]
pub struct DefaultError;
/// Generic error for error that supports `DefaultError` renderer.
/// Generic error container for errors that supports `DefaultError` renderer.
pub struct Error {
cause: Box<dyn WebResponseError<DefaultError>>,
}

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

@ -8,7 +8,7 @@ use futures::future::{ok, FutureExt, LocalBoxFuture, Ready};
use crate::http::Payload;
use super::error::ErrorRenderer;
use super::request::HttpRequest;
use super::httprequest::HttpRequest;
/// Trait implemented by types that can be extracted from request.
///
@ -258,105 +258,98 @@ tuple_from_req!(TupleFromRequest9, (0, A), (1, B), (2, C), (3, D), (4, E), (5, F
tuple_from_req!(TupleFromRequest10, (0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H), (8, I), (9, J));
}
// #[cfg(test)]
// mod tests {
// use bytes::Bytes;
// use serde_derive::Deserialize;
#[cfg(test)]
mod tests {
use bytes::Bytes;
use serde_derive::Deserialize;
// use super::*;
// use crate::http::header;
// use crate::web::error::DefaultError;
// use crate::web::test::TestRequest;
// use crate::web::types::{Form, FormConfig};
use crate::http::header;
use crate::web::error::UrlencodedError;
use crate::web::test::{from_request, TestRequest};
use crate::web::types::{Form, FormConfig};
// #[derive(Deserialize, Debug, PartialEq)]
// struct Info {
// hello: String,
// }
#[derive(Deserialize, Debug, PartialEq)]
struct Info {
hello: String,
}
// fn extract<T: FromRequest<DefaultError>>(
// extract: T,
// ) -> impl FromRequest<DefaultError, Error = T::Error> {
// extract
// }
#[ntex_rt::test]
async fn test_option() {
let (req, mut pl) = TestRequest::with_header(
header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
)
.data(FormConfig::default().limit(4096))
.to_http_parts();
// #[ntex_rt::test]
// async fn test_option() {
// let (req, mut pl) = TestRequest::with_header(
// header::CONTENT_TYPE,
// "application/x-www-form-urlencoded",
// )
// .data(FormConfig::default().limit(4096))
// .to_http_parts();
let r = from_request::<Option<Form<Info>>>(&req, &mut pl)
.await
.unwrap();
assert_eq!(r, None);
// let r = Option::<Form<Info>>::from_request(&req, &mut pl)
// .await
// .unwrap();
// assert_eq!(r, None);
let (req, mut pl) = TestRequest::with_header(
header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
)
.header(header::CONTENT_LENGTH, "9")
.set_payload(Bytes::from_static(b"hello=world"))
.to_http_parts();
// let (req, mut pl) = TestRequest::with_header(
// header::CONTENT_TYPE,
// "application/x-www-form-urlencoded",
// )
// .header(header::CONTENT_LENGTH, "9")
// .set_payload(Bytes::from_static(b"hello=world"))
// .to_http_parts();
let r = from_request::<Option<Form<Info>>>(&req, &mut pl)
.await
.unwrap();
assert_eq!(
r,
Some(Form(Info {
hello: "world".into()
}))
);
// let r = Option::<Form<Info>>::from_request(&req, &mut pl)
// .await
// .unwrap();
// assert_eq!(
// r,
// Some(Form(Info {
// hello: "world".into()
// }))
// );
let (req, mut pl) = TestRequest::with_header(
header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
)
.header(header::CONTENT_LENGTH, "9")
.set_payload(Bytes::from_static(b"bye=world"))
.to_http_parts();
// let (req, mut pl) = TestRequest::with_header(
// header::CONTENT_TYPE,
// "application/x-www-form-urlencoded",
// )
// .header(header::CONTENT_LENGTH, "9")
// .set_payload(Bytes::from_static(b"bye=world"))
// .to_http_parts();
let r = from_request::<Option<Form<Info>>>(&req, &mut pl)
.await
.unwrap();
assert_eq!(r, None);
}
// let r = Option::<Form<Info>>::from_request(&req, &mut pl)
// .await
// .unwrap();
// assert_eq!(r, None);
// }
#[ntex_rt::test]
async fn test_result() {
let (req, mut pl) = TestRequest::with_header(
header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
)
.header(header::CONTENT_LENGTH, "11")
.set_payload(Bytes::from_static(b"hello=world"))
.to_http_parts();
// #[ntex_rt::test]
// async fn test_result() {
// let (req, mut pl) = TestRequest::with_header(
// header::CONTENT_TYPE,
// "application/x-www-form-urlencoded",
// )
// .header(header::CONTENT_LENGTH, "11")
// .set_payload(Bytes::from_static(b"hello=world"))
// .to_http_parts();
let r = from_request::<Result<Form<Info>, UrlencodedError>>(&req, &mut pl)
.await
.unwrap();
assert_eq!(
r.unwrap(),
Form(Info {
hello: "world".into()
})
);
// let r: Result<Form<Info>, WebError> = FromRequest::<DefaultError>::from_request(&req, &mut pl)
// .await
// .unwrap();
// assert_eq!(
// r.unwrap(),
// Form(Info {
// hello: "world".into()
// })
// );
let (req, mut pl) = TestRequest::with_header(
header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
)
.header(header::CONTENT_LENGTH, "9")
.set_payload(Bytes::from_static(b"bye=world"))
.to_http_parts();
// let (req, mut pl) = TestRequest::with_header(
// header::CONTENT_TYPE,
// "application/x-www-form-urlencoded",
// )
// .header(header::CONTENT_LENGTH, "9")
// .set_payload(Bytes::from_static(b"bye=world"))
// .to_http_parts();
// let r: Result::<Form<Info>, WebError> = FromRequest::from_request(&req, &mut pl)
// .await
// .unwrap();
// assert!(r.is_err());
// }
// }
let r = from_request::<Result<Form<Info>, UrlencodedError>>(&req, &mut pl)
.await
.unwrap();
assert!(r.is_err());
}
}

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

@ -8,9 +8,10 @@ use pin_project::pin_project;
use super::error::ErrorRenderer;
use super::extract::FromRequest;
use super::request::HttpRequest;
use super::httprequest::HttpRequest;
use super::request::WebRequest;
use super::responder::Responder;
use super::service::{WebRequest, WebResponse};
use super::response::WebResponse;
/// Async fn handler
pub trait Handler<T, Err>: Clone + 'static

530
ntex/src/web/httprequest.rs Normal file
View file

@ -0,0 +1,530 @@
use std::cell::{Ref, RefCell, RefMut};
use std::rc::Rc;
use std::{fmt, net};
use futures::future::{ok, Ready};
use crate::http::{
Extensions, HeaderMap, HttpMessage, Message, Method, Payload, RequestHead, Uri,
Version,
};
use crate::router::Path;
use super::config::AppConfig;
use super::error::{ErrorRenderer, UrlGenerationError};
use super::extract::FromRequest;
use super::info::ConnectionInfo;
use super::rmap::ResourceMap;
#[derive(Clone)]
/// An HTTP Request
pub struct HttpRequest(pub(crate) Rc<HttpRequestInner>);
pub(crate) struct HttpRequestInner {
pub(crate) head: Message<RequestHead>,
pub(crate) path: Path<Uri>,
pub(crate) payload: Payload,
pub(crate) app_data: Rc<Extensions>,
rmap: Rc<ResourceMap>,
config: AppConfig,
pool: &'static HttpRequestPool,
}
impl HttpRequest {
#[inline]
pub(crate) fn new(
path: Path<Uri>,
head: Message<RequestHead>,
payload: Payload,
rmap: Rc<ResourceMap>,
config: AppConfig,
app_data: Rc<Extensions>,
pool: &'static HttpRequestPool,
) -> HttpRequest {
HttpRequest(Rc::new(HttpRequestInner {
head,
path,
payload,
rmap,
config,
app_data,
pool,
}))
}
}
impl HttpRequest {
/// This method returns reference to the request head
#[inline]
pub fn head(&self) -> &RequestHead {
&self.0.head
}
/// This method returns muttable reference to the request head.
/// panics if multiple references of http request exists.
#[inline]
pub(crate) fn head_mut(&mut self) -> &mut RequestHead {
&mut Rc::get_mut(&mut self.0).unwrap().head
}
/// Request's uri.
#[inline]
pub fn uri(&self) -> &Uri {
&self.head().uri
}
/// Read the Request method.
#[inline]
pub fn method(&self) -> &Method {
&self.head().method
}
/// Read the Request Version.
#[inline]
pub fn version(&self) -> Version {
self.head().version
}
#[inline]
/// Returns request's headers.
pub fn headers(&self) -> &HeaderMap {
&self.head().headers
}
/// The target path of this Request.
#[inline]
pub fn path(&self) -> &str {
self.head().uri.path()
}
/// The query string in the URL.
///
/// E.g., id=10
#[inline]
pub fn query_string(&self) -> &str {
if let Some(query) = self.uri().query().as_ref() {
query
} else {
""
}
}
/// Get a reference to the Path parameters.
///
/// Params is a container for url parameters.
/// A variable segment is specified in the form `{identifier}`,
/// where the identifier can be used later in a request handler to
/// access the matched value for that segment.
#[inline]
pub fn match_info(&self) -> &Path<Uri> {
&self.0.path
}
#[inline]
pub(crate) fn match_info_mut(&mut self) -> &mut Path<Uri> {
&mut Rc::get_mut(&mut self.0).unwrap().path
}
/// Request extensions
#[inline]
pub fn extensions(&self) -> Ref<'_, Extensions> {
self.head().extensions()
}
/// Mutable reference to a the request's extensions
#[inline]
pub fn extensions_mut(&self) -> RefMut<'_, Extensions> {
self.head().extensions_mut()
}
/// Generate url for named resource
///
/// ```rust
/// # use ntex::web::{self, App, HttpRequest, HttpResponse};
/// #
/// async fn index(req: HttpRequest) -> HttpResponse {
/// let url = req.url_for("foo", &["1", "2", "3"]); // <- generate url for "foo" resource
/// HttpResponse::Ok().into()
/// }
///
/// fn main() {
/// let app = App::new()
/// .service(web::resource("/test/{one}/{two}/{three}")
/// .name("foo") // <- set resource name, then it could be used in `url_for`
/// .route(web::get().to(index))
/// );
/// }
/// ```
pub fn url_for<U, I>(
&self,
name: &str,
elements: U,
) -> Result<url::Url, UrlGenerationError>
where
U: IntoIterator<Item = I>,
I: AsRef<str>,
{
self.0.rmap.url_for(&self, name, elements)
}
/// Generate url for named resource
///
/// This method is similar to `HttpRequest::url_for()` but it can be used
/// for urls that do not contain variable parts.
pub fn url_for_static(&self, name: &str) -> Result<url::Url, UrlGenerationError> {
const NO_PARAMS: [&str; 0] = [];
self.url_for(name, &NO_PARAMS)
}
#[inline]
/// Get a reference to a `ResourceMap` of current application.
pub fn resource_map(&self) -> &ResourceMap {
&self.0.rmap
}
/// Peer socket address
///
/// Peer address is actual socket address, if proxy is used in front of
/// actix http server, then peer address would be address of this proxy.
///
/// To get client connection information `.connection_info()` should be used.
#[inline]
pub fn peer_addr(&self) -> Option<net::SocketAddr> {
self.head().peer_addr
}
/// Get *ConnectionInfo* for the current request.
///
/// This method panics if request's extensions container is already
/// borrowed.
#[inline]
pub fn connection_info(&self) -> Ref<'_, ConnectionInfo> {
ConnectionInfo::get(self.head(), &*self.app_config())
}
/// App config
#[inline]
pub fn app_config(&self) -> &AppConfig {
&self.0.config
}
/// Get an application data object stored with `App::data` or `App::app_data`
/// methods during application configuration.
///
/// If `App::data` was used to store object, use `Data<T>`:
///
/// ```rust,ignore
/// let opt_t = req.app_data::<Data<T>>();
/// ```
pub fn app_data<T: 'static>(&self) -> Option<&T> {
if let Some(st) = self.0.app_data.get::<T>() {
Some(&st)
} else {
None
}
}
}
impl HttpMessage for HttpRequest {
#[inline]
/// Returns Request's headers.
fn message_headers(&self) -> &HeaderMap {
&self.head().headers
}
/// Request extensions
#[inline]
fn message_extensions(&self) -> Ref<'_, Extensions> {
self.0.head.extensions()
}
/// Mutable reference to a the request's extensions
#[inline]
fn message_extensions_mut(&self) -> RefMut<'_, Extensions> {
self.0.head.extensions_mut()
}
}
impl Drop for HttpRequest {
fn drop(&mut self) {
if Rc::strong_count(&self.0) == 1 {
let v = &mut self.0.pool.0.borrow_mut();
if v.len() < 128 {
self.extensions_mut().clear();
v.push(self.0.clone());
}
}
}
}
/// It is possible to get `HttpRequest` as an extractor handler parameter
///
/// ## Example
///
/// ```rust
/// use ntex::web::{self, App, HttpRequest};
/// use serde_derive::Deserialize;
///
/// /// extract `Thing` from request
/// async fn index(req: HttpRequest) -> String {
/// format!("Got thing: {:?}", req)
/// }
///
/// fn main() {
/// let app = App::new().service(
/// web::resource("/users/{first}").route(
/// web::get().to(index))
/// );
/// }
/// ```
impl<Err: ErrorRenderer> FromRequest<Err> for HttpRequest {
type Error = Err::Container;
type Future = Ready<Result<Self, Self::Error>>;
#[inline]
fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
ok(req.clone())
}
}
impl fmt::Debug for HttpRequest {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
writeln!(
f,
"\nHttpRequest {:?} {}:{}",
self.0.head.version,
self.0.head.method,
self.path()
)?;
if !self.query_string().is_empty() {
writeln!(f, " query: ?{:?}", self.query_string())?;
}
if !self.match_info().is_empty() {
writeln!(f, " params: {:?}", self.match_info())?;
}
writeln!(f, " headers:")?;
for (key, val) in self.headers().iter() {
writeln!(f, " {:?}: {:?}", key, val)?;
}
Ok(())
}
}
/// Request's objects pool
pub(crate) struct HttpRequestPool(RefCell<Vec<Rc<HttpRequestInner>>>);
impl HttpRequestPool {
pub(crate) fn create() -> &'static HttpRequestPool {
let pool = HttpRequestPool(RefCell::new(Vec::with_capacity(128)));
Box::leak(Box::new(pool))
}
/// Get message from the pool
#[inline]
pub(crate) fn get_request(&self) -> Option<HttpRequest> {
if let Some(inner) = self.0.borrow_mut().pop() {
Some(HttpRequest(inner))
} else {
None
}
}
pub(crate) fn clear(&self) {
self.0.borrow_mut().clear()
}
}
#[cfg(test)]
mod tests {
use futures::future::ready;
use super::*;
use crate::http::{header, StatusCode};
use crate::router::ResourceDef;
use crate::web::dev::ResourceMap;
use crate::web::test::{call_service, init_service, TestRequest};
use crate::web::{self, App, HttpResponse};
#[test]
fn test_debug() {
let req =
TestRequest::with_header("content-type", "text/plain").to_http_request();
let dbg = format!("{:?}", req);
assert!(dbg.contains("HttpRequest"));
}
#[cfg(feature = "cookie")]
#[test]
fn test_no_request_cookies() {
let req = TestRequest::default().to_http_request();
assert!(req.cookies().unwrap().is_empty());
}
#[cfg(feature = "cookie")]
#[test]
fn test_request_cookies() {
let req = TestRequest::default()
.header(header::COOKIE, "cookie1=value1")
.header(header::COOKIE, "cookie2=value2")
.to_http_request();
{
let cookies = req.cookies().unwrap();
assert_eq!(cookies.len(), 2);
assert_eq!(cookies[0].name(), "cookie2");
assert_eq!(cookies[0].value(), "value2");
assert_eq!(cookies[1].name(), "cookie1");
assert_eq!(cookies[1].value(), "value1");
}
let cookie = req.cookie("cookie1");
assert!(cookie.is_some());
let cookie = cookie.unwrap();
assert_eq!(cookie.name(), "cookie1");
assert_eq!(cookie.value(), "value1");
let cookie = req.cookie("cookie-unknown");
assert!(cookie.is_none());
}
#[test]
fn test_request_query() {
let req = TestRequest::with_uri("/?id=test").to_http_request();
assert_eq!(req.query_string(), "id=test");
}
#[test]
fn test_url_for() {
let mut res = ResourceDef::new("/user/{name}.{ext}");
*res.name_mut() = "index".to_string();
let mut rmap = ResourceMap::new(ResourceDef::new(""));
rmap.add(&mut res, None);
//assert!(rmap.has_resource("/user/test.html"));
//assert!(!rmap.has_resource("/test/unknown"));
let req = TestRequest::with_header(header::HOST, "www.rust-lang.org")
.rmap(rmap)
.to_http_request();
assert_eq!(
req.url_for("unknown", &["test"]),
Err(UrlGenerationError::ResourceNotFound)
);
assert_eq!(
req.url_for("index", &["test"]),
Err(UrlGenerationError::NotEnoughElements)
);
let url = req.url_for("index", &["test", "html"]);
assert_eq!(
url.ok().unwrap().as_str(),
"http://www.rust-lang.org/user/test.html"
);
}
#[test]
fn test_url_for_static() {
let mut rdef = ResourceDef::new("/index.html");
*rdef.name_mut() = "index".to_string();
let mut rmap = ResourceMap::new(ResourceDef::new(""));
rmap.add(&mut rdef, None);
// assert!(rmap.has_resource("/index.html"));
let req = TestRequest::with_uri("/test")
.header(header::HOST, "www.rust-lang.org")
.rmap(rmap)
.to_http_request();
let url = req.url_for_static("index");
assert_eq!(
url.ok().unwrap().as_str(),
"http://www.rust-lang.org/index.html"
);
}
#[test]
fn test_url_for_external() {
let mut rdef = ResourceDef::new("https://youtube.com/watch/{video_id}");
*rdef.name_mut() = "youtube".to_string();
let mut rmap = ResourceMap::new(ResourceDef::new(""));
rmap.add(&mut rdef, None);
// assert!(rmap.has_resource("https://youtube.com/watch/unknown"));
let req = TestRequest::default().rmap(rmap).to_http_request();
let url = req.url_for("youtube", &["oHg5SJYRHA0"]);
assert_eq!(
url.ok().unwrap().as_str(),
"https://youtube.com/watch/oHg5SJYRHA0"
);
}
#[ntex_rt::test]
async fn test_data() {
let mut srv = init_service(App::new().app_data(10usize).service(
web::resource("/").to(|req: HttpRequest| {
ready(if req.app_data::<usize>().is_some() {
HttpResponse::Ok()
} else {
HttpResponse::BadRequest()
})
}),
))
.await;
let req = TestRequest::default().to_request();
let resp = call_service(&mut srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
let mut srv = init_service(App::new().app_data(10u32).service(
web::resource("/").to(|req: HttpRequest| async move {
if req.app_data::<usize>().is_some() {
HttpResponse::Ok()
} else {
HttpResponse::BadRequest()
}
}),
))
.await;
let req = TestRequest::default().to_request();
let resp = call_service(&mut srv, req).await;
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
}
#[ntex_rt::test]
async fn test_extensions_dropped() {
struct Tracker {
dropped: bool,
}
struct Foo {
tracker: Rc<RefCell<Tracker>>,
}
impl Drop for Foo {
fn drop(&mut self) {
self.tracker.borrow_mut().dropped = true;
}
}
let tracker = Rc::new(RefCell::new(Tracker { dropped: false }));
{
let tracker2 = Rc::clone(&tracker);
let mut srv = init_service(App::new().data(10u32).service(
web::resource("/").to(move |req: HttpRequest| {
req.extensions_mut().insert(Foo {
tracker: Rc::clone(&tracker2),
});
ready(HttpResponse::Ok())
}),
))
.await;
let req = TestRequest::default().to_request();
let resp = call_service(&mut srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
}
assert!(tracker.borrow().dropped);
}
}

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

@ -14,9 +14,8 @@ use crate::http::encoding::Encoder;
use crate::http::header::{ContentEncoding, ACCEPT_ENCODING};
use crate::service::{Service, Transform};
use crate::web::dev::BodyEncoding;
use crate::web::service::{WebRequest, WebResponse};
use crate::web::ErrorRenderer;
use crate::web::dev::{WebRequest, WebResponse};
use crate::web::{BodyEncoding, ErrorRenderer};
#[derive(Debug, Clone)]
/// `Middleware` for compressing response body.

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

File diff suppressed because it is too large Load diff

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

@ -9,7 +9,7 @@ use futures::future::{ok, FutureExt, LocalBoxFuture, Ready};
use crate::http::error::HttpError;
use crate::http::header::{HeaderMap, HeaderName, HeaderValue, CONTENT_TYPE};
use crate::service::{Service, Transform};
use crate::web::service::{WebRequest, WebResponse};
use crate::web::dev::{WebRequest, WebResponse};
/// `Middleware` for setting default response headers.
///
@ -172,7 +172,7 @@ mod tests {
use super::*;
use crate::http::header::CONTENT_TYPE;
use crate::service::IntoService;
use crate::web::service::WebRequest;
use crate::web::request::WebRequest;
use crate::web::test::{ok_service, TestRequest};
use crate::web::{DefaultError, Error, HttpResponse};

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

@ -18,7 +18,7 @@ use time::OffsetDateTime;
use crate::http::body::{BodySize, MessageBody, ResponseBody};
use crate::http::header::HeaderName;
use crate::service::{Service, Transform};
use crate::web::service::{WebRequest, WebResponse};
use crate::web::dev::{WebRequest, WebResponse};
use crate::web::HttpResponse;
/// `Middleware` for logging request and response info to the terminal.

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

@ -71,11 +71,13 @@ mod error_default;
mod extract;
pub mod guard;
mod handler;
mod httprequest;
mod info;
pub mod middleware;
mod request;
mod resource;
mod responder;
mod response;
mod rmap;
mod route;
mod scope;
@ -94,13 +96,12 @@ pub use self::data::Data;
pub use self::error::{DefaultError, Error, ErrorRenderer, WebResponseError};
pub use self::extract::FromRequest;
pub use self::handler::Handler;
pub use self::request::HttpRequest;
pub use self::httprequest::HttpRequest;
pub use self::resource::Resource;
pub use self::responder::{Either, Responder};
pub use self::route::Route;
pub use self::scope::Scope;
pub use self::server::HttpServer;
pub use self::service::WebService;
pub use self::util::*;
pub mod dev {
@ -110,11 +111,13 @@ pub mod dev {
//! traits by adding a glob import to the top of ntex::web heavy modules:
use super::Handler;
pub use crate::web::config::{AppConfig, AppService};
pub use crate::web::config::AppConfig;
pub use crate::web::info::ConnectionInfo;
pub use crate::web::request::WebRequest;
pub use crate::web::response::WebResponse;
pub use crate::web::rmap::ResourceMap;
pub use crate::web::service::{
HttpServiceFactory, WebRequest, WebResponse, WebService,
WebServiceAdapter, WebServiceConfig, WebServiceFactory,
};
pub(crate) fn insert_slesh(mut patterns: Vec<String>) -> Vec<String> {
@ -126,50 +129,6 @@ pub mod dev {
patterns
}
use crate::http::header::ContentEncoding;
use crate::http::{Response, ResponseBuilder};
struct Enc(ContentEncoding);
/// Helper trait that allows to set specific encoding for response.
pub trait BodyEncoding {
/// Get content encoding
fn get_encoding(&self) -> Option<ContentEncoding>;
/// Set content encoding
fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self;
}
impl BodyEncoding for ResponseBuilder {
fn get_encoding(&self) -> Option<ContentEncoding> {
if let Some(ref enc) = self.extensions().get::<Enc>() {
Some(enc.0)
} else {
None
}
}
fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self {
self.extensions_mut().insert(Enc(encoding));
self
}
}
impl<B> BodyEncoding for Response<B> {
fn get_encoding(&self) -> Option<ContentEncoding> {
if let Some(ref enc) = self.extensions().get::<Enc>() {
Some(enc.0)
} else {
None
}
}
fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self {
self.extensions_mut().insert(Enc(encoding));
self
}
}
#[doc(hidden)]
#[inline(always)]
pub fn __assert_extractor<Err, T>()

556
ntex/src/web/request.rs
View file

@ -1,70 +1,97 @@
use std::cell::{Ref, RefCell, RefMut};
use std::cell::{Ref, RefMut};
use std::marker::PhantomData;
use std::rc::Rc;
use std::{fmt, net};
use futures::future::{ok, Ready};
use crate::http::{
Extensions, HeaderMap, HttpMessage, Message, Method, Payload, RequestHead, Uri,
Version,
Extensions, HeaderMap, HttpMessage, Method, Payload, PayloadStream, RequestHead,
Response, Uri, Version,
};
use crate::router::Path;
use crate::router::{Path, Resource};
use super::config::AppConfig;
use super::error::{ErrorRenderer, UrlGenerationError};
use super::extract::FromRequest;
use super::data::Data;
use super::error::ErrorRenderer;
use super::httprequest::HttpRequest;
use super::info::ConnectionInfo;
use super::response::WebResponse;
use super::rmap::ResourceMap;
#[derive(Clone)]
/// An HTTP Request
pub struct HttpRequest(pub(crate) Rc<HttpRequestInner>);
pub(crate) struct HttpRequestInner {
pub(crate) head: Message<RequestHead>,
pub(crate) path: Path<Uri>,
pub(crate) payload: Payload,
pub(crate) app_data: Rc<Extensions>,
rmap: Rc<ResourceMap>,
config: AppConfig,
pool: &'static HttpRequestPool,
/// An service http request
///
/// WebRequest allows mutable access to request's internal structures
pub struct WebRequest<Err> {
req: HttpRequest,
_t: PhantomData<Err>,
}
impl HttpRequest {
impl<Err: ErrorRenderer> WebRequest<Err> {
/// Create web response for error
#[inline]
pub(crate) fn new(
path: Path<Uri>,
head: Message<RequestHead>,
payload: Payload,
rmap: Rc<ResourceMap>,
config: AppConfig,
app_data: Rc<Extensions>,
pool: &'static HttpRequestPool,
) -> HttpRequest {
HttpRequest(Rc::new(HttpRequestInner {
head,
path,
payload,
rmap,
config,
app_data,
pool,
}))
pub fn error_response<B, E: Into<Err::Container>>(self, err: E) -> WebResponse<B> {
WebResponse::from_err::<Err, E>(err, self.req)
}
}
impl HttpRequest {
impl<Err> WebRequest<Err> {
/// Construct web request
pub(crate) fn new(req: HttpRequest) -> Self {
WebRequest {
req,
_t: PhantomData,
}
}
/// Deconstruct request into parts
pub fn into_parts(mut self) -> (HttpRequest, Payload) {
let pl = Rc::get_mut(&mut (self.req).0).unwrap().payload.take();
(self.req, pl)
}
/// Construct request from parts.
///
/// `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(WebRequest::new(req))
} else {
Err((req, pl))
}
}
/// Construct request from request.
///
/// `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(WebRequest::new(req))
} else {
Err(req)
}
}
/// Create web response
#[inline]
pub fn into_response<B, R: Into<Response<B>>>(self, res: R) -> WebResponse<B> {
WebResponse::new(self.req, res.into())
}
/// This method returns reference to the request head
#[inline]
pub fn head(&self) -> &RequestHead {
&self.0.head
&self.req.head()
}
/// This method returns muttable reference to the request head.
/// panics if multiple references of http request exists.
/// This method returns reference to the request head
#[inline]
pub(crate) fn head_mut(&mut self) -> &mut RequestHead {
&mut Rc::get_mut(&mut self.0).unwrap().head
pub fn head_mut(&mut self) -> &mut RequestHead {
self.req.head_mut()
}
/// Request's uri.
@ -91,6 +118,12 @@ impl HttpRequest {
&self.head().headers
}
#[inline]
/// Returns mutable request's headers.
pub fn headers_mut(&mut self) -> &mut HeaderMap {
&mut self.head_mut().headers
}
/// The target path of this Request.
#[inline]
pub fn path(&self) -> &str {
@ -109,6 +142,23 @@ impl HttpRequest {
}
}
/// Peer socket address
///
/// Peer address is actual socket address, if proxy is used in front of
/// actix http server, then peer address would be address of this proxy.
///
/// To get client connection information `ConnectionInfo` should be used.
#[inline]
pub fn peer_addr(&self) -> Option<net::SocketAddr> {
self.head().peer_addr
}
/// Get *ConnectionInfo* for the current request.
#[inline]
pub fn connection_info(&self) -> Ref<'_, ConnectionInfo> {
ConnectionInfo::get(self.head(), &*self.app_config())
}
/// Get a reference to the Path parameters.
///
/// Params is a container for url parameters.
@ -117,115 +167,80 @@ impl HttpRequest {
/// access the matched value for that segment.
#[inline]
pub fn match_info(&self) -> &Path<Uri> {
&self.0.path
self.req.match_info()
}
#[inline]
pub(crate) fn match_info_mut(&mut self) -> &mut Path<Uri> {
&mut Rc::get_mut(&mut self.0).unwrap().path
}
/// Request extensions
#[inline]
pub fn extensions(&self) -> Ref<'_, Extensions> {
self.head().extensions()
}
/// Mutable reference to a the request's extensions
#[inline]
pub fn extensions_mut(&self) -> RefMut<'_, Extensions> {
self.head().extensions_mut()
}
/// Generate url for named resource
///
/// ```rust
/// # use ntex::web::{self, App, HttpRequest, HttpResponse};
/// #
/// async fn index(req: HttpRequest) -> HttpResponse {
/// let url = req.url_for("foo", &["1", "2", "3"]); // <- generate url for "foo" resource
/// HttpResponse::Ok().into()
/// }
///
/// fn main() {
/// let app = App::new()
/// .service(web::resource("/test/{one}/{two}/{three}")
/// .name("foo") // <- set resource name, then it could be used in `url_for`
/// .route(web::get().to(index))
/// );
/// }
/// ```
pub fn url_for<U, I>(
&self,
name: &str,
elements: U,
) -> Result<url::Url, UrlGenerationError>
where
U: IntoIterator<Item = I>,
I: AsRef<str>,
{
self.0.rmap.url_for(&self, name, elements)
}
/// Generate url for named resource
///
/// This method is similar to `HttpRequest::url_for()` but it can be used
/// for urls that do not contain variable parts.
pub fn url_for_static(&self, name: &str) -> Result<url::Url, UrlGenerationError> {
const NO_PARAMS: [&str; 0] = [];
self.url_for(name, &NO_PARAMS)
/// Get a mutable reference to the Path parameters.
pub fn match_info_mut(&mut self) -> &mut Path<Uri> {
self.req.match_info_mut()
}
#[inline]
/// Get a reference to a `ResourceMap` of current application.
pub fn resource_map(&self) -> &ResourceMap {
&self.0.rmap
self.req.resource_map()
}
/// Peer socket address
///
/// Peer address is actual socket address, if proxy is used in front of
/// actix http server, then peer address would be address of this proxy.
///
/// To get client connection information `.connection_info()` should be used.
#[inline]
pub fn peer_addr(&self) -> Option<net::SocketAddr> {
self.head().peer_addr
}
/// Get *ConnectionInfo* for the current request.
///
/// This method panics if request's extensions container is already
/// borrowed.
#[inline]
pub fn connection_info(&self) -> Ref<'_, ConnectionInfo> {
ConnectionInfo::get(self.head(), &*self.app_config())
}
/// App config
/// Service configuration
#[inline]
pub fn app_config(&self) -> &AppConfig {
&self.0.config
self.req.app_config()
}
/// Get an application data object stored with `App::data` or `App::app_data`
/// methods during application configuration.
///
/// If `App::data` was used to store object, use `Data<T>`:
///
/// ```rust,ignore
/// let opt_t = req.app_data::<Data<T>>();
/// ```
pub fn app_data<T: 'static>(&self) -> Option<&T> {
if let Some(st) = self.0.app_data.get::<T>() {
Some(&st)
#[inline]
/// Get an application data stored with `App::data()` method during
/// application configuration.
pub fn app_data<T: 'static>(&self) -> Option<Data<T>> {
if let Some(st) = (self.req).0.app_data.get::<Data<T>>() {
Some(st.clone())
} else {
None
}
}
#[inline]
/// Get request's payload
pub fn take_payload(&mut self) -> Payload<PayloadStream> {
Rc::get_mut(&mut (self.req).0).unwrap().payload.take()
}
#[inline]
/// Set request payload.
pub fn set_payload(&mut self, payload: Payload) {
Rc::get_mut(&mut (self.req).0).unwrap().payload = payload;
}
#[doc(hidden)]
/// Set new app data container
pub fn set_data_container(&mut self, extensions: Rc<Extensions>) {
Rc::get_mut(&mut (self.req).0).unwrap().app_data = extensions;
}
/// Request extensions
#[inline]
pub fn extensions(&self) -> Ref<'_, Extensions> {
self.req.extensions()
}
/// Mutable reference to a the request's extensions
#[inline]
pub fn extensions_mut(&self) -> RefMut<'_, Extensions> {
self.req.extensions_mut()
}
}
impl HttpMessage for HttpRequest {
impl<Err> Resource<Uri> for WebRequest<Err> {
fn path(&self) -> &str {
self.match_info().path()
}
fn resource_path(&mut self) -> &mut Path<Uri> {
self.match_info_mut()
}
}
impl<Err> HttpMessage for WebRequest<Err> {
#[inline]
/// Returns Request's headers.
fn message_headers(&self) -> &HeaderMap {
@ -235,65 +250,23 @@ impl HttpMessage for HttpRequest {
/// Request extensions
#[inline]
fn message_extensions(&self) -> Ref<'_, Extensions> {
self.0.head.extensions()
self.req.extensions()
}
/// Mutable reference to a the request's extensions
#[inline]
fn message_extensions_mut(&self) -> RefMut<'_, Extensions> {
self.0.head.extensions_mut()
self.req.extensions_mut()
}
}
impl Drop for HttpRequest {
fn drop(&mut self) {
if Rc::strong_count(&self.0) == 1 {
let v = &mut self.0.pool.0.borrow_mut();
if v.len() < 128 {
self.extensions_mut().clear();
v.push(self.0.clone());
}
}
}
}
/// It is possible to get `HttpRequest` as an extractor handler parameter
///
/// ## Example
///
/// ```rust
/// use ntex::web::{self, App, HttpRequest};
/// use serde_derive::Deserialize;
///
/// /// extract `Thing` from request
/// async fn index(req: HttpRequest) -> String {
/// format!("Got thing: {:?}", req)
/// }
///
/// fn main() {
/// let app = App::new().service(
/// web::resource("/users/{first}").route(
/// web::get().to(index))
/// );
/// }
/// ```
impl<Err: ErrorRenderer> FromRequest<Err> for HttpRequest {
type Error = Err::Container;
type Future = Ready<Result<Self, Self::Error>>;
#[inline]
fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
ok(req.clone())
}
}
impl fmt::Debug for HttpRequest {
impl<Err: ErrorRenderer> fmt::Debug for WebRequest<Err> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
writeln!(
f,
"\nHttpRequest {:?} {}:{}",
self.0.head.version,
self.0.head.method,
"\nWebRequest {:?} {}:{}",
self.head().version,
self.head().method,
self.path()
)?;
if !self.query_string().is_empty() {
@ -309,222 +282,3 @@ impl fmt::Debug for HttpRequest {
Ok(())
}
}
/// Request's objects pool
pub(crate) struct HttpRequestPool(RefCell<Vec<Rc<HttpRequestInner>>>);
impl HttpRequestPool {
pub(crate) fn create() -> &'static HttpRequestPool {
let pool = HttpRequestPool(RefCell::new(Vec::with_capacity(128)));
Box::leak(Box::new(pool))
}
/// Get message from the pool
#[inline]
pub(crate) fn get_request(&self) -> Option<HttpRequest> {
if let Some(inner) = self.0.borrow_mut().pop() {
Some(HttpRequest(inner))
} else {
None
}
}
pub(crate) fn clear(&self) {
self.0.borrow_mut().clear()
}
}
#[cfg(test)]
mod tests {
use futures::future::ready;
use super::*;
use crate::http::{header, StatusCode};
use crate::router::ResourceDef;
use crate::web::dev::ResourceMap;
use crate::web::test::{call_service, init_service, TestRequest};
use crate::web::{self, App, HttpResponse};
#[test]
fn test_debug() {
let req =
TestRequest::with_header("content-type", "text/plain").to_http_request();
let dbg = format!("{:?}", req);
assert!(dbg.contains("HttpRequest"));
}
#[cfg(feature = "cookie")]
#[test]
fn test_no_request_cookies() {
let req = TestRequest::default().to_http_request();
assert!(req.cookies().unwrap().is_empty());
}
#[cfg(feature = "cookie")]
#[test]
fn test_request_cookies() {
let req = TestRequest::default()
.header(header::COOKIE, "cookie1=value1")
.header(header::COOKIE, "cookie2=value2")
.to_http_request();
{
let cookies = req.cookies().unwrap();
assert_eq!(cookies.len(), 2);
assert_eq!(cookies[0].name(), "cookie2");
assert_eq!(cookies[0].value(), "value2");
assert_eq!(cookies[1].name(), "cookie1");
assert_eq!(cookies[1].value(), "value1");
}
let cookie = req.cookie("cookie1");
assert!(cookie.is_some());
let cookie = cookie.unwrap();
assert_eq!(cookie.name(), "cookie1");
assert_eq!(cookie.value(), "value1");
let cookie = req.cookie("cookie-unknown");
assert!(cookie.is_none());
}
#[test]
fn test_request_query() {
let req = TestRequest::with_uri("/?id=test").to_http_request();
assert_eq!(req.query_string(), "id=test");
}
#[test]
fn test_url_for() {
let mut res = ResourceDef::new("/user/{name}.{ext}");
*res.name_mut() = "index".to_string();
let mut rmap = ResourceMap::new(ResourceDef::new(""));
rmap.add(&mut res, None);
//assert!(rmap.has_resource("/user/test.html"));
//assert!(!rmap.has_resource("/test/unknown"));
let req = TestRequest::with_header(header::HOST, "www.rust-lang.org")
.rmap(rmap)
.to_http_request();
assert_eq!(
req.url_for("unknown", &["test"]),
Err(UrlGenerationError::ResourceNotFound)
);
assert_eq!(
req.url_for("index", &["test"]),
Err(UrlGenerationError::NotEnoughElements)
);
let url = req.url_for("index", &["test", "html"]);
assert_eq!(
url.ok().unwrap().as_str(),
"http://www.rust-lang.org/user/test.html"
);
}
#[test]
fn test_url_for_static() {
let mut rdef = ResourceDef::new("/index.html");
*rdef.name_mut() = "index".to_string();
let mut rmap = ResourceMap::new(ResourceDef::new(""));
rmap.add(&mut rdef, None);
// assert!(rmap.has_resource("/index.html"));
let req = TestRequest::with_uri("/test")
.header(header::HOST, "www.rust-lang.org")
.rmap(rmap)
.to_http_request();
let url = req.url_for_static("index");
assert_eq!(
url.ok().unwrap().as_str(),
"http://www.rust-lang.org/index.html"
);
}
#[test]
fn test_url_for_external() {
let mut rdef = ResourceDef::new("https://youtube.com/watch/{video_id}");
*rdef.name_mut() = "youtube".to_string();
let mut rmap = ResourceMap::new(ResourceDef::new(""));
rmap.add(&mut rdef, None);
// assert!(rmap.has_resource("https://youtube.com/watch/unknown"));
let req = TestRequest::default().rmap(rmap).to_http_request();
let url = req.url_for("youtube", &["oHg5SJYRHA0"]);
assert_eq!(
url.ok().unwrap().as_str(),
"https://youtube.com/watch/oHg5SJYRHA0"
);
}
#[ntex_rt::test]
async fn test_data() {
let mut srv = init_service(App::new().app_data(10usize).service(
web::resource("/").to(|req: HttpRequest| {
ready(if req.app_data::<usize>().is_some() {
HttpResponse::Ok()
} else {
HttpResponse::BadRequest()
})
}),
))
.await;
let req = TestRequest::default().to_request();
let resp = call_service(&mut srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
let mut srv = init_service(App::new().app_data(10u32).service(
web::resource("/").to(|req: HttpRequest| async move {
if req.app_data::<usize>().is_some() {
HttpResponse::Ok()
} else {
HttpResponse::BadRequest()
}
}),
))
.await;
let req = TestRequest::default().to_request();
let resp = call_service(&mut srv, req).await;
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
}
#[ntex_rt::test]
async fn test_extensions_dropped() {
struct Tracker {
dropped: bool,
}
struct Foo {
tracker: Rc<RefCell<Tracker>>,
}
impl Drop for Foo {
fn drop(&mut self) {
self.tracker.borrow_mut().dropped = true;
}
}
let tracker = Rc::new(RefCell::new(Tracker { dropped: false }));
{
let tracker2 = Rc::clone(&tracker);
let mut srv = init_service(App::new().data(10u32).service(
web::resource("/").to(move |req: HttpRequest| {
req.extensions_mut().insert(Foo {
tracker: Rc::clone(&tracker2),
});
ready(HttpResponse::Ok())
}),
))
.await;
let req = TestRequest::default().to_request();
let resp = call_service(&mut srv, req).await;
assert_eq!(resp.status(), StatusCode::OK);
}
assert!(tracker.borrow().dropped);
}
}

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

@ -15,14 +15,15 @@ use crate::service::{
};
use super::data::Data;
use super::dev::{insert_slesh, AppService, HttpServiceFactory};
use super::dev::{insert_slesh, WebServiceConfig, WebServiceFactory};
use super::error::ErrorRenderer;
use super::extract::FromRequest;
use super::guard::Guard;
use super::handler::Handler;
use super::request::WebRequest;
use super::responder::Responder;
use super::response::WebResponse;
use super::route::{Route, RouteService};
use super::service::{WebRequest, WebResponse};
type HttpService<Err: ErrorRenderer> =
BoxService<WebRequest<Err>, WebResponse, Err::Container>;
@ -369,7 +370,7 @@ where
}
}
impl<Err, T> HttpServiceFactory<Err> for Resource<Err, T>
impl<Err, T> WebServiceFactory<Err> for Resource<Err, T>
where
T: ServiceFactory<
Config = (),
@ -380,7 +381,7 @@ where
> + 'static,
Err: ErrorRenderer,
{
fn register(mut self, config: &mut AppService<Err>) {
fn register(mut self, config: &mut WebServiceConfig<Err>) {
let guards = if self.guards.is_empty() {
None
} else {
@ -563,7 +564,7 @@ mod tests {
use crate::http::{Method, StatusCode};
use crate::rt::time::delay_for;
use crate::web::middleware::DefaultHeaders;
use crate::web::service::WebRequest;
use crate::web::request::WebRequest;
use crate::web::test::{call_service, init_service, TestRequest};
use crate::web::{self, guard, App, DefaultError, Error, HttpResponse};
use crate::Service;

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

@ -14,7 +14,7 @@ use crate::http::header::{HeaderMap, HeaderName, IntoHeaderValue};
use crate::http::{Response, ResponseBuilder, StatusCode};
use super::error::{DefaultError, ErrorRenderer, InternalError, WebResponseError};
use super::request::HttpRequest;
use super::httprequest::HttpRequest;
/// Trait implemented by types that can be converted to a http response.
///

153
ntex/src/web/response.rs Normal file
View file

@ -0,0 +1,153 @@
use std::fmt;
use crate::http::body::{Body, MessageBody, ResponseBody};
use crate::http::{HeaderMap, Response, ResponseHead, StatusCode};
use super::error::ErrorRenderer;
use super::httprequest::HttpRequest;
/// An service http response
pub struct WebResponse<B = Body> {
request: HttpRequest,
response: Response<B>,
}
impl<B> WebResponse<B> {
/// Create web response instance
pub fn new(request: HttpRequest, response: Response<B>) -> Self {
WebResponse { request, response }
}
/// Create web response from the error
pub fn from_err<Err: ErrorRenderer, E: Into<Err::Container>>(
err: E,
request: HttpRequest,
) -> Self {
use crate::http::error::ResponseError;
let err = err.into();
let res: Response = err.error_response();
if res.head().status == StatusCode::INTERNAL_SERVER_ERROR {
log::error!("Internal Server Error: {:?}", err);
} else {
log::debug!("Error in response: {:?}", err);
}
WebResponse {
request,
response: res.into_body(),
}
}
/// Create web response for error
#[inline]
pub fn error_response<Err: ErrorRenderer, E: Into<Err::Container>>(
self,
err: E,
) -> Self {
Self::from_err::<Err, E>(err, self.request)
}
/// Create web response
#[inline]
pub fn into_response<B1>(self, response: Response<B1>) -> WebResponse<B1> {
WebResponse::new(self.request, response)
}
/// Get reference to original request
#[inline]
pub fn request(&self) -> &HttpRequest {
&self.request
}
/// Get reference to response
#[inline]
pub fn response(&self) -> &Response<B> {
&self.response
}
/// Get mutable reference to response
#[inline]
pub fn response_mut(&mut self) -> &mut Response<B> {
&mut self.response
}
/// Get the response status code
#[inline]
pub fn status(&self) -> StatusCode {
self.response.status()
}
#[inline]
/// Returns response's headers.
pub fn headers(&self) -> &HeaderMap {
self.response.headers()
}
#[inline]
/// Returns mutable response's headers.
pub fn headers_mut(&mut self) -> &mut HeaderMap {
self.response.headers_mut()
}
/// Execute closure and in case of error convert it to response.
pub fn checked_expr<F, E, Err>(mut self, f: F) -> Self
where
F: FnOnce(&mut Self) -> Result<(), E>,
E: Into<Err::Container>,
Err: ErrorRenderer,
{
match f(&mut self) {
Ok(_) => self,
Err(err) => {
let res: Response = err.into().into();
WebResponse::new(self.request, res.into_body())
}
}
}
/// Extract response body
pub fn take_body(&mut self) -> ResponseBody<B> {
self.response.take_body()
}
}
impl<B> WebResponse<B> {
/// Set a new body
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);
WebResponse {
response,
request: self.request,
}
}
}
impl<B> Into<Response<B>> for WebResponse<B> {
fn into(self) -> Response<B> {
self.response
}
}
impl<B: MessageBody> fmt::Debug for WebResponse<B> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let res = writeln!(
f,
"\nWebResponse {:?} {}{}",
self.response.head().version,
self.response.head().status,
self.response.head().reason.unwrap_or(""),
);
let _ = writeln!(f, " headers:");
for (key, val) in self.response.head().headers.iter() {
let _ = writeln!(f, " {:?}: {:?}", key, val);
}
let _ = writeln!(f, " body: {:?}", self.response.body().size());
res
}
}

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

@ -6,7 +6,7 @@ use url::Url;
use crate::router::ResourceDef;
use crate::web::error::UrlGenerationError;
use crate::web::request::HttpRequest;
use crate::web::httprequest::HttpRequest;
#[derive(Clone, Debug)]
pub struct ResourceMap {

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

@ -12,8 +12,9 @@ use super::error_default::DefaultError;
use super::extract::FromRequest;
use super::guard::{self, Guard};
use super::handler::{Handler, HandlerFn, HandlerWrapper};
use super::request::WebRequest;
use super::responder::Responder;
use super::service::{WebRequest, WebResponse};
use super::response::WebResponse;
use super::HttpResponse;
/// Resource route definition

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

@ -15,15 +15,15 @@ use crate::service::{
use super::config::ServiceConfig;
use super::data::Data;
use super::dev::{AppService, HttpServiceFactory};
use super::dev::{WebServiceConfig, WebServiceFactory};
use super::error::ErrorRenderer;
use super::guard::Guard;
use super::request::WebRequest;
use super::resource::Resource;
use super::response::WebResponse;
use super::rmap::ResourceMap;
use super::route::Route;
use super::service::{
AppServiceFactory, ServiceFactoryWrapper, WebRequest, WebResponse,
};
use super::service::{AppServiceFactory, ServiceFactoryWrapper};
type Guards = Vec<Box<dyn Guard>>;
type HttpService<Err: ErrorRenderer> =
@ -245,7 +245,7 @@ where
/// ```
pub fn service<F>(mut self, factory: F) -> Self
where
F: HttpServiceFactory<Err> + 'static,
F: WebServiceFactory<Err> + 'static,
{
self.services
.push(Box::new(ServiceFactoryWrapper::new(factory)));
@ -410,7 +410,7 @@ where
}
}
impl<Err, T> HttpServiceFactory<Err> for Scope<Err, T>
impl<Err, T> WebServiceFactory<Err> for Scope<Err, T>
where
T: ServiceFactory<
Config = (),
@ -421,7 +421,7 @@ where
> + 'static,
Err: ErrorRenderer,
{
fn register(mut self, config: &mut AppService<Err>) {
fn register(mut self, config: &mut WebServiceConfig<Err>) {
// update default resource if needed
if self.default.borrow().is_none() {
*self.default.borrow_mut() = Some(config.default_service());
@ -685,7 +685,7 @@ mod tests {
use crate::http::{Method, StatusCode};
use crate::service::Service;
use crate::web::middleware::DefaultHeaders;
use crate::web::service::WebRequest;
use crate::web::request::WebRequest;
use crate::web::test::{call_service, init_service, read_body, TestRequest};
use crate::web::DefaultError;
use crate::web::{self, guard, App, HttpRequest, HttpResponse};

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

@ -1,31 +1,24 @@
use std::cell::{Ref, RefMut};
use std::marker::PhantomData;
use std::rc::Rc;
use std::{fmt, net};
use crate::http::body::{Body, MessageBody, ResponseBody};
use crate::http::{
Extensions, HeaderMap, HttpMessage, Method, Payload, PayloadStream, RequestHead,
Response, ResponseHead, StatusCode, Uri, Version,
};
use crate::router::{IntoPattern, Path, Resource, ResourceDef};
use crate::{IntoServiceFactory, ServiceFactory};
use crate::http::Extensions;
use crate::router::{IntoPattern, ResourceDef};
use crate::service::{boxed, IntoServiceFactory, ServiceFactory};
use super::config::{AppConfig, AppService};
use super::data::Data;
use super::config::AppConfig;
use super::data::DataFactory;
use super::dev::insert_slesh;
use super::error::ErrorRenderer;
use super::guard::Guard;
use super::info::ConnectionInfo;
use super::request::HttpRequest;
use super::request::WebRequest;
use super::response::WebResponse;
use super::rmap::ResourceMap;
pub trait HttpServiceFactory<Err: ErrorRenderer> {
fn register(self, config: &mut AppService<Err>);
pub trait WebServiceFactory<Err: ErrorRenderer> {
fn register(self, config: &mut WebServiceConfig<Err>);
}
pub(super) trait AppServiceFactory<Err: ErrorRenderer> {
fn register(&mut self, config: &mut AppService<Err>);
fn register(&mut self, config: &mut WebServiceConfig<Err>);
}
pub(super) struct ServiceFactoryWrapper<T> {
@ -42,437 +35,148 @@ impl<T> ServiceFactoryWrapper<T> {
impl<T, Err> AppServiceFactory<Err> for ServiceFactoryWrapper<T>
where
T: HttpServiceFactory<Err>,
T: WebServiceFactory<Err>,
Err: ErrorRenderer,
{
fn register(&mut self, config: &mut AppService<Err>) {
fn register(&mut self, config: &mut WebServiceConfig<Err>) {
if let Some(item) = self.factory.take() {
item.register(config)
}
}
}
/// An service http request
///
/// WebRequest allows mutable access to request's internal structures
pub struct WebRequest<Err> {
req: HttpRequest,
_t: PhantomData<Err>,
type Guards = Vec<Box<dyn Guard>>;
type HttpServiceFactory<Err: ErrorRenderer> =
boxed::BoxServiceFactory<(), WebRequest<Err>, WebResponse, Err::Container, ()>;
/// Application service configuration
pub struct WebServiceConfig<Err: ErrorRenderer> {
config: AppConfig,
root: bool,
default: Rc<HttpServiceFactory<Err>>,
services: Vec<(
ResourceDef,
HttpServiceFactory<Err>,
Option<Guards>,
Option<Rc<ResourceMap>>,
)>,
service_data: Rc<Vec<Box<dyn DataFactory>>>,
}
impl<Err: ErrorRenderer> WebRequest<Err> {
/// Create web response for error
#[inline]
pub fn error_response<B, E: Into<Err::Container>>(self, err: E) -> WebResponse<B> {
WebResponse::from_err::<Err, E>(err, self.req)
}
}
impl<Err> WebRequest<Err> {
/// Construct web request
pub(crate) fn new(req: HttpRequest) -> Self {
WebRequest {
req,
_t: PhantomData,
impl<Err: ErrorRenderer> WebServiceConfig<Err> {
/// Crate server settings instance
pub(crate) fn new(
config: AppConfig,
default: Rc<HttpServiceFactory<Err>>,
service_data: Rc<Vec<Box<dyn DataFactory>>>,
) -> Self {
WebServiceConfig {
config,
default,
service_data,
root: true,
services: Vec::new(),
}
}
/// Deconstruct request into parts
pub fn into_parts(mut self) -> (HttpRequest, Payload) {
let pl = Rc::get_mut(&mut (self.req).0).unwrap().payload.take();
(self.req, pl)
/// Check if root is beeing configured
pub fn is_root(&self) -> bool {
self.root
}
/// Construct request from parts.
///
/// `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(WebRequest::new(req))
} else {
Err((req, pl))
pub(crate) fn into_services(
self,
) -> (
AppConfig,
Vec<(
ResourceDef,
HttpServiceFactory<Err>,
Option<Guards>,
Option<Rc<ResourceMap>>,
)>,
) {
(self.config, self.services)
}
pub(crate) fn clone_config(&self) -> Self {
WebServiceConfig {
config: self.config.clone(),
default: self.default.clone(),
services: Vec::new(),
root: false,
service_data: self.service_data.clone(),
}
}
/// Construct request from request.
///
/// `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(WebRequest::new(req))
} else {
Err(req)
}
}
/// Create web response
#[inline]
pub fn into_response<B, R: Into<Response<B>>>(self, res: R) -> WebResponse<B> {
WebResponse::new(self.req, res.into())
}
/// This method returns reference to the request head
#[inline]
pub fn head(&self) -> &RequestHead {
&self.req.head()
}
/// This method returns reference to the request head
#[inline]
pub fn head_mut(&mut self) -> &mut RequestHead {
self.req.head_mut()
}
/// Request's uri.
#[inline]
pub fn uri(&self) -> &Uri {
&self.head().uri
}
/// Read the Request method.
#[inline]
pub fn method(&self) -> &Method {
&self.head().method
}
/// Read the Request Version.
#[inline]
pub fn version(&self) -> Version {
self.head().version
}
#[inline]
/// Returns request's headers.
pub fn headers(&self) -> &HeaderMap {
&self.head().headers
}
#[inline]
/// Returns mutable request's headers.
pub fn headers_mut(&mut self) -> &mut HeaderMap {
&mut self.head_mut().headers
}
/// The target path of this Request.
#[inline]
pub fn path(&self) -> &str {
self.head().uri.path()
}
/// The query string in the URL.
///
/// E.g., id=10
#[inline]
pub fn query_string(&self) -> &str {
if let Some(query) = self.uri().query().as_ref() {
query
} else {
""
}
}
/// Peer socket address
///
/// Peer address is actual socket address, if proxy is used in front of
/// actix http server, then peer address would be address of this proxy.
///
/// To get client connection information `ConnectionInfo` should be used.
#[inline]
pub fn peer_addr(&self) -> Option<net::SocketAddr> {
self.head().peer_addr
}
/// Get *ConnectionInfo* for the current request.
#[inline]
pub fn connection_info(&self) -> Ref<'_, ConnectionInfo> {
ConnectionInfo::get(self.head(), &*self.app_config())
}
/// Get a reference to the Path parameters.
///
/// Params is a container for url parameters.
/// A variable segment is specified in the form `{identifier}`,
/// where the identifier can be used later in a request handler to
/// access the matched value for that segment.
#[inline]
pub fn match_info(&self) -> &Path<Uri> {
self.req.match_info()
}
#[inline]
/// Get a mutable reference to the Path parameters.
pub fn match_info_mut(&mut self) -> &mut Path<Uri> {
self.req.match_info_mut()
}
#[inline]
/// Get a reference to a `ResourceMap` of current application.
pub fn resource_map(&self) -> &ResourceMap {
self.req.resource_map()
}
/// Service configuration
#[inline]
pub fn app_config(&self) -> &AppConfig {
self.req.app_config()
pub fn config(&self) -> &AppConfig {
&self.config
}
#[inline]
/// Get an application data stored with `App::data()` method during
/// application configuration.
pub fn app_data<T: 'static>(&self) -> Option<Data<T>> {
if let Some(st) = (self.req).0.app_data.get::<Data<T>>() {
Some(st.clone())
} else {
None
/// Default resource
pub fn default_service(&self) -> Rc<HttpServiceFactory<Err>> {
self.default.clone()
}
/// Set global route data
pub fn set_service_data(&self, extensions: &mut Extensions) -> bool {
for f in self.service_data.iter() {
f.create(extensions);
}
!self.service_data.is_empty()
}
#[inline]
/// Get request's payload
pub fn take_payload(&mut self) -> Payload<PayloadStream> {
Rc::get_mut(&mut (self.req).0).unwrap().payload.take()
}
#[inline]
/// Set request payload.
pub fn set_payload(&mut self, payload: Payload) {
Rc::get_mut(&mut (self.req).0).unwrap().payload = payload;
}
#[doc(hidden)]
/// Set new app data container
pub fn set_data_container(&mut self, extensions: Rc<Extensions>) {
Rc::get_mut(&mut (self.req).0).unwrap().app_data = extensions;
}
/// Request extensions
#[inline]
pub fn extensions(&self) -> Ref<'_, Extensions> {
self.req.extensions()
}
/// Mutable reference to a the request's extensions
#[inline]
pub fn extensions_mut(&self) -> RefMut<'_, Extensions> {
self.req.extensions_mut()
}
}
impl<Err> Resource<Uri> for WebRequest<Err> {
fn path(&self) -> &str {
self.match_info().path()
}
fn resource_path(&mut self) -> &mut Path<Uri> {
self.match_info_mut()
}
}
impl<Err> HttpMessage for WebRequest<Err> {
#[inline]
/// Returns Request's headers.
fn message_headers(&self) -> &HeaderMap {
&self.head().headers
}
/// Request extensions
#[inline]
fn message_extensions(&self) -> Ref<'_, Extensions> {
self.req.extensions()
}
/// Mutable reference to a the request's extensions
#[inline]
fn message_extensions_mut(&self) -> RefMut<'_, Extensions> {
self.req.extensions_mut()
}
}
impl<Err: ErrorRenderer> fmt::Debug for WebRequest<Err> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
writeln!(
f,
"\nWebRequest {:?} {}:{}",
self.head().version,
self.head().method,
self.path()
)?;
if !self.query_string().is_empty() {
writeln!(f, " query: ?{:?}", self.query_string())?;
}
if !self.match_info().is_empty() {
writeln!(f, " params: {:?}", self.match_info())?;
}
writeln!(f, " headers:")?;
for (key, val) in self.headers().iter() {
writeln!(f, " {:?}: {:?}", key, val)?;
}
Ok(())
}
}
pub struct WebResponse<B = Body> {
request: HttpRequest,
response: Response<B>,
}
impl<B> WebResponse<B> {
/// Create web response instance
pub fn new(request: HttpRequest, response: Response<B>) -> Self {
WebResponse { request, response }
}
/// Create web response from the error
pub fn from_err<Err: ErrorRenderer, E: Into<Err::Container>>(
err: E,
request: HttpRequest,
) -> Self {
use crate::http::error::ResponseError;
let err = err.into();
let res: Response = err.error_response();
if res.head().status == StatusCode::INTERNAL_SERVER_ERROR {
log::error!("Internal Server Error: {:?}", err);
} else {
log::debug!("Error in response: {:?}", err);
}
WebResponse {
request,
response: res.into_body(),
}
}
/// Create web response for error
#[inline]
pub fn error_response<Err: ErrorRenderer, E: Into<Err::Container>>(
self,
err: E,
) -> Self {
Self::from_err::<Err, E>(err, self.request)
}
/// Create web response
#[inline]
pub fn into_response<B1>(self, response: Response<B1>) -> WebResponse<B1> {
WebResponse::new(self.request, response)
}
/// Get reference to original request
#[inline]
pub fn request(&self) -> &HttpRequest {
&self.request
}
/// Get reference to response
#[inline]
pub fn response(&self) -> &Response<B> {
&self.response
}
/// Get mutable reference to response
#[inline]
pub fn response_mut(&mut self) -> &mut Response<B> {
&mut self.response
}
/// Get the response status code
#[inline]
pub fn status(&self) -> StatusCode {
self.response.status()
}
#[inline]
/// Returns response's headers.
pub fn headers(&self) -> &HeaderMap {
self.response.headers()
}
#[inline]
/// Returns mutable response's headers.
pub fn headers_mut(&mut self) -> &mut HeaderMap {
self.response.headers_mut()
}
/// Execute closure and in case of error convert it to response.
pub fn checked_expr<F, E, Err>(mut self, f: F) -> Self
where
F: FnOnce(&mut Self) -> Result<(), E>,
E: Into<Err::Container>,
Err: ErrorRenderer,
/// Register http service
pub fn register_service<F, S>(
&mut self,
rdef: ResourceDef,
guards: Option<Vec<Box<dyn Guard>>>,
factory: F,
nested: Option<Rc<ResourceMap>>,
) where
F: IntoServiceFactory<S>,
S: ServiceFactory<
Config = (),
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
InitError = (),
> + 'static,
{
match f(&mut self) {
Ok(_) => self,
Err(err) => {
let res: Response = err.into().into();
WebResponse::new(self.request, res.into_body())
}
}
}
/// Extract response body
pub fn take_body(&mut self) -> ResponseBody<B> {
self.response.take_body()
self.services.push((
rdef,
boxed::factory(factory.into_factory()),
guards,
nested,
));
}
}
impl<B> WebResponse<B> {
/// Set a new body
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);
WebResponse {
response,
request: self.request,
}
}
}
impl<B> Into<Response<B>> for WebResponse<B> {
fn into(self) -> Response<B> {
self.response
}
}
impl<B: MessageBody> fmt::Debug for WebResponse<B> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let res = writeln!(
f,
"\nWebResponse {:?} {}{}",
self.response.head().version,
self.response.head().status,
self.response.head().reason.unwrap_or(""),
);
let _ = writeln!(f, " headers:");
for (key, val) in self.response.head().headers.iter() {
let _ = writeln!(f, " {:?}: {:?}", key, val);
}
let _ = writeln!(f, " body: {:?}", self.response.body().size());
res
}
}
pub struct WebService {
/// Create service adapter for a specific path.
///
/// ```rust
/// use ntex::web::{self, dev, guard, App, HttpResponse, Error, DefaultError};
///
/// async fn my_service(req: dev::WebRequest<DefaultError>) -> Result<dev::WebResponse, Error> {
/// Ok(req.into_response(HttpResponse::Ok().finish()))
/// }
///
/// let app = App::new().service(
/// web::service("/users/*")
/// .guard(guard::Header("content-type", "text/plain"))
/// .finish(my_service)
/// );
/// ```
pub struct WebServiceAdapter {
rdef: Vec<String>,
name: Option<String>,
guards: Vec<Box<dyn Guard>>,
}
impl WebService {
/// Create new `WebService` instance.
impl WebServiceAdapter {
/// Create new `WebServiceAdapter` instance.
pub fn new<T: IntoPattern>(path: T) -> Self {
WebService {
WebServiceAdapter {
rdef: path.patterns(),
name: None,
guards: Vec::new(),
@ -511,7 +215,7 @@ impl WebService {
}
/// Set a service factory implementation and generate web service.
pub fn finish<T, F, Err>(self, service: F) -> impl HttpServiceFactory<Err>
pub fn finish<T, F, Err>(self, service: F) -> impl WebServiceFactory<Err>
where
F: IntoServiceFactory<T>,
T: ServiceFactory<
@ -539,7 +243,7 @@ struct WebServiceImpl<T> {
guards: Vec<Box<dyn Guard>>,
}
impl<T, Err> HttpServiceFactory<Err> for WebServiceImpl<T>
impl<T, Err> WebServiceFactory<Err> for WebServiceImpl<T>
where
T: ServiceFactory<
Config = (),
@ -550,7 +254,7 @@ where
> + 'static,
Err: ErrorRenderer,
{
fn register(mut self, config: &mut AppService<Err>) {
fn register(mut self, config: &mut WebServiceConfig<Err>) {
let guards = if self.guards.is_empty() {
None
} else {

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

@ -33,11 +33,11 @@ use crate::server::Server;
use crate::{map_config, IntoService, IntoServiceFactory, Service, ServiceFactory};
use crate::web::config::AppConfig;
use crate::web::error::ErrorRenderer;
use crate::web::request::HttpRequestPool;
use crate::web::dev::{WebRequest, WebResponse};
use crate::web::error::{DefaultError, ErrorRenderer};
use crate::web::httprequest::{HttpRequest, HttpRequestPool};
use crate::web::rmap::ResourceMap;
use crate::web::service::{WebRequest, WebResponse};
use crate::web::{DefaultError, HttpRequest, HttpResponse};
use crate::web::{FromRequest, HttpResponse, Responder};
/// Create service that always responds with `HttpResponse::Ok()`
pub fn ok_service<Err: ErrorRenderer>() -> impl Service<
@ -216,6 +216,7 @@ where
bytes.freeze()
}
/// Reads response's body and combines it to a Bytes objects
pub async fn load_stream<S>(mut stream: S) -> Result<Bytes, Box<dyn Error>>
where
S: Stream<Item = Result<Bytes, Box<dyn Error>>> + Unpin,
@ -274,6 +275,22 @@ where
.unwrap_or_else(|_| panic!("read_response_json failed during deserialization"))
}
/// Helper method for extractors testing
pub async fn from_request<T: FromRequest<DefaultError>>(
req: &HttpRequest,
payload: &mut Payload,
) -> Result<T, T::Error> {
T::from_request(req, payload).await
}
/// Helper method for responders testing
pub async fn respond_to<T: Responder<DefaultError>>(
slf: T,
req: &HttpRequest,
) -> Result<HttpResponse, T::Error> {
T::respond_to(slf, req).await
}
/// Test `Request` builder.
///
/// For unit testing, actix provides a request builder type and a simple handler runner. TestRequest implements a builder-like pattern.
@ -757,6 +774,7 @@ where
}
#[derive(Clone)]
/// Test server configuration
pub struct TestServerConfig {
tp: HttpVer,
stream: StreamType,

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

@ -17,9 +17,7 @@ use crate::http::encoding::Decoder;
use crate::http::header::{CONTENT_LENGTH, CONTENT_TYPE};
use crate::http::{HttpMessage, Payload, Response, StatusCode};
use crate::web::error::{ErrorRenderer, UrlencodedError};
use crate::web::extract::FromRequest;
use crate::web::request::HttpRequest;
use crate::web::responder::Responder;
use crate::web::{FromRequest, HttpRequest, Responder};
/// Form data helper (`application/x-www-form-urlencoded`)
///
@ -347,133 +345,133 @@ where
}
}
// #[cfg(test)]
// mod tests {
// use bytes::Bytes;
// use serde::{Deserialize, Serialize};
#[cfg(test)]
mod tests {
use bytes::Bytes;
use serde::{Deserialize, Serialize};
// use super::*;
// use crate::http::header::{HeaderValue, CONTENT_TYPE};
// use crate::web::test::TestRequest;
use super::*;
use crate::http::header::{HeaderValue, CONTENT_TYPE};
use crate::web::test::{from_request, respond_to, TestRequest};
// #[derive(Deserialize, Serialize, Debug, PartialEq)]
// struct Info {
// hello: String,
// counter: i64,
// }
#[derive(Deserialize, Serialize, Debug, PartialEq)]
struct Info {
hello: String,
counter: i64,
}
// #[ntex_rt::test]
// async fn test_form() {
// let (req, mut pl) =
// TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
// .header(CONTENT_LENGTH, "11")
// .set_payload(Bytes::from_static(b"hello=world&counter=123"))
// .to_http_parts();
#[ntex_rt::test]
async fn test_form() {
let (req, mut pl) =
TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
.header(CONTENT_LENGTH, "11")
.set_payload(Bytes::from_static(b"hello=world&counter=123"))
.to_http_parts();
// let Form(s) = Form::<Info>::from_request(&req, &mut pl).await.unwrap();
// assert_eq!(
// s,
// Info {
// hello: "world".into(),
// counter: 123
// }
// );
// }
let Form(s) = from_request::<Form<Info>>(&req, &mut pl).await.unwrap();
assert_eq!(
s,
Info {
hello: "world".into(),
counter: 123
}
);
}
// fn eq(err: UrlencodedError, other: UrlencodedError) -> bool {
// match err {
// UrlencodedError::Overflow { .. } => match other {
// UrlencodedError::Overflow { .. } => true,
// _ => false,
// },
// UrlencodedError::UnknownLength => match other {
// UrlencodedError::UnknownLength => true,
// _ => false,
// },
// UrlencodedError::ContentType => match other {
// UrlencodedError::ContentType => true,
// _ => false,
// },
// _ => false,
// }
// }
fn eq(err: UrlencodedError, other: UrlencodedError) -> bool {
match err {
UrlencodedError::Overflow { .. } => match other {
UrlencodedError::Overflow { .. } => true,
_ => false,
},
UrlencodedError::UnknownLength => match other {
UrlencodedError::UnknownLength => true,
_ => false,
},
UrlencodedError::ContentType => match other {
UrlencodedError::ContentType => true,
_ => false,
},
_ => false,
}
}
// #[ntex_rt::test]
// async fn test_urlencoded_error() {
// let (req, mut pl) =
// TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
// .header(CONTENT_LENGTH, "xxxx")
// .to_http_parts();
// let info = UrlEncoded::<Info>::new(&req, &mut pl).await;
// assert!(eq(info.err().unwrap(), UrlencodedError::UnknownLength));
#[ntex_rt::test]
async fn test_urlencoded_error() {
let (req, mut pl) =
TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
.header(CONTENT_LENGTH, "xxxx")
.to_http_parts();
let info = UrlEncoded::<Info>::new(&req, &mut pl).await;
assert!(eq(info.err().unwrap(), UrlencodedError::UnknownLength));
// let (req, mut pl) =
// TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
// .header(CONTENT_LENGTH, "1000000")
// .to_http_parts();
// let info = UrlEncoded::<Info>::new(&req, &mut pl).await;
// assert!(eq(
// info.err().unwrap(),
// UrlencodedError::Overflow { size: 0, limit: 0 }
// ));
let (req, mut pl) =
TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
.header(CONTENT_LENGTH, "1000000")
.to_http_parts();
let info = UrlEncoded::<Info>::new(&req, &mut pl).await;
assert!(eq(
info.err().unwrap(),
UrlencodedError::Overflow { size: 0, limit: 0 }
));
// let (req, mut pl) = TestRequest::with_header(CONTENT_TYPE, "text/plain")
// .header(CONTENT_LENGTH, "10")
// .to_http_parts();
// let info = UrlEncoded::<Info>::new(&req, &mut pl).await;
// assert!(eq(info.err().unwrap(), UrlencodedError::ContentType));
// }
let (req, mut pl) = TestRequest::with_header(CONTENT_TYPE, "text/plain")
.header(CONTENT_LENGTH, "10")
.to_http_parts();
let info = UrlEncoded::<Info>::new(&req, &mut pl).await;
assert!(eq(info.err().unwrap(), UrlencodedError::ContentType));
}
// #[ntex_rt::test]
// async fn test_urlencoded() {
// let (req, mut pl) =
// TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
// .header(CONTENT_LENGTH, "11")
// .set_payload(Bytes::from_static(b"hello=world&counter=123"))
// .to_http_parts();
#[ntex_rt::test]
async fn test_urlencoded() {
let (req, mut pl) =
TestRequest::with_header(CONTENT_TYPE, "application/x-www-form-urlencoded")
.header(CONTENT_LENGTH, "11")
.set_payload(Bytes::from_static(b"hello=world&counter=123"))
.to_http_parts();
// let info = UrlEncoded::<Info>::new(&req, &mut pl).await.unwrap();
// assert_eq!(
// info,
// Info {
// hello: "world".to_owned(),
// counter: 123
// }
// );
let info = UrlEncoded::<Info>::new(&req, &mut pl).await.unwrap();
assert_eq!(
info,
Info {
hello: "world".to_owned(),
counter: 123
}
);
// let (req, mut pl) = TestRequest::with_header(
// CONTENT_TYPE,
// "application/x-www-form-urlencoded; charset=utf-8",
// )
// .header(CONTENT_LENGTH, "11")
// .set_payload(Bytes::from_static(b"hello=world&counter=123"))
// .to_http_parts();
let (req, mut pl) = TestRequest::with_header(
CONTENT_TYPE,
"application/x-www-form-urlencoded; charset=utf-8",
)
.header(CONTENT_LENGTH, "11")
.set_payload(Bytes::from_static(b"hello=world&counter=123"))
.to_http_parts();
// let info = UrlEncoded::<Info>::new(&req, &mut pl).await.unwrap();
// assert_eq!(
// info,
// Info {
// hello: "world".to_owned(),
// counter: 123
// }
// );
// }
let info = UrlEncoded::<Info>::new(&req, &mut pl).await.unwrap();
assert_eq!(
info,
Info {
hello: "world".to_owned(),
counter: 123
}
);
}
// #[ntex_rt::test]
// async fn test_responder() {
// let req = TestRequest::default().to_http_request();
#[ntex_rt::test]
async fn test_responder() {
let req = TestRequest::default().to_http_request();
// let form = Form(Info {
// hello: "world".to_string(),
// counter: 123,
// });
// let resp = form.respond_to(&req).await.unwrap();
// assert_eq!(resp.status(), StatusCode::OK);
// assert_eq!(
// resp.headers().get(CONTENT_TYPE).unwrap(),
// HeaderValue::from_static("application/x-www-form-urlencoded")
// );
let form = Form(Info {
hello: "world".to_string(),
counter: 123,
});
let resp = respond_to(form, &req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(
resp.headers().get(CONTENT_TYPE).unwrap(),
HeaderValue::from_static("application/x-www-form-urlencoded")
);
// assert_eq!(resp.body().bin_ref(), b"hello=world&counter=123");
// }
// }
assert_eq!(resp.body().bin_ref(), b"hello=world&counter=123");
}
}

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

@ -13,16 +13,12 @@ use serde::de::DeserializeOwned;
use serde::Serialize;
use serde_json;
use crate::http::header::CONTENT_LENGTH;
use crate::http::{HttpMessage, Payload, Response, StatusCode};
#[cfg(feature = "compress")]
use crate::http::encoding::Decoder;
use crate::http::header::CONTENT_LENGTH;
use crate::http::{HttpMessage, Payload, Response, StatusCode};
use crate::web::error::{ErrorRenderer, JsonError, JsonPayloadError};
use crate::web::extract::FromRequest;
use crate::web::request::HttpRequest;
use crate::web::responder::Responder;
use crate::web::{FromRequest, HttpRequest, Responder};
/// Json helper
///
@ -384,251 +380,199 @@ where
}
}
// #[cfg(test)]
// mod tests {
// use bytes::Bytes;
// use serde_derive::{Deserialize, Serialize};
#[cfg(test)]
mod tests {
use bytes::Bytes;
use serde_derive::{Deserialize, Serialize};
// use super::*;
// use crate::http::error::InternalError;
// use crate::http::header;
// use crate::web::test::{load_stream, TestRequest};
// use crate::web::HttpResponse;
use super::*;
use crate::http::header;
use crate::web::test::{from_request, respond_to, TestRequest};
// #[derive(Serialize, Deserialize, PartialEq, Debug)]
// struct MyObject {
// name: String,
// }
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct MyObject {
name: String,
}
// fn json_eq(err: JsonPayloadError, other: JsonPayloadError) -> bool {
// match err {
// JsonPayloadError::Overflow => match other {
// JsonPayloadError::Overflow => true,
// _ => false,
// },
// JsonPayloadError::ContentType => match other {
// JsonPayloadError::ContentType => true,
// _ => false,
// },
// _ => false,
// }
// }
fn json_eq(err: JsonPayloadError, other: JsonPayloadError) -> bool {
match err {
JsonPayloadError::Overflow => match other {
JsonPayloadError::Overflow => true,
_ => false,
},
JsonPayloadError::ContentType => match other {
JsonPayloadError::ContentType => true,
_ => false,
},
_ => false,
}
}
// #[ntex_rt::test]
// async fn test_responder() {
// let req = TestRequest::default().to_http_request();
#[ntex_rt::test]
async fn test_responder() {
let req = TestRequest::default().to_http_request();
// let j = Json(MyObject {
// name: "test".to_string(),
// });
// let resp = j.respond_to(&req).await.unwrap();
// assert_eq!(resp.status(), StatusCode::OK);
// assert_eq!(
// resp.headers().get(header::CONTENT_TYPE).unwrap(),
// header::HeaderValue::from_static("application/json")
// );
let j = Json(MyObject {
name: "test".to_string(),
});
let resp = respond_to(j, &req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(),
header::HeaderValue::from_static("application/json")
);
// assert_eq!(resp.body().bin_ref(), b"{\"name\":\"test\"}");
// }
assert_eq!(resp.body().bin_ref(), b"{\"name\":\"test\"}");
}
// #[ntex_rt::test]
// async fn test_custom_error_responder() {
// let (req, mut pl) = TestRequest::default()
// .header(
// header::CONTENT_TYPE,
// header::HeaderValue::from_static("application/json"),
// )
// .header(
// header::CONTENT_LENGTH,
// header::HeaderValue::from_static("16"),
// )
// .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
// .data(JsonConfig::default().limit(10).error_handler(|err, _| {
// let msg = MyObject {
// name: "invalid request".to_string(),
// };
// let resp = HttpResponse::BadRequest()
// .body(serde_json::to_string(&msg).unwrap());
// InternalError::from_response(err, resp).into()
// }))
// .to_http_parts();
#[ntex_rt::test]
async fn test_extract() {
let (req, mut pl) = TestRequest::default()
.header(
header::CONTENT_TYPE,
header::HeaderValue::from_static("application/json"),
)
.header(
header::CONTENT_LENGTH,
header::HeaderValue::from_static("16"),
)
.set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
.to_http_parts();
// let s = Json::<MyObject>::from_request(&req, &mut pl).await;
// let mut resp = Response::from_error(s.err().unwrap().into());
// assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
let s = from_request::<Json<MyObject>>(&req, &mut pl).await.unwrap();
assert_eq!(s.name, "test");
assert_eq!(
s.into_inner(),
MyObject {
name: "test".to_string()
}
);
// let body = load_stream(resp.take_body()).await.unwrap();
// let msg: MyObject = serde_json::from_slice(&body).unwrap();
// assert_eq!(msg.name, "invalid request");
// }
let (req, mut pl) = TestRequest::default()
.header(
header::CONTENT_TYPE,
header::HeaderValue::from_static("application/json"),
)
.header(
header::CONTENT_LENGTH,
header::HeaderValue::from_static("16"),
)
.set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
.data(JsonConfig::default().limit(10))
.to_http_parts();
// #[ntex_rt::test]
// async fn test_extract() {
// let (req, mut pl) = TestRequest::default()
// .header(
// header::CONTENT_TYPE,
// header::HeaderValue::from_static("application/json"),
// )
// .header(
// header::CONTENT_LENGTH,
// header::HeaderValue::from_static("16"),
// )
// .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
// .to_http_parts();
let s = from_request::<Json<MyObject>>(&req, &mut pl).await;
assert!(format!("{}", s.err().unwrap())
.contains("Json payload size is bigger than allowed"));
}
// let s = Json::<MyObject>::from_request(&req, &mut pl).await.unwrap();
// assert_eq!(s.name, "test");
// assert_eq!(
// s.into_inner(),
// MyObject {
// name: "test".to_string()
// }
// );
#[ntex_rt::test]
async fn test_json_body() {
let (req, mut pl) = TestRequest::default().to_http_parts();
let json = JsonBody::<MyObject>::new(&req, &mut pl, None).await;
assert!(json_eq(json.err().unwrap(), JsonPayloadError::ContentType));
// let (req, mut pl) = TestRequest::default()
// .header(
// header::CONTENT_TYPE,
// header::HeaderValue::from_static("application/json"),
// )
// .header(
// header::CONTENT_LENGTH,
// header::HeaderValue::from_static("16"),
// )
// .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
// .data(JsonConfig::default().limit(10))
// .to_http_parts();
let (req, mut pl) = TestRequest::default()
.header(
header::CONTENT_TYPE,
header::HeaderValue::from_static("application/text"),
)
.to_http_parts();
let json = JsonBody::<MyObject>::new(&req, &mut pl, None).await;
assert!(json_eq(json.err().unwrap(), JsonPayloadError::ContentType));
// let s = Json::<MyObject>::from_request(&req, &mut pl).await;
// assert!(format!("{}", s.err().unwrap())
// .contains("Json payload size is bigger than allowed"));
let (req, mut pl) = TestRequest::default()
.header(
header::CONTENT_TYPE,
header::HeaderValue::from_static("application/json"),
)
.header(
header::CONTENT_LENGTH,
header::HeaderValue::from_static("10000"),
)
.to_http_parts();
// let (req, mut pl) = TestRequest::default()
// .header(
// header::CONTENT_TYPE,
// header::HeaderValue::from_static("application/json"),
// )
// .header(
// header::CONTENT_LENGTH,
// header::HeaderValue::from_static("16"),
// )
// .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
// .data(
// JsonConfig::default()
// .limit(10)
// .error_handler(|_, _| JsonPayloadError::ContentType.into()),
// )
// .to_http_parts();
// let s = Json::<MyObject>::from_request(&req, &mut pl).await;
// assert!(format!("{}", s.err().unwrap()).contains("Content type error"));
// }
let json = JsonBody::<MyObject>::new(&req, &mut pl, None)
.limit(100)
.await;
assert!(json_eq(json.err().unwrap(), JsonPayloadError::Overflow));
// #[ntex_rt::test]
// async fn test_json_body() {
// let (req, mut pl) = TestRequest::default().to_http_parts();
// let json = JsonBody::<MyObject>::new(&req, &mut pl, None).await;
// assert!(json_eq(json.err().unwrap(), JsonPayloadError::ContentType));
let (req, mut pl) = TestRequest::default()
.header(
header::CONTENT_TYPE,
header::HeaderValue::from_static("application/json"),
)
.header(
header::CONTENT_LENGTH,
header::HeaderValue::from_static("16"),
)
.set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
.to_http_parts();
// let (req, mut pl) = TestRequest::default()
// .header(
// header::CONTENT_TYPE,
// header::HeaderValue::from_static("application/text"),
// )
// .to_http_parts();
// let json = JsonBody::<MyObject>::new(&req, &mut pl, None).await;
// assert!(json_eq(json.err().unwrap(), JsonPayloadError::ContentType));
let json = JsonBody::<MyObject>::new(&req, &mut pl, None).await;
assert_eq!(
json.ok().unwrap(),
MyObject {
name: "test".to_owned()
}
);
}
// let (req, mut pl) = TestRequest::default()
// .header(
// header::CONTENT_TYPE,
// header::HeaderValue::from_static("application/json"),
// )
// .header(
// header::CONTENT_LENGTH,
// header::HeaderValue::from_static("10000"),
// )
// .to_http_parts();
#[ntex_rt::test]
async fn test_with_json_and_bad_content_type() {
let (req, mut pl) = TestRequest::with_header(
header::CONTENT_TYPE,
header::HeaderValue::from_static("text/plain"),
)
.header(
header::CONTENT_LENGTH,
header::HeaderValue::from_static("16"),
)
.set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
.data(JsonConfig::default().limit(4096))
.to_http_parts();
// let json = JsonBody::<MyObject>::new(&req, &mut pl, None)
// .limit(100)
// .await;
// assert!(json_eq(json.err().unwrap(), JsonPayloadError::Overflow));
let s = from_request::<Json<MyObject>>(&req, &mut pl).await;
assert!(s.is_err())
}
// let (req, mut pl) = TestRequest::default()
// .header(
// header::CONTENT_TYPE,
// header::HeaderValue::from_static("application/json"),
// )
// .header(
// header::CONTENT_LENGTH,
// header::HeaderValue::from_static("16"),
// )
// .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
// .to_http_parts();
#[ntex_rt::test]
async fn test_with_json_and_good_custom_content_type() {
let (req, mut pl) = TestRequest::with_header(
header::CONTENT_TYPE,
header::HeaderValue::from_static("text/plain"),
)
.header(
header::CONTENT_LENGTH,
header::HeaderValue::from_static("16"),
)
.set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
.data(JsonConfig::default().content_type(|mime: mime::Mime| {
mime.type_() == mime::TEXT && mime.subtype() == mime::PLAIN
}))
.to_http_parts();
// let json = JsonBody::<MyObject>::new(&req, &mut pl, None).await;
// assert_eq!(
// json.ok().unwrap(),
// MyObject {
// name: "test".to_owned()
// }
// );
// }
let s = from_request::<Json<MyObject>>(&req, &mut pl).await;
assert!(s.is_ok())
}
// #[ntex_rt::test]
// async fn test_with_json_and_bad_content_type() {
// let (req, mut pl) = TestRequest::with_header(
// header::CONTENT_TYPE,
// header::HeaderValue::from_static("text/plain"),
// )
// .header(
// header::CONTENT_LENGTH,
// header::HeaderValue::from_static("16"),
// )
// .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
// .data(JsonConfig::default().limit(4096))
// .to_http_parts();
#[ntex_rt::test]
async fn test_with_json_and_bad_custom_content_type() {
let (req, mut pl) = TestRequest::with_header(
header::CONTENT_TYPE,
header::HeaderValue::from_static("text/html"),
)
.header(
header::CONTENT_LENGTH,
header::HeaderValue::from_static("16"),
)
.set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
.data(JsonConfig::default().content_type(|mime: mime::Mime| {
mime.type_() == mime::TEXT && mime.subtype() == mime::PLAIN
}))
.to_http_parts();
// let s = Json::<MyObject>::from_request(&req, &mut pl).await;
// assert!(s.is_err())
// }
// #[ntex_rt::test]
// async fn test_with_json_and_good_custom_content_type() {
// let (req, mut pl) = TestRequest::with_header(
// header::CONTENT_TYPE,
// header::HeaderValue::from_static("text/plain"),
// )
// .header(
// header::CONTENT_LENGTH,
// header::HeaderValue::from_static("16"),
// )
// .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
// .data(JsonConfig::default().content_type(|mime: mime::Mime| {
// mime.type_() == mime::TEXT && mime.subtype() == mime::PLAIN
// }))
// .to_http_parts();
// let s = Json::<MyObject>::from_request(&req, &mut pl).await;
// assert!(s.is_ok())
// }
// #[ntex_rt::test]
// async fn test_with_json_and_bad_custom_content_type() {
// let (req, mut pl) = TestRequest::with_header(
// header::CONTENT_TYPE,
// header::HeaderValue::from_static("text/html"),
// )
// .header(
// header::CONTENT_LENGTH,
// header::HeaderValue::from_static("16"),
// )
// .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
// .data(JsonConfig::default().content_type(|mime: mime::Mime| {
// mime.type_() == mime::TEXT && mime.subtype() == mime::PLAIN
// }))
// .to_http_parts();
// let s = Json::<MyObject>::from_request(&req, &mut pl).await;
// assert!(s.is_err())
// }
// }
let s = from_request::<Json<MyObject>>(&req, &mut pl).await;
assert!(s.is_err())
}
}

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

@ -7,8 +7,7 @@ use serde::de;
use crate::http::Payload;
use crate::router::PathDeserializer;
use crate::web::error::{ErrorRenderer, PathError};
use crate::web::request::HttpRequest;
use crate::web::FromRequest;
use crate::web::{FromRequest, HttpRequest};
#[derive(PartialEq, Eq, PartialOrd, Ord)]
/// Extract typed information from the request's path.
@ -178,134 +177,117 @@ where
}
}
// #[cfg(test)]
// mod tests {
// use actix_router::ResourceDef;
// use derive_more::Display;
// use serde_derive::Deserialize;
#[cfg(test)]
mod tests {
use derive_more::Display;
use serde_derive::Deserialize;
// use super::*;
// use crate::http::{error, StatusCode};
// use crate::web::test::TestRequest;
// use crate::web::HttpResponse;
use super::*;
use crate::router::Router;
use crate::web::test::{from_request, TestRequest};
// #[derive(Deserialize, Debug, Display)]
// #[display(fmt = "MyStruct({}, {})", key, value)]
// struct MyStruct {
// key: String,
// value: String,
// }
#[derive(Deserialize, Debug, Display)]
#[display(fmt = "MyStruct({}, {})", key, value)]
struct MyStruct {
key: String,
value: String,
}
// #[derive(Deserialize)]
// struct Test2 {
// key: String,
// value: u32,
// }
#[derive(Deserialize)]
struct Test2 {
key: String,
value: u32,
}
// #[ntex_rt::test]
// async fn test_extract_path_single() {
// let resource = ResourceDef::new("/{value}/");
#[ntex_rt::test]
async fn test_extract_path_single() {
let mut router = Router::<usize>::build();
router.path("/{value}/", 10).0.set_id(0);
let router = router.finish();
// let mut req = TestRequest::with_uri("/32/").to_srv_request();
// resource.match_path(req.match_info_mut());
let mut req = TestRequest::with_uri("/32/").to_srv_request();
router.recognize(req.match_info_mut());
// let (req, mut pl) = req.into_parts();
// assert_eq!(*Path::<i8>::from_request(&req, &mut pl).await.unwrap(), 32);
// assert!(Path::<MyStruct>::from_request(&req, &mut pl).await.is_err());
// }
let (req, mut pl) = req.into_parts();
assert_eq!(*from_request::<Path<i8>>(&req, &mut pl).await.unwrap(), 32);
assert!(from_request::<Path<MyStruct>>(&req, &mut pl).await.is_err());
}
// #[ntex_rt::test]
// async fn test_tuple_extract() {
// let resource = ResourceDef::new("/{key}/{value}/");
#[ntex_rt::test]
async fn test_tuple_extract() {
let mut router = Router::<usize>::build();
router.path("/{key}/{value}/", 10).0.set_id(0);
let router = router.finish();
// let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
// resource.match_path(req.match_info_mut());
let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
router.recognize(req.match_info_mut());
// let (req, mut pl) = req.into_parts();
// let res = <(Path<(String, String)>,)>::from_request(&req, &mut pl)
// .await
// .unwrap();
// assert_eq!((res.0).0, "name");
// assert_eq!((res.0).1, "user1");
let (req, mut pl) = req.into_parts();
let res = from_request::<(Path<(String, String)>,)>(&req, &mut pl)
.await
.unwrap();
assert_eq!((res.0).0, "name");
assert_eq!((res.0).1, "user1");
// let res = <(Path<(String, String)>, Path<(String, String)>)>::from_request(
// &req, &mut pl,
// )
// .await
// .unwrap();
// assert_eq!((res.0).0, "name");
// assert_eq!((res.0).1, "user1");
// assert_eq!((res.1).0, "name");
// assert_eq!((res.1).1, "user1");
let res = from_request::<(Path<(String, String)>, Path<(String, String)>)>(
&req, &mut pl,
)
.await
.unwrap();
assert_eq!((res.0).0, "name");
assert_eq!((res.0).1, "user1");
assert_eq!((res.1).0, "name");
assert_eq!((res.1).1, "user1");
// let () = <()>::from_request(&req, &mut pl).await.unwrap();
// }
let () = from_request::<()>(&req, &mut pl).await.unwrap();
}
// #[ntex_rt::test]
// async fn test_request_extract() {
// let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
#[ntex_rt::test]
async fn test_request_extract() {
let mut router = Router::<usize>::build();
router.path("/{key}/{value}/", 10).0.set_id(0);
let router = router.finish();
// let resource = ResourceDef::new("/{key}/{value}/");
// resource.match_path(req.match_info_mut());
let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
router.recognize(req.match_info_mut());
// let (req, mut pl) = req.into_parts();
// let mut s = Path::<MyStruct>::from_request(&req, &mut pl).await.unwrap();
// assert_eq!(s.key, "name");
// assert_eq!(s.value, "user1");
// s.value = "user2".to_string();
// assert_eq!(s.value, "user2");
// assert_eq!(
// format!("{}, {:?}", s, s),
// "MyStruct(name, user2), MyStruct { key: \"name\", value: \"user2\" }"
// );
// let s = s.into_inner();
// assert_eq!(s.value, "user2");
let (req, mut pl) = req.into_parts();
let mut s = from_request::<Path<MyStruct>>(&req, &mut pl).await.unwrap();
assert_eq!(s.key, "name");
assert_eq!(s.value, "user1");
s.value = "user2".to_string();
assert_eq!(s.value, "user2");
assert_eq!(
format!("{}, {:?}", s, s),
"MyStruct(name, user2), MyStruct { key: \"name\", value: \"user2\" }"
);
let s = s.into_inner();
assert_eq!(s.value, "user2");
// let s = Path::<(String, String)>::from_request(&req, &mut pl)
// .await
// .unwrap();
// assert_eq!(s.0, "name");
// assert_eq!(s.1, "user1");
let s = from_request::<Path<(String, String)>>(&req, &mut pl)
.await
.unwrap();
assert_eq!(s.0, "name");
assert_eq!(s.1, "user1");
// let mut req = TestRequest::with_uri("/name/32/").to_srv_request();
// let resource = ResourceDef::new("/{key}/{value}/");
// resource.match_path(req.match_info_mut());
let mut req = TestRequest::with_uri("/name/32/").to_srv_request();
router.recognize(req.match_info_mut());
// let (req, mut pl) = req.into_parts();
// let s = Path::<Test2>::from_request(&req, &mut pl).await.unwrap();
// assert_eq!(s.as_ref().key, "name");
// assert_eq!(s.value, 32);
let (req, mut pl) = req.into_parts();
let s = from_request::<Path<Test2>>(&req, &mut pl).await.unwrap();
assert_eq!(s.as_ref().key, "name");
assert_eq!(s.value, 32);
// let s = Path::<(String, u8)>::from_request(&req, &mut pl)
// .await
// .unwrap();
// assert_eq!(s.0, "name");
// assert_eq!(s.1, 32);
let s = from_request::<Path<(String, u8)>>(&req, &mut pl)
.await
.unwrap();
assert_eq!(s.0, "name");
assert_eq!(s.1, 32);
// let res = Path::<Vec<String>>::from_request(&req, &mut pl)
// .await
// .unwrap();
// assert_eq!(res[0], "name".to_owned());
// assert_eq!(res[1], "32".to_owned());
// }
// #[ntex_rt::test]
// async fn test_custom_err_handler() {
// let (req, mut pl) = TestRequest::with_uri("/name/user1/")
// .data(PathConfig::default().error_handler(|err, _| {
// error::InternalError::from_response(
// err,
// HttpResponse::Conflict().finish(),
// )
// .into()
// }))
// .to_http_parts();
// let s = Path::<(usize,)>::from_request(&req, &mut pl)
// .await
// .unwrap_err();
// let res: HttpResponse = s.into();
// assert_eq!(res.status(), StatusCode::CONFLICT);
// }
// }
let res = from_request::<Path<Vec<String>>>(&req, &mut pl)
.await
.unwrap();
assert_eq!(res[0], "name".to_owned());
assert_eq!(res[1], "32".to_owned());
}
}

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

@ -12,8 +12,7 @@ use mime::Mime;
use crate::http::{error, header, HttpMessage};
use crate::web::error::{ErrorRenderer, PayloadError};
use crate::web::extract::FromRequest;
use crate::web::request::HttpRequest;
use crate::web::{FromRequest, HttpRequest};
/// Payload extractor returns request 's payload stream.
///
@ -414,85 +413,85 @@ impl Future for HttpMessageBody {
}
}
// #[cfg(test)]
// mod tests {
// use bytes::Bytes;
#[cfg(test)]
mod tests {
use bytes::Bytes;
// use super::*;
// use crate::http::header;
// use crate::web::test::TestRequest;
use super::*;
use crate::http::header;
use crate::web::test::{from_request, TestRequest};
// #[ntex_rt::test]
// async fn test_payload_config() {
// let req = TestRequest::default().to_http_request();
// let cfg = PayloadConfig::default().mimetype(mime::APPLICATION_JSON);
// assert!(cfg.check_mimetype(&req).is_err());
#[ntex_rt::test]
async fn test_payload_config() {
let req = TestRequest::default().to_http_request();
let cfg = PayloadConfig::default().mimetype(mime::APPLICATION_JSON);
assert!(cfg.check_mimetype(&req).is_err());
// let req = TestRequest::with_header(
// header::CONTENT_TYPE,
// "application/x-www-form-urlencoded",
// )
// .to_http_request();
// assert!(cfg.check_mimetype(&req).is_err());
let req = TestRequest::with_header(
header::CONTENT_TYPE,
"application/x-www-form-urlencoded",
)
.to_http_request();
assert!(cfg.check_mimetype(&req).is_err());
// let req = TestRequest::with_header(header::CONTENT_TYPE, "application/json")
// .to_http_request();
// assert!(cfg.check_mimetype(&req).is_ok());
// }
let req = TestRequest::with_header(header::CONTENT_TYPE, "application/json")
.to_http_request();
assert!(cfg.check_mimetype(&req).is_ok());
}
// #[ntex_rt::test]
// async fn test_bytes() {
// let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "11")
// .set_payload(Bytes::from_static(b"hello=world"))
// .to_http_parts();
#[ntex_rt::test]
async fn test_bytes() {
let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "11")
.set_payload(Bytes::from_static(b"hello=world"))
.to_http_parts();
// let s = Bytes::from_request(&req, &mut pl).await.unwrap();
// assert_eq!(s, Bytes::from_static(b"hello=world"));
// }
let s = from_request::<Bytes>(&req, &mut pl).await.unwrap();
assert_eq!(s, Bytes::from_static(b"hello=world"));
}
// #[ntex_rt::test]
// async fn test_string() {
// let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "11")
// .set_payload(Bytes::from_static(b"hello=world"))
// .to_http_parts();
#[ntex_rt::test]
async fn test_string() {
let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "11")
.set_payload(Bytes::from_static(b"hello=world"))
.to_http_parts();
// let s = String::from_request(&req, &mut pl).await.unwrap();
// assert_eq!(s, "hello=world");
// }
let s = from_request::<String>(&req, &mut pl).await.unwrap();
assert_eq!(s, "hello=world");
}
// #[ntex_rt::test]
// async fn test_message_body() {
// let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "xxxx")
// .to_srv_request()
// .into_parts();
// let res = HttpMessageBody::new(&req, &mut pl).await;
// match res.err().unwrap() {
// PayloadError::Payload(error::PayloadError::UnknownLength) => (),
// _ => unreachable!("error"),
// }
#[ntex_rt::test]
async fn test_message_body() {
let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "xxxx")
.to_srv_request()
.into_parts();
let res = HttpMessageBody::new(&req, &mut pl).await;
match res.err().unwrap() {
PayloadError::Payload(error::PayloadError::UnknownLength) => (),
_ => unreachable!("error"),
}
// let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "1000000")
// .to_srv_request()
// .into_parts();
// let res = HttpMessageBody::new(&req, &mut pl).await;
// match res.err().unwrap() {
// PayloadError::Payload(error::PayloadError::Overflow) => (),
// _ => unreachable!("error"),
// }
let (req, mut pl) = TestRequest::with_header(header::CONTENT_LENGTH, "1000000")
.to_srv_request()
.into_parts();
let res = HttpMessageBody::new(&req, &mut pl).await;
match res.err().unwrap() {
PayloadError::Payload(error::PayloadError::Overflow) => (),
_ => unreachable!("error"),
}
// let (req, mut pl) = TestRequest::default()
// .set_payload(Bytes::from_static(b"test"))
// .to_http_parts();
// let res = HttpMessageBody::new(&req, &mut pl).await;
// assert_eq!(res.ok().unwrap(), Bytes::from_static(b"test"));
let (req, mut pl) = TestRequest::default()
.set_payload(Bytes::from_static(b"test"))
.to_http_parts();
let res = HttpMessageBody::new(&req, &mut pl).await;
assert_eq!(res.ok().unwrap(), Bytes::from_static(b"test"));
// let (req, mut pl) = TestRequest::default()
// .set_payload(Bytes::from_static(b"11111111111111"))
// .to_http_parts();
// let res = HttpMessageBody::new(&req, &mut pl).limit(5).await;
// match res.err().unwrap() {
// PayloadError::Payload(error::PayloadError::Overflow) => (),
// _ => unreachable!("error"),
// }
// }
// }
let (req, mut pl) = TestRequest::default()
.set_payload(Bytes::from_static(b"11111111111111"))
.to_http_parts();
let res = HttpMessageBody::new(&req, &mut pl).limit(5).await;
match res.err().unwrap() {
PayloadError::Payload(error::PayloadError::Overflow) => (),
_ => unreachable!("error"),
}
}
}

83
ntex/src/web/types/query.rs
View file

@ -8,8 +8,7 @@ use serde_urlencoded;
use crate::http::Payload;
use crate::web::error::{ErrorRenderer, QueryPayloadError};
use crate::web::extract::FromRequest;
use crate::web::request::HttpRequest;
use crate::web::{FromRequest, HttpRequest};
/// Extract typed information from the request's query.
///
@ -153,55 +152,51 @@ where
}
}
// #[cfg(test)]
// mod tests {
// use derive_more::Display;
// use serde_derive::Deserialize;
#[cfg(test)]
mod tests {
use derive_more::Display;
use serde_derive::Deserialize;
// use super::*;
// use crate::http::error::InternalError;
// use crate::http::StatusCode;
// use crate::web::test::TestRequest;
// use crate::web::{DefaultError, HttpResponse};
use super::*;
use crate::web::test::{from_request, TestRequest};
// #[derive(Deserialize, Debug, Display)]
// struct Id {
// id: String,
// }
#[derive(Deserialize, Debug, Display)]
struct Id {
id: String,
}
// #[ntex_rt::test]
// async fn test_service_request_extract() {
// let req = TestRequest::with_uri("/name/user1/").to_srv_request();
// assert!(Query::<Id>::from_query(&req.query_string()).is_err());
#[ntex_rt::test]
async fn test_service_request_extract() {
let req = TestRequest::with_uri("/name/user1/").to_srv_request();
assert!(Query::<Id>::from_query(&req.query_string()).is_err());
// let req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
// let mut s = Query::<Id>::from_query(&req.query_string()).unwrap();
let req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
let mut s = Query::<Id>::from_query(&req.query_string()).unwrap();
// assert_eq!(s.id, "test");
// assert_eq!(format!("{}, {:?}", s, s), "test, Id { id: \"test\" }");
assert_eq!(s.id, "test");
assert_eq!(format!("{}, {:?}", s, s), "test, Id { id: \"test\" }");
// s.id = "test1".to_string();
// let s = s.into_inner();
// assert_eq!(s.id, "test1");
// }
s.id = "test1".to_string();
let s = s.into_inner();
assert_eq!(s.id, "test1");
}
// #[ntex_rt::test]
// async fn test_request_extract() {
// let req = TestRequest::with_uri("/name/user1/").to_srv_request();
// let (req, mut pl) = req.into_parts();
// let res: Result<Query<Id>, QueryPayloadError> = FromRequest::from_request(&req, &mut pl).await;
// assert!(res.is_err());
#[ntex_rt::test]
async fn test_request_extract() {
let req = TestRequest::with_uri("/name/user1/").to_srv_request();
let (req, mut pl) = req.into_parts();
let res = from_request::<Query<Id>>(&req, &mut pl).await;
assert!(res.is_err());
// let req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
// let (req, mut pl) = req.into_parts();
let req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
let (req, mut pl) = req.into_parts();
// let mut s: Result<Query<Id>, QueryPayloadError> = FromRequest::<DefaultError>::from_request(&req, &mut pl).await;
// let s = s.unwrap();
// assert_eq!(s.id, "test");
// assert_eq!(format!("{}, {:?}", s, s), "test, Id { id: \"test\" }");
let mut s = from_request::<Query<Id>>(&req, &mut pl).await.unwrap();
assert_eq!(s.id, "test");
assert_eq!(format!("{}, {:?}", s, s), "test, Id { id: \"test\" }");
// s.id = "test1".to_string();
// let s = s.into_inner();
// assert_eq!(s.id, "test1");
// }
// }
s.id = "test1".to_string();
let s = s.into_inner();
assert_eq!(s.id, "test1");
}
}

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

@ -5,6 +5,7 @@ use ntex_router::IntoPattern;
use crate::http::body::MessageBody;
use crate::http::error::{BlockingError, ResponseError};
use crate::http::header::ContentEncoding;
use crate::http::{Method, Request, Response};
use crate::{IntoServiceFactory, Service, ServiceFactory};
@ -17,7 +18,8 @@ use super::responder::Responder;
use super::route::Route;
use super::scope::Scope;
use super::server::HttpServer;
use super::service::WebService;
use super::service::WebServiceAdapter;
use super::{HttpResponse, HttpResponseBuilder};
/// Create resource for a specific path.
///
@ -232,7 +234,7 @@ where
Route::new().to(handler)
}
/// Create raw service for a specific path.
/// Create service adapter for a specific path.
///
/// ```rust
/// use ntex::web::{self, dev, guard, App, HttpResponse, Error, DefaultError};
@ -247,8 +249,8 @@ where
/// .finish(my_service)
/// );
/// ```
pub fn service<T: IntoPattern>(path: T) -> WebService {
WebService::new(path)
pub fn service<T: IntoPattern>(path: T) -> WebServiceAdapter {
WebServiceAdapter::new(path)
}
/// Execute blocking function on a thread pool, returns future that resolves
@ -290,3 +292,44 @@ where
{
HttpServer::new(factory)
}
struct Enc(ContentEncoding);
/// Helper trait that allows to set specific encoding for response.
pub trait BodyEncoding {
/// Get content encoding
fn get_encoding(&self) -> Option<ContentEncoding>;
/// Set content encoding
fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self;
}
impl BodyEncoding for HttpResponseBuilder {
fn get_encoding(&self) -> Option<ContentEncoding> {
if let Some(ref enc) = self.extensions().get::<Enc>() {
Some(enc.0)
} else {
None
}
}
fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self {
self.extensions_mut().insert(Enc(encoding));
self
}
}
impl<B> BodyEncoding for HttpResponse<B> {
fn get_encoding(&self) -> Option<ContentEncoding> {
if let Some(ref enc) = self.extensions().get::<Enc>() {
Some(enc.0)
} else {
None
}
}
fn encoding(&mut self, encoding: ContentEncoding) -> &mut Self {
self.extensions_mut().insert(Enc(encoding));
self
}
}

4
ntex/tests/http_awc_client.rs
View file

@ -15,9 +15,9 @@ use ntex::http::client::{error::SendRequestError, Client, Connector};
use ntex::http::test::server as test_server;
use ntex::http::{header, HttpMessage, HttpService};
use ntex::service::{map_config, pipeline_factory, Service};
use ntex::web::dev::{AppConfig, BodyEncoding};
use ntex::web::dev::AppConfig;
use ntex::web::middleware::Compress;
use ntex::web::{self, test, App, Error, HttpRequest, HttpResponse};
use ntex::web::{self, test, App, BodyEncoding, Error, HttpRequest, HttpResponse};
const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \

3
ntex/tests/web_server.rs
View file

@ -19,9 +19,8 @@ use ntex::http::header::{
};
use ntex::http::{Method, StatusCode};
use ntex::web::dev::BodyEncoding;
use ntex::web::middleware::Compress;
use ntex::web::{self, test, App, HttpResponse, WebResponseError};
use ntex::web::{self, test, App, BodyEncoding, HttpResponse, WebResponseError};
const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \