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

migrate ntex

Browse source
This commit is contained in:
Nikolay Kim 2021-12-24 02:29:24 +06:00
parent 75b54e6b04
commit 8d65da2f4d
28 changed files with 281 additions and 429 deletions
Download patch file Download diff file Expand all files Collapse all files

2
ntex/Cargo.toml
View file

@ -41,7 +41,7 @@ url = ["url-pkg"]
[dependencies]
ntex-codec = "0.6.0"
ntex-router = "0.5.1"
ntex-service = "0.2.1"
ntex-service = "0.3.0"
ntex-macros = "0.1.3"
ntex-util = "0.1.4"
ntex-bytes = "0.1.8"

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

@ -45,22 +45,16 @@ impl<F, S> HttpServiceBuilder<F, S, ExpectHandler, UpgradeHandler<F>> {
impl<F, S, X, U> HttpServiceBuilder<F, S, X, U>
where
F: Filter + 'static,
S: ServiceFactory<Config = (), Request = Request>,
S::Error: ResponseError + 'static,
F: Filter,
S: ServiceFactory<Request, Config = ()> + 'static,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Future: 'static,
<S::Service as Service>::Future: 'static,
X: ServiceFactory<Config = (), Request = Request, Response = Request>,
X::Error: ResponseError + 'static,
X: ServiceFactory<Request, Config = (), Response = Request> + 'static,
X::Error: ResponseError,
X::InitError: fmt::Debug,
X::Future: 'static,
<X::Service as Service>::Future: 'static,
U: ServiceFactory<Config = (), Request = (Request, Io<F>, Codec), Response = ()>,
U::Error: fmt::Display + Error + 'static,
U: ServiceFactory<(Request, Io<F>, Codec), Config = (), Response = ()> + 'static,
U::Error: fmt::Display + Error,
U::InitError: fmt::Debug,
U::Future: 'static,
<U::Service as Service>::Future: 'static,
{
/// Set server keep-alive setting.
///
@ -115,12 +109,9 @@ where
/// request will be forwarded to main service.
pub fn expect<XF, X1>(self, expect: XF) -> HttpServiceBuilder<F, S, X1, U>
where
XF: IntoServiceFactory<X1>,
X1: ServiceFactory<Config = (), Request = Request, Response = Request>,
X1::Error: ResponseError + 'static,
XF: IntoServiceFactory<X1, Request>,
X1: ServiceFactory<Request, Config = (), Response = Request> + 'static,
X1::InitError: fmt::Debug,
X1::Future: 'static,
<X1::Service as Service>::Future: 'static,
{
HttpServiceBuilder {
keep_alive: self.keep_alive,
@ -140,16 +131,11 @@ where
/// and this service get called with original request and framed object.
pub fn upgrade<UF, U1>(self, upgrade: UF) -> HttpServiceBuilder<F, S, X, U1>
where
UF: IntoServiceFactory<U1>,
U1: ServiceFactory<
Config = (),
Request = (Request, Io<F>, Codec),
Response = (),
>,
U1::Error: fmt::Display + Error + 'static,
UF: IntoServiceFactory<U1, (Request, Io<F>, Codec)>,
U1: ServiceFactory<(Request, Io<F>, Codec), Config = (), Response = ()>
+ 'static,
U1::Error: fmt::Display + Error,
U1::InitError: fmt::Debug,
U1::Future: 'static,
<U1::Service as Service>::Future: 'static,
{
HttpServiceBuilder {
keep_alive: self.keep_alive,
@ -168,9 +154,8 @@ where
/// It get called once per request.
pub fn on_request<R, FR>(mut self, f: FR) -> Self
where
FR: IntoService<R>,
R: Service<Request = (Request, IoRef), Response = Request, Error = Response>
+ 'static,
FR: IntoService<R, (Request, IoRef)>,
R: Service<(Request, IoRef), Response = Request, Error = Response> + 'static,
{
self.on_request = Some(boxed::service(f.into_service()));
self
@ -180,7 +165,7 @@ where
pub fn h1<B, SF>(self, service: SF) -> H1Service<F, S, B, X, U>
where
B: MessageBody,
SF: IntoServiceFactory<S>,
SF: IntoServiceFactory<S, Request>,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>>,
@ -202,11 +187,11 @@ where
pub fn h2<B, SF>(self, service: SF) -> H2Service<F, S, B>
where
B: MessageBody + 'static,
SF: IntoServiceFactory<S>,
SF: IntoServiceFactory<S, Request>,
S::Error: ResponseError + 'static,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>> + 'static,
<S::Service as Service>::Future: 'static,
<S::Service as Service<Request>>::Future: 'static,
{
let cfg = ServiceConfig::new(
self.keep_alive,
@ -222,12 +207,12 @@ where
pub fn finish<B, SF>(self, service: SF) -> HttpService<F, S, B, X, U>
where
B: MessageBody + 'static,
SF: IntoServiceFactory<S>,
SF: IntoServiceFactory<S, Request>,
S::Error: ResponseError + 'static,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>> + 'static,
S::Future: 'static,
<S::Service as Service>::Future: 'static,
<S::Service as Service<Request>>::Future: 'static,
{
let cfg = ServiceConfig::new(
self.keep_alive,

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

@ -42,8 +42,7 @@ impl ClientBuilder {
/// Use custom connector service.
pub fn connector<T>(mut self, connector: T) -> Self
where
T: Service<Request = Connect, Response = Connection, Error = ConnectError>
+ 'static,
T: Service<Connect, Response = Connection, Error = ConnectError> + 'static,
{
self.config.connector = Box::new(ConnectorWrapper(connector));
self

2
ntex/src/http/client/connect.rs
View file

@ -21,7 +21,7 @@ pub(super) trait Connect {
impl<T> Connect for ConnectorWrapper<T>
where
T: Service<Request = ClientConnect, Response = Connection, Error = ConnectError>,
T: Service<ClientConnect, Response = Connection, Error = ConnectError>,
T::Future: 'static,
{
fn send_request(

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

@ -178,7 +178,7 @@ impl Connector {
pub fn connector<T, F>(mut self, connector: T) -> Self
where
T: Service<
Request = TcpConnect<Uri>,
TcpConnect<Uri>,
Response = Io<F>,
Error = crate::connect::ConnectError,
> + 'static,
@ -193,7 +193,7 @@ impl Connector {
pub fn secure_connector<T, F>(mut self, connector: T) -> Self
where
T: Service<
Request = TcpConnect<Uri>,
TcpConnect<Uri>,
Response = Io<F>,
Error = crate::connect::ConnectError,
> + 'static,
@ -209,7 +209,7 @@ impl Connector {
pub fn boxed_secure_connector<T>(mut self, connector: T) -> Self
where
T: Service<
Request = TcpConnect<Uri>,
TcpConnect<Uri>,
Response = IoBoxed,
Error = crate::connect::ConnectError,
> + 'static,
@ -223,8 +223,7 @@ impl Connector {
/// its combinator chain.
pub fn finish(
self,
) -> impl Service<Request = Connect, Response = Connection, Error = ConnectError> + Clone
{
) -> impl Service<Connect, Response = Connection, Error = ConnectError> + Clone {
let tcp_service =
connector(self.connector, self.timeout, self.disconnect_timeout);
@ -258,12 +257,8 @@ fn connector(
connector: BoxedConnector,
timeout: Millis,
disconnect_timeout: Millis,
) -> impl Service<
Request = Connect,
Response = IoBoxed,
Error = ConnectError,
Future = impl Unpin,
> + Unpin {
) -> impl Service<Connect, Response = IoBoxed, Error = ConnectError, Future = impl Unpin>
+ Unpin {
TimeoutService::new(
timeout,
apply_fn(connector, |msg: Connect, srv| {
@ -286,18 +281,15 @@ struct InnerConnector<T> {
ssl_pool: Option<ConnectionPool<T>>,
}
impl<T> Service for InnerConnector<T>
impl<T> Service<Connect> for InnerConnector<T>
where
T: Service<Request = Connect, Response = IoBoxed, Error = ConnectError>
+ Unpin
+ 'static,
T: Service<Connect, Response = IoBoxed, Error = ConnectError> + Unpin + 'static,
T::Future: Unpin,
{
type Request = Connect;
type Response = <ConnectionPool<T> as Service>::Response;
type Response = <ConnectionPool<T> as Service<Connect>>::Response;
type Error = ConnectError;
type Future = Either<
<ConnectionPool<T> as Service>::Future,
<ConnectionPool<T> as Service<Connect>>::Future,
Ready<Self::Response, Self::Error>,
>;

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

@ -37,9 +37,7 @@ pub(super) struct ConnectionPool<T>(Rc<T>, Rc<RefCell<Inner>>);
impl<T> ConnectionPool<T>
where
T: Service<Request = Connect, Response = IoBoxed, Error = ConnectError>
+ Unpin
+ 'static,
T: Service<Connect, Response = IoBoxed, Error = ConnectError> + Unpin + 'static,
T::Future: Unpin,
{
pub(super) fn new(
@ -84,12 +82,11 @@ impl<T> Clone for ConnectionPool<T> {
}
}
impl<T> Service for ConnectionPool<T>
impl<T> Service<Connect> for ConnectionPool<T>
where
T: Service<Request = Connect, Response = IoBoxed, Error = ConnectError> + 'static,
T: Service<Connect, Response = IoBoxed, Error = ConnectError> + 'static,
T::Future: Unpin,
{
type Request = Connect;
type Response = Connection;
type Error = ConnectError;
type Future = Pin<Box<dyn Future<Output = Result<Connection, ConnectError>>>>;
@ -303,7 +300,7 @@ struct ConnectionPoolSupport<T> {
impl<T> Future for ConnectionPoolSupport<T>
where
T: Service<Request = Connect, Response = IoBoxed, Error = ConnectError> + Unpin,
T: Service<Connect, Response = IoBoxed, Error = ConnectError> + Unpin,
T::Future: Unpin + 'static,
{
type Output = ();

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

@ -32,7 +32,7 @@ bitflags::bitflags! {
pin_project_lite::pin_project! {
/// Dispatcher for HTTP/1.1 protocol
pub struct Dispatcher<F, S: Service, B, X: Service, U: Service> {
pub struct Dispatcher<F, S: Service<Request>, B, X: Service<Request>, U: Service<(Request, Io<F>, Codec)>> {
#[pin]
call: CallState<S, X>,
st: State<B>,
@ -56,7 +56,7 @@ enum State<B> {
pin_project_lite::pin_project! {
#[project = CallStateProject]
enum CallState<S: Service, X: Service> {
enum CallState<S: Service<Request>, X: Service<Request>> {
None,
Service { #[pin] fut: S::Future },
Expect { #[pin] fut: X::Future },
@ -79,13 +79,13 @@ struct DispatcherInner<F, S, B, X, U> {
impl<F, S, B, X, U> Dispatcher<F, S, B, X, U>
where
F: Filter + 'static,
S: Service<Request = Request>,
S: Service<Request>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>>,
B: MessageBody,
X: Service<Request = Request, Response = Request>,
X: Service<Request, Response = Request>,
X::Error: ResponseError,
U: Service<Request = (Request, Io<F>, Codec), Response = ()> + 'static,
U: Service<(Request, Io<F>, Codec), Response = ()> + 'static,
U::Error: Error + fmt::Display,
{
/// Construct new `Dispatcher` instance with outgoing messages stream.
@ -131,13 +131,13 @@ macro_rules! set_error ({ $slf:tt, $err:ident } => {
impl<F, S, B, X, U> Future for Dispatcher<F, S, B, X, U>
where
F: Filter,
S: Service<Request = Request>,
S: Service<Request>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>>,
B: MessageBody,
X: Service<Request = Request, Response = Request>,
X: Service<Request, Response = Request>,
X::Error: ResponseError + 'static,
U: Service<Request = (Request, Io<F>, Codec), Response = ()> + 'static,
U: Service<(Request, Io<F>, Codec), Response = ()> + 'static,
U::Error: Error + fmt::Display,
{
type Output = Result<(), DispatchError>;
@ -441,7 +441,7 @@ where
impl<T, S, B, X, U> DispatcherInner<T, S, B, X, U>
where
S: Service<Request = Request>,
S: Service<Request>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>>,
B: MessageBody,

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

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

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

@ -29,14 +29,14 @@ pub struct H1Service<F, S, B, X = ExpectHandler, U = UpgradeHandler<F>> {
impl<F, S, B> H1Service<F, S, B>
where
S: ServiceFactory<Config = (), Request = Request>,
S: ServiceFactory<Request, Config = ()>,
S::Error: ResponseError + 'static,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>>,
B: MessageBody,
{
/// Create new `HttpService` instance with config.
pub(crate) fn with_config<U: IntoServiceFactory<S>>(
pub(crate) fn with_config<U: IntoServiceFactory<S, Request>>(
cfg: ServiceConfig,
service: U,
) -> Self {
@ -63,19 +63,19 @@ mod openssl {
impl<F, S, B, X, U> H1Service<SslFilter<F>, S, B, X, U>
where
F: Filter,
S: ServiceFactory<Config = (), Request = Request>,
S: ServiceFactory<Request, Config = ()>,
S::Error: ResponseError + 'static,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>>,
S::Future: 'static,
B: MessageBody,
X: ServiceFactory<Config = (), Request = Request, Response = Request>,
X: ServiceFactory<Request, Config = (), Response = Request>,
X::Error: ResponseError + 'static,
X::InitError: fmt::Debug,
X::Future: 'static,
U: ServiceFactory<
(Request, Io<SslFilter<F>>, Codec),
Config = (),
Request = (Request, Io<SslFilter<F>>, Codec),
Response = (),
> + 'static,
U::Error: fmt::Display + Error,
@ -86,8 +86,8 @@ mod openssl {
self,
acceptor: SslAcceptor,
) -> impl ServiceFactory<
Io<F>,
Config = (),
Request = Io<F>,
Response = (),
Error = SslError<DispatchError>,
InitError = (),
@ -116,19 +116,19 @@ mod rustls {
impl<F, S, B, X, U> H1Service<TlsFilter<F>, S, B, X, U>
where
F: Filter,
S: ServiceFactory<Config = (), Request = Request>,
S: ServiceFactory<Request, Config = ()>,
S::Error: ResponseError + 'static,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>>,
S::Future: 'static,
B: MessageBody,
X: ServiceFactory<Config = (), Request = Request, Response = Request>,
X: ServiceFactory<Request, Config = (), Response = Request>,
X::Error: ResponseError + 'static,
X::InitError: fmt::Debug,
X::Future: 'static,
U: ServiceFactory<
(Request, Io<TlsFilter<F>>, Codec),
Config = (),
Request = (Request, Io<TlsFilter<F>>, Codec),
Response = (),
> + 'static,
U::Error: fmt::Display + Error,
@ -139,8 +139,8 @@ mod rustls {
self,
config: ServerConfig,
) -> impl ServiceFactory<
Io<F>,
Config = (),
Request = Io<F>,
Response = (),
Error = SslError<DispatchError>,
InitError = (),
@ -159,7 +159,7 @@ mod rustls {
impl<F, S, B, X, U> H1Service<F, S, B, X, U>
where
F: Filter,
S: ServiceFactory<Config = (), Request = Request>,
S: ServiceFactory<Request, Config = ()>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>>,
S::InitError: fmt::Debug,
@ -168,7 +168,7 @@ where
{
pub fn expect<X1>(self, expect: X1) -> H1Service<F, S, B, X1, U>
where
X1: ServiceFactory<Request = Request, Response = Request>,
X1: ServiceFactory<Request, Response = Request>,
X1::Error: ResponseError + 'static,
X1::InitError: fmt::Debug,
X1::Future: 'static,
@ -186,7 +186,7 @@ where
pub fn upgrade<U1>(self, upgrade: Option<U1>) -> H1Service<F, S, B, X, U1>
where
U1: ServiceFactory<Request = (Request, Io<F>, Codec), Response = ()>,
U1: ServiceFactory<(Request, Io<F>, Codec), Response = ()>,
U1::Error: fmt::Display + Error + 'static,
U1::InitError: fmt::Debug,
U1::Future: 'static,
@ -211,26 +211,24 @@ where
}
}
impl<F, S, B, X, U> ServiceFactory for H1Service<F, S, B, X, U>
impl<F, S, B, X, U> ServiceFactory<Io<F>> for H1Service<F, S, B, X, U>
where
F: Filter + 'static,
S: ServiceFactory<Config = (), Request = Request>,
S: ServiceFactory<Request, Config = ()>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>>,
S::InitError: fmt::Debug,
S::Future: 'static,
B: MessageBody,
X: ServiceFactory<Config = (), Request = Request, Response = Request>,
X: ServiceFactory<Request, Config = (), Response = Request>,
X::Error: ResponseError + 'static,
X::InitError: fmt::Debug,
X::Future: 'static,
U: ServiceFactory<Config = (), Request = (Request, Io<F>, Codec), Response = ()>
+ 'static,
U: ServiceFactory<(Request, Io<F>, Codec), Config = (), Response = ()> + 'static,
U::Error: fmt::Display + Error,
U::InitError: fmt::Debug,
{
type Config = ();
type Request = Io<F>;
type Response = ();
type Error = DispatchError;
type InitError = ();
@ -273,24 +271,23 @@ where
}
/// `Service` implementation for HTTP1 transport
pub struct H1ServiceHandler<F, S: Service, B, X: Service, U: Service> {
pub struct H1ServiceHandler<F, S, B, X, U> {
config: Rc<DispatcherConfig<S, X, U>>,
_t: marker::PhantomData<(F, B)>,
}
impl<F, S, B, X, U> Service for H1ServiceHandler<F, S, B, X, U>
impl<F, S, B, X, U> Service<Io<F>> for H1ServiceHandler<F, S, B, X, U>
where
F: Filter + 'static,
S: Service<Request = Request>,
S: Service<Request>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>>,
B: MessageBody,
X: Service<Request = Request, Response = Request>,
X: Service<Request, Response = Request>,
X::Error: ResponseError + 'static,
U: Service<Request = (Request, Io<F>, Codec), Response = ()> + 'static,
U: Service<(Request, Io<F>, Codec), Response = ()> + 'static,
U::Error: fmt::Display + Error,
{
type Request = Io<F>;
type Response = ();
type Error = DispatchError;
type Future = Dispatcher<F, S, B, X, U>;
@ -359,7 +356,7 @@ where
}
}
fn call(&self, io: Self::Request) -> Self::Future {
fn call(&self, io: Io<F>) -> Self::Future {
log::trace!(
"New http1 connection, peer address {:?}",
io.query::<types::PeerAddr>().get()

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

@ -7,11 +7,11 @@ use crate::{util::Ready, Service, ServiceFactory};
pub struct UpgradeHandler<F>(PhantomData<F>);
impl<F> ServiceFactory for UpgradeHandler<F> {
type Config = ();
type Request = (Request, Io<F>, Codec);
impl<F> ServiceFactory<(Request, Io<F>, Codec)> for UpgradeHandler<F> {
type Response = ();
type Error = io::Error;
type Config = ();
type Service = UpgradeHandler<F>;
type InitError = io::Error;
type Future = Ready<Self::Service, Self::InitError>;
@ -22,8 +22,7 @@ impl<F> ServiceFactory for UpgradeHandler<F> {
}
}
impl<F> Service for UpgradeHandler<F> {
type Request = (Request, Io<F>, Codec);
impl<F> Service<(Request, Io<F>, Codec)> for UpgradeHandler<F> {
type Response = ();
type Error = io::Error;
type Future = Ready<Self::Response, Self::Error>;
@ -34,7 +33,7 @@ impl<F> Service for UpgradeHandler<F> {
}
#[inline]
fn call(&self, _: Self::Request) -> Self::Future {
fn call(&self, _: (Request, Io<F>, Codec)) -> Self::Future {
unimplemented!()
}
}

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

@ -25,7 +25,7 @@ const CHUNK_SIZE: usize = 16_384;
pin_project_lite::pin_project! {
/// Dispatcher for HTTP/2 protocol
pub struct Dispatcher<F, S: Service<Request = Request>, B: MessageBody, X, U> {
pub struct Dispatcher<F, S: Service<Request>, B: MessageBody, X, U> {
io: IoRef,
config: Rc<DispatcherConfig<S, X, U>>,
connection: Connection<Io<F>, Bytes>,
@ -38,7 +38,7 @@ pin_project_lite::pin_project! {
impl<F, S, B, X, U> Dispatcher<F, S, B, X, U>
where
F: Filter,
S: Service<Request = Request>,
S: Service<Request>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>>,
B: MessageBody,
@ -76,7 +76,7 @@ where
impl<F, S, B, X, U> Future for Dispatcher<F, S, B, X, U>
where
F: Filter,
S: Service<Request = Request>,
S: Service<Request>,
S::Error: ResponseError + 'static,
S::Future: 'static,
S::Response: Into<Response<B>> + 'static,

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

@ -26,15 +26,15 @@ pub struct H2Service<F, S, B> {
impl<F, S, B> H2Service<F, S, B>
where
S: ServiceFactory<Config = (), Request = Request>,
S: ServiceFactory<Request, Config = ()>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>> + 'static,
S::Future: 'static,
<S::Service as Service>::Future: 'static,
<S::Service as Service<Request>>::Future: 'static,
B: MessageBody + 'static,
{
/// Create new `HttpService` instance with config.
pub(crate) fn with_config<U: IntoServiceFactory<S>>(
pub(crate) fn with_config<U: IntoServiceFactory<S, Request>>(
cfg: ServiceConfig,
service: U,
) -> Self {
@ -131,18 +131,17 @@ mod rustls {
}
}
impl<F, S, B> ServiceFactory for H2Service<F, S, B>
impl<F, S, B> ServiceFactory<Io<F>> for H2Service<F, S, B>
where
F: Filter,
S: ServiceFactory<Config = (), Request = Request>,
S: ServiceFactory<Request, Config = ()>,
S::Error: ResponseError + 'static,
S::Response: Into<Response<B>> + 'static,
S::Future: 'static,
<S::Service as Service>::Future: 'static,
<S::Service as Service<Request>>::Future: 'static,
B: MessageBody + 'static,
{
type Config = ();
type Request = Io<F>;
type Response = ();
type Error = DispatchError;
type InitError = S::InitError;
@ -166,21 +165,20 @@ where
}
/// `Service` implementation for http/2 transport
pub struct H2ServiceHandler<F, S: Service, B> {
pub struct H2ServiceHandler<F, S: Service<Request>, B> {
config: Rc<DispatcherConfig<S, (), ()>>,
_t: PhantomData<(F, B)>,
}
impl<F, S, B> Service for H2ServiceHandler<F, S, B>
impl<F, S, B> Service<Io<F>> for H2ServiceHandler<F, S, B>
where
F: Filter,
S: Service<Request = Request>,
S: Service<Request>,
S::Error: ResponseError + 'static,
S::Future: 'static,
S::Response: Into<Response<B>> + 'static,
B: MessageBody + 'static,
{
type Request = Io<F>;
type Response = ();
type Error = DispatchError;
type Future = H2ServiceHandlerResponse<F, S, B>;
@ -198,7 +196,7 @@ where
self.config.service.poll_shutdown(cx, is_error)
}
fn call(&self, io: Self::Request) -> Self::Future {
fn call(&self, io: Io<F>) -> Self::Future {
log::trace!(
"New http2 connection, peer address {:?}",
io.query::<types::PeerAddr>().get()
@ -215,7 +213,7 @@ where
}
}
enum State<F, S: Service<Request = Request>, B: MessageBody>
enum State<F, S: Service<Request>, B: MessageBody>
where
F: Filter,
S::Future: 'static,
@ -231,7 +229,7 @@ where
pub struct H2ServiceHandlerResponse<F, S, B>
where
F: Filter,
S: Service<Request = Request>,
S: Service<Request>,
S::Error: ResponseError + 'static,
S::Future: 'static,
S::Response: Into<Response<B>> + 'static,
@ -243,7 +241,7 @@ where
impl<F, S, B> Future for H2ServiceHandlerResponse<F, S, B>
where
F: Filter,
S: Service<Request = Request>,
S: Service<Request>,
S::Error: ResponseError + 'static,
S::Future: 'static,
S::Response: Into<Response<B>> + 'static,

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

@ -29,12 +29,12 @@ pub struct HttpService<F, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler<F>
impl<F, S, B> HttpService<F, S, B>
where
S: ServiceFactory<Config = (), Request = Request>,
S: ServiceFactory<Request, Config = ()>,
S::Error: ResponseError + 'static,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>> + 'static,
S::Future: 'static,
<S::Service as Service>::Future: 'static,
<S::Service as Service<Request>>::Future: 'static,
B: MessageBody + 'static,
{
/// Create builder for `HttpService` instance.
@ -46,16 +46,16 @@ where
impl<F, S, B> HttpService<F, S, B>
where
F: Filter,
S: ServiceFactory<Config = (), Request = Request>,
S: ServiceFactory<Request, Config = ()>,
S::Error: ResponseError + 'static,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>> + 'static,
S::Future: 'static,
<S::Service as Service>::Future: 'static,
<S::Service as Service<Request>>::Future: 'static,
B: MessageBody + 'static,
{
/// Create new `HttpService` instance.
pub fn new<U: IntoServiceFactory<S>>(service: U) -> Self {
pub fn new<U: IntoServiceFactory<S, Request>>(service: U) -> Self {
let cfg = ServiceConfig::new(
KeepAlive::Timeout(Seconds(5)),
Millis(5_000),
@ -74,7 +74,7 @@ where
}
/// Create new `HttpService` instance with config.
pub(crate) fn with_config<U: IntoServiceFactory<S>>(
pub(crate) fn with_config<U: IntoServiceFactory<S, Request>>(
cfg: ServiceConfig,
service: U,
) -> Self {
@ -92,12 +92,12 @@ where
impl<F, S, B, X, U> HttpService<F, S, B, X, U>
where
F: Filter,
S: ServiceFactory<Config = (), Request = Request>,
S: ServiceFactory<Request, Config = ()>,
S::Error: ResponseError + 'static,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>> + 'static,
S::Future: 'static,
<S::Service as Service>::Future: 'static,
<S::Service as Service<Request>>::Future: 'static,
B: MessageBody,
{
/// Provide service for `EXPECT: 100-Continue` support.
@ -107,7 +107,7 @@ where
/// request will be forwarded to main service.
pub fn expect<X1>(self, expect: X1) -> HttpService<F, S, B, X1, U>
where
X1: ServiceFactory<Config = (), Request = Request, Response = Request>,
X1: ServiceFactory<Request, Config = (), Response = Request>,
X1::Error: ResponseError,
X1::InitError: fmt::Debug,
X1::Future: 'static,
@ -128,11 +128,7 @@ where
/// and this service get called with original request and framed object.
pub fn upgrade<U1>(self, upgrade: Option<U1>) -> HttpService<F, S, B, X, U1>
where
U1: ServiceFactory<
Config = (),
Request = (Request, Io<F>, h1::Codec),
Response = (),
>,
U1: ServiceFactory<(Request, Io<F>, h1::Codec), Config = (), Response = ()>,
U1::Error: fmt::Display + error::Error + 'static,
U1::InitError: fmt::Debug,
U1::Future: 'static,
@ -264,28 +260,22 @@ mod rustls {
}
}
impl<F, S, B, X, U> ServiceFactory for HttpService<F, S, B, X, U>
impl<F, S, B, X, U> ServiceFactory<Io<F>> for HttpService<F, S, B, X, U>
where
F: Filter + 'static,
S: ServiceFactory<Config = (), Request = Request>,
S::Error: ResponseError + 'static,
S: ServiceFactory<Request, Config = ()> + 'static,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Future: 'static,
S::Response: Into<Response<B>> + 'static,
<S::Service as Service>::Future: 'static,
S::Response: Into<Response<B>>,
B: MessageBody + 'static,
X: ServiceFactory<Config = (), Request = Request, Response = Request>,
X::Error: ResponseError + 'static,
X: ServiceFactory<Request, Config = (), Response = Request> + 'static,
X::Error: ResponseError,
X::InitError: fmt::Debug,
X::Future: 'static,
<X::Service as Service>::Future: 'static,
U: ServiceFactory<Config = (), Request = (Request, Io<F>, h1::Codec), Response = ()>
+ 'static,
U: ServiceFactory<(Request, Io<F>, h1::Codec), Config = (), Response = ()> + 'static,
U::Error: fmt::Display + error::Error,
U::InitError: fmt::Debug,
{
type Config = ();
type Request = Io<F>;
type Response = ();
type Error = DispatchError;
type InitError = ();
@ -330,25 +320,24 @@ where
}
/// `Service` implementation for http transport
pub struct HttpServiceHandler<F, S: Service, B, X: Service, U: Service> {
pub struct HttpServiceHandler<F, S, B, X, U> {
config: Rc<DispatcherConfig<S, X, U>>,
_t: marker::PhantomData<(F, B, X)>,
_t: marker::PhantomData<(F, B)>,
}
impl<F, S, B, X, U> Service for HttpServiceHandler<F, S, B, X, U>
impl<F, S, B, X, U> Service<Io<F>> for HttpServiceHandler<F, S, B, X, U>
where
F: Filter + 'static,
S: Service<Request = Request>,
S: Service<Request>,
S::Error: ResponseError + 'static,
S::Future: 'static,
S::Response: Into<Response<B>> + 'static,
B: MessageBody + 'static,
X: Service<Request = Request, Response = Request>,
X: Service<Request, Response = Request>,
X::Error: ResponseError + 'static,
U: Service<Request = (Request, Io<F>, h1::Codec), Response = ()> + 'static,
U: Service<(Request, Io<F>, h1::Codec), Response = ()> + 'static,
U::Error: fmt::Display + error::Error,
{
type Request = Io<F>;
type Response = ();
type Error = DispatchError;
type Future = HttpServiceHandlerResponse<F, S, B, X, U>;
@ -410,7 +399,7 @@ where
}
}
fn call(&self, io: Self::Request) -> Self::Future {
fn call(&self, io: Io<F>) -> Self::Future {
log::trace!(
"New http connection, peer address {:?}",
io.query::<types::PeerAddr>().get()
@ -442,17 +431,17 @@ pin_project_lite::pin_project! {
where
F: Filter,
F: 'static,
S: Service<Request = Request>,
S: Service<Request>,
S::Error: ResponseError,
S::Error: 'static,
S::Response: Into<Response<B>>,
S::Response: 'static,
B: MessageBody,
B: 'static,
X: Service<Request = Request, Response = Request>,
X: Service<Request, Response = Request>,
X::Error: ResponseError,
X::Error: 'static,
U: Service<Request = (Request, Io<F>, h1::Codec), Response = ()>,
U: Service<(Request, Io<F>, h1::Codec), Response = ()>,
U::Error: fmt::Display,
U::Error: error::Error,
U: 'static,
@ -466,16 +455,16 @@ pin_project_lite::pin_project! {
#[project = StateProject]
enum ResponseState<F, S, B, X, U>
where
S: Service<Request = Request>,
S: Service<Request>,
S::Error: ResponseError,
S::Error: 'static,
F: Filter,
F: 'static,
B: MessageBody,
X: Service<Request = Request, Response = Request>,
X: Service<Request, Response = Request>,
X::Error: ResponseError,
X::Error: 'static,
U: Service<Request = (Request, Io<F>, h1::Codec), Response = ()>,
U: Service<(Request, Io<F>, h1::Codec), Response = ()>,
U::Error: fmt::Display,
U::Error: error::Error,
U: 'static,
@ -495,14 +484,14 @@ pin_project_lite::pin_project! {
impl<F, S, B, X, U> future::Future for HttpServiceHandlerResponse<F, S, B, X, U>
where
F: Filter + 'static,
S: Service<Request = Request>,
S: Service<Request>,
S::Error: ResponseError + 'static,
S::Future: 'static,
S::Response: Into<Response<B>> + 'static,
B: MessageBody,
X: Service<Request = Request, Response = Request>,
X: Service<Request, Response = Request>,
X::Error: ResponseError + 'static,
U: Service<Request = (Request, Io<F>, h1::Codec), Response = ()> + 'static,
U: Service<(Request, Io<F>, h1::Codec), Response = ()> + 'static,
U::Error: fmt::Display + error::Error,
{
type Output = Result<(), DispatchError>;

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

@ -209,7 +209,7 @@ fn parts(parts: &mut Option<Inner>) -> &mut Inner {
pub fn server<F, R>(factory: F) -> TestServer
where
F: Fn() -> R + Send + Clone + 'static,
R: ServiceFactory<Config = (), Request = Io>,
R: ServiceFactory<Io, Config = ()>,
{
let (tx, rx) = mpsc::channel();

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

@ -344,7 +344,8 @@ struct ServiceFactory<T> {
pool: PoolId,
}
impl<T> service::ServiceFactory<(Option<CounterGuard>, ServerMessage)> for ServiceFactory<T>
impl<T> service::ServiceFactory<(Option<CounterGuard>, ServerMessage)>
for ServiceFactory<T>
where
T: service::ServiceFactory<Io, Config = ()>,
T::Future: 'static,

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

@ -28,7 +28,7 @@ type FnDataFactory =
/// for building application instances.
pub struct App<M, F, Err: ErrorRenderer = DefaultError> {
middleware: M,
filter: PipelineFactory<F>,
filter: PipelineFactory<F, WebRequest<Err>>,
services: Vec<Box<dyn AppServiceFactory<Err>>>,
default: Option<Rc<HttpNewService<Err>>>,
data: Vec<Box<dyn DataFactory>>,
@ -78,8 +78,8 @@ impl<Err: ErrorRenderer> App<Identity, Filter<Err>, Err> {
impl<M, T, Err> App<M, T, Err>
where
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -280,10 +280,10 @@ where
/// ```
pub fn default_service<F, U>(mut self, f: F) -> Self
where
F: IntoServiceFactory<U>,
F: IntoServiceFactory<U, WebRequest<Err>>,
U: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
> + 'static,
@ -361,8 +361,8 @@ where
) -> App<
M,
impl ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -371,13 +371,13 @@ where
>
where
S: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
>,
U: IntoServiceFactory<S>,
U: IntoServiceFactory<S, WebRequest<Err>>,
{
App {
filter: self.filter.and_then(filter.into_factory()),
@ -446,14 +446,10 @@ where
impl<M, F, Err> App<M, F, Err>
where
M: Transform<AppService<F::Service, Err>> + 'static,
M::Service: Service<
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
>,
M::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
F: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -482,8 +478,8 @@ where
pub fn finish(
self,
) -> impl ServiceFactory<
Request,
Config = (),
Request = Request,
Response = WebResponse,
Error = Err::Container,
InitError = (),
@ -513,8 +509,8 @@ where
self,
cfg: AppConfig,
) -> impl ServiceFactory<
Request,
Config = (),
Request = Request,
Response = WebResponse,
Error = Err::Container,
InitError = (),
@ -523,17 +519,13 @@ where
}
}
impl<M, F, Err> IntoServiceFactory<AppFactory<M, F, Err>> for App<M, F, Err>
impl<M, F, Err> IntoServiceFactory<AppFactory<M, F, Err>, Request> for App<M, F, Err>
where
M: Transform<AppService<F::Service, Err>> + 'static,
M::Service: Service<
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
>,
M::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
F: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -587,9 +579,8 @@ impl<Err: ErrorRenderer> Filter<Err> {
}
}
impl<Err: ErrorRenderer> ServiceFactory for Filter<Err> {
impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for Filter<Err> {
type Config = ();
type Request = WebRequest<Err>;
type Response = WebRequest<Err>;
type Error = Err::Container;
type InitError = ();
@ -602,8 +593,7 @@ impl<Err: ErrorRenderer> ServiceFactory for Filter<Err> {
}
}
impl<Err: ErrorRenderer> Service for Filter<Err> {
type Request = WebRequest<Err>;
impl<Err: ErrorRenderer> Service<WebRequest<Err>> for Filter<Err> {
type Response = WebRequest<Err>;
type Error = Err::Container;
type Future = Ready<WebRequest<Err>, Err::Container>;
@ -617,7 +607,7 @@ impl<Err: ErrorRenderer> Service for Filter<Err> {
}
#[inline]
fn call(&self, req: Self::Request) -> Self::Future {
fn call(&self, req: WebRequest<Err>) -> Self::Future {
Ready::Ok(req)
}
}

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

@ -32,8 +32,8 @@ type FnDataFactory =
pub struct AppFactory<T, F, Err: ErrorRenderer>
where
F: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -42,7 +42,7 @@ where
Err: ErrorRenderer,
{
pub(super) middleware: Rc<T>,
pub(super) filter: PipelineFactory<F>,
pub(super) filter: PipelineFactory<F, WebRequest<Err>>,
pub(super) extensions: RefCell<Option<Extensions>>,
pub(super) data: Rc<Vec<Box<dyn DataFactory>>>,
pub(super) data_factories: Rc<Vec<FnDataFactory>>,
@ -52,17 +52,13 @@ where
pub(super) case_insensitive: bool,
}
impl<T, F, Err> ServiceFactory for AppFactory<T, F, Err>
impl<T, F, Err> ServiceFactory<Request> for AppFactory<T, F, Err>
where
T: Transform<AppService<F::Service, Err>> + 'static,
T::Service: Service<
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
>,
T::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
F: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -71,7 +67,6 @@ where
Err: ErrorRenderer,
{
type Config = AppConfig;
type Request = Request;
type Response = WebResponse;
type Error = Err::Container;
type InitError = ();
@ -178,11 +173,7 @@ where
/// Service to convert `Request` to a `WebRequest<Err>`
pub struct AppFactoryService<T, Err>
where
T: Service<
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
>,
T: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
Err: ErrorRenderer,
{
service: T,
@ -193,16 +184,11 @@ where
_t: PhantomData<Err>,
}
impl<T, Err> Service for AppFactoryService<T, Err>
impl<T, Err> Service<Request> for AppFactoryService<T, Err>
where
T: Service<
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
>,
T: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
Err: ErrorRenderer,
{
type Request = Request;
type Response = WebResponse;
type Error = T::Error;
type Future = T::Future;
@ -244,11 +230,7 @@ where
impl<T, Err> Drop for AppFactoryService<T, Err>
where
T: Service<
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
>,
T: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
Err: ErrorRenderer,
{
fn drop(&mut self) {
@ -261,8 +243,7 @@ struct AppRouting<Err: ErrorRenderer> {
default: Option<HttpService<Err>>,
}
impl<Err: ErrorRenderer> Service for AppRouting<Err> {
type Request = WebRequest<Err>;
impl<Err: ErrorRenderer> Service<WebRequest<Err>> for AppRouting<Err> {
type Response = WebResponse;
type Error = Err::Container;
type Future = BoxResponse<Err>;
@ -301,16 +282,11 @@ pub struct AppService<F, Err: ErrorRenderer> {
routing: Rc<AppRouting<Err>>,
}
impl<F, Err> Service for AppService<F, Err>
impl<F, Err> Service<WebRequest<Err>> for AppService<F, Err>
where
F: Service<
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
>,
F: Service<WebRequest<Err>, Response = WebRequest<Err>, Error = Err::Container>,
Err: ErrorRenderer,
{
type Request = WebRequest<Err>;
type Response = WebResponse;
type Error = Err::Container;
type Future = AppServiceResponse<F, Err>;
@ -336,7 +312,7 @@ where
}
pin_project_lite::pin_project! {
pub struct AppServiceResponse<F: Service, Err: ErrorRenderer> {
pub struct AppServiceResponse<F: Service<WebRequest<Err>>, Err: ErrorRenderer> {
#[pin]
filter: F::Future,
routing: Rc<AppRouting<Err>>,
@ -346,11 +322,7 @@ pin_project_lite::pin_project! {
impl<F, Err> Future for AppServiceResponse<F, Err>
where
F: Service<
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
>,
F: Service<WebRequest<Err>, Response = WebRequest<Err>, Error = Err::Container>,
Err: ErrorRenderer,
{
type Output = Result<WebResponse, Err::Container>;

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

@ -26,8 +26,9 @@ use crate::web::{WebRequest, WebResponse};
/// }
/// ```
#[derive(Clone)]
pub struct DefaultHeaders {
pub struct DefaultHeaders<E> {
inner: Rc<Inner>,
_t: PhantomData<E>,
}
struct Inner {
@ -35,20 +36,21 @@ struct Inner {
headers: HeaderMap,
}
impl Default for DefaultHeaders {
impl<E> Default for DefaultHeaders<E> {
fn default() -> Self {
DefaultHeaders {
inner: Rc::new(Inner {
ct: false,
headers: HeaderMap::new(),
}),
_t: PhantomData,
}
}
}
impl DefaultHeaders {
impl<E> DefaultHeaders<E> {
/// Construct `DefaultHeaders` middleware.
pub fn new() -> DefaultHeaders {
pub fn new() -> DefaultHeaders<E> {
DefaultHeaders::default()
}
@ -86,9 +88,9 @@ impl DefaultHeaders {
}
}
impl<S, E> Transform<S> for DefaultHeaders
impl<S, E> Transform<S> for DefaultHeaders<E>
where
S: Service<Request = WebRequest<E>, Response = WebResponse>,
S: Service<WebRequest<E>, Response = WebResponse>,
S::Future: 'static,
{
type Service = DefaultHeadersMiddleware<S, E>;
@ -108,12 +110,11 @@ pub struct DefaultHeadersMiddleware<S, E> {
_t: PhantomData<E>,
}
impl<S, E> Service for DefaultHeadersMiddleware<S, E>
impl<S, E> Service<WebRequest<E>> for DefaultHeadersMiddleware<S, E>
where
S: Service<Request = WebRequest<E>, Response = WebResponse>,
S: Service<WebRequest<E>, Response = WebResponse>,
S::Future: 'static,
{
type Request = WebRequest<E>;
type Response = WebResponse;
type Error = S::Error;
type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;

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

@ -1,7 +1,7 @@
//! Request logging middleware
use std::fmt::{self, Display};
use std::task::{Context, Poll};
use std::{convert::TryFrom, env, error::Error, future::Future, pin::Pin, rc::Rc, time};
use std::{fmt, fmt::Display, marker::PhantomData};
use regex::Regex;
@ -113,10 +113,7 @@ impl Default for Logger {
}
}
impl<S, Err> Transform<S> for Logger
where
S: Service<Request = WebRequest<Err>, Response = WebResponse>,
{
impl<S> Transform<S> for Logger {
type Service = LoggerMiddleware<S>;
fn new_transform(&self, service: S) -> Self::Service {
@ -133,14 +130,13 @@ pub struct LoggerMiddleware<S> {
service: S,
}
impl<S, E> Service for LoggerMiddleware<S>
impl<S, E> Service<WebRequest<E>> for LoggerMiddleware<S>
where
S: Service<Request = WebRequest<E>, Response = WebResponse>,
S: Service<WebRequest<E>, Response = WebResponse>,
{
type Request = WebRequest<E>;
type Response = WebResponse;
type Error = S::Error;
type Future = Either<LoggerResponse<S>, S::Future>;
type Future = Either<LoggerResponse<S, E>, S::Future>;
#[inline]
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
@ -167,6 +163,7 @@ where
time,
format: Some(format),
fut: self.service.call(req),
_t: PhantomData,
})
}
}
@ -174,18 +171,19 @@ where
pin_project_lite::pin_project! {
#[doc(hidden)]
pub struct LoggerResponse<S: Service>
pub struct LoggerResponse<S: Service<WebRequest<E>>, E>
{
#[pin]
fut: S::Future,
time: time::SystemTime,
format: Option<Format>,
_t: PhantomData<E>
}
}
impl<S, E> Future for LoggerResponse<S>
impl<S, E> Future for LoggerResponse<S, E>
where
S: Service<Request = WebRequest<E>, Response = WebResponse>,
S: Service<WebRequest<E>, Response = WebResponse>,
{
type Output = Result<WebResponse, S::Error>;

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

@ -49,7 +49,7 @@ type HttpNewService<Err: ErrorRenderer> =
/// Default behavior could be overriden with `default_resource()` method.
pub struct Resource<Err: ErrorRenderer, M = Identity, T = Filter<Err>> {
middleware: M,
filter: PipelineFactory<T>,
filter: PipelineFactory<T, WebRequest<Err>>,
rdef: Vec<String>,
name: Option<String>,
routes: Vec<Route<Err>>,
@ -76,8 +76,8 @@ impl<Err: ErrorRenderer> Resource<Err> {
impl<Err, M, T> Resource<Err, M, T>
where
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -251,8 +251,8 @@ where
Err,
M,
impl ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -260,13 +260,13 @@ where
>
where
U: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
>,
F: IntoServiceFactory<U>,
F: IntoServiceFactory<U, WebRequest<Err>>,
{
Resource {
filter: self.filter.and_then(filter.into_factory()),
@ -305,10 +305,10 @@ where
/// default handler from `App` or `Scope`.
pub fn default_service<F, S>(mut self, f: F) -> Self
where
F: IntoServiceFactory<S>,
F: IntoServiceFactory<S, WebRequest<Err>>,
S: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
> + 'static,
@ -328,18 +328,14 @@ where
impl<Err, M, T> WebServiceFactory<Err> for Resource<Err, M, T>
where
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
> + 'static,
M: Transform<ResourceService<T::Service, Err>> + 'static,
M::Service: Service<
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
>,
M::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
Err: ErrorRenderer,
{
fn register(mut self, config: &mut WebServiceConfig<Err>) {
@ -380,25 +376,26 @@ where
}
}
impl<Err, M, T> IntoServiceFactory<ResourceServiceFactory<Err, M, PipelineFactory<T>>>
for Resource<Err, M, T>
impl<Err, M, T>
IntoServiceFactory<
ResourceServiceFactory<Err, M, PipelineFactory<T, WebRequest<Err>>>,
WebRequest<Err>,
> for Resource<Err, M, T>
where
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
> + 'static,
M: Transform<ResourceService<T::Service, Err>> + 'static,
M::Service: Service<
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
>,
M::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
Err: ErrorRenderer,
{
fn into_factory(self) -> ResourceServiceFactory<Err, M, PipelineFactory<T>> {
fn into_factory(
self,
) -> ResourceServiceFactory<Err, M, PipelineFactory<T, WebRequest<Err>>> {
let router_factory = ResourceRouterFactory {
routes: self.routes,
data: self.data.map(Rc::new),
@ -420,17 +417,13 @@ pub struct ResourceServiceFactory<Err: ErrorRenderer, M, T> {
routing: ResourceRouterFactory<Err>,
}
impl<Err, M, F> ServiceFactory for ResourceServiceFactory<Err, M, F>
impl<Err, M, F> ServiceFactory<WebRequest<Err>> for ResourceServiceFactory<Err, M, F>
where
M: Transform<ResourceService<F::Service, Err>> + 'static,
M::Service: Service<
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
>,
M::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
F: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -438,7 +431,6 @@ where
Err: ErrorRenderer,
{
type Config = ();
type Request = WebRequest<Err>;
type Response = WebResponse;
type Error = Err::Container;
type Service = M::Service;
@ -463,16 +455,11 @@ pub struct ResourceService<F, Err: ErrorRenderer> {
routing: Rc<ResourceRouter<Err>>,
}
impl<F, Err> Service for ResourceService<F, Err>
impl<F, Err> Service<WebRequest<Err>> for ResourceService<F, Err>
where
F: Service<
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
>,
F: Service<WebRequest<Err>, Response = WebRequest<Err>, Error = Err::Container>,
Err: ErrorRenderer,
{
type Request = WebRequest<Err>;
type Response = WebResponse;
type Error = Err::Container;
type Future = ResourceServiceResponse<F, Err>;
@ -498,21 +485,17 @@ where
}
pin_project_lite::pin_project! {
pub struct ResourceServiceResponse<F: Service, Err: ErrorRenderer> {
pub struct ResourceServiceResponse<F: Service<WebRequest<Err>>, Err: ErrorRenderer> {
#[pin]
filter: F::Future,
routing: Rc<ResourceRouter<Err>>,
endpoint: Option<<ResourceRouter<Err> as Service>::Future>,
endpoint: Option<<ResourceRouter<Err> as Service<WebRequest<Err>>>::Future>,
}
}
impl<F, Err> Future for ResourceServiceResponse<F, Err>
where
F: Service<
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
>,
F: Service<WebRequest<Err>, Response = WebRequest<Err>, Error = Err::Container>,
Err: ErrorRenderer,
{
type Output = Result<WebResponse, Err::Container>;
@ -540,9 +523,8 @@ struct ResourceRouterFactory<Err: ErrorRenderer> {
default: Rc<RefCell<Option<Rc<HttpNewService<Err>>>>>,
}
impl<Err: ErrorRenderer> ServiceFactory for ResourceRouterFactory<Err> {
impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for ResourceRouterFactory<Err> {
type Config = ();
type Request = WebRequest<Err>;
type Response = WebResponse;
type Error = Err::Container;
type InitError = ();
@ -576,8 +558,7 @@ struct ResourceRouter<Err: ErrorRenderer> {
default: Option<HttpService<Err>>,
}
impl<Err: ErrorRenderer> Service for ResourceRouter<Err> {
type Request = WebRequest<Err>;
impl<Err: ErrorRenderer> Service<WebRequest<Err>> for ResourceRouter<Err> {
type Response = WebResponse;
type Error = Err::Container;
type Future = Either<

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

@ -53,9 +53,8 @@ impl<Err: ErrorRenderer> Route<Err> {
}
}
impl<Err: ErrorRenderer> ServiceFactory for Route<Err> {
impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for Route<Err> {
type Config = ();
type Request = WebRequest<Err>;
type Response = WebResponse;
type Error = Err::Container;
type InitError = ();
@ -88,8 +87,7 @@ impl<Err: ErrorRenderer> RouteService<Err> {
}
}
impl<Err: ErrorRenderer> Service for RouteService<Err> {
type Request = WebRequest<Err>;
impl<Err: ErrorRenderer> Service<WebRequest<Err>> for RouteService<Err> {
type Response = WebResponse;
type Error = Err::Container;
type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;

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

@ -61,7 +61,7 @@ type BoxResponse<Err: ErrorRenderer> =
///
pub struct Scope<Err: ErrorRenderer, M = Identity, T = Filter<Err>> {
middleware: M,
filter: PipelineFactory<T>,
filter: PipelineFactory<T, WebRequest<Err>>,
rdef: Vec<String>,
data: Option<Extensions>,
services: Vec<Box<dyn AppServiceFactory<Err>>>,
@ -91,8 +91,8 @@ impl<Err: ErrorRenderer> Scope<Err> {
impl<Err, M, T> Scope<Err, M, T>
where
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -292,10 +292,10 @@ where
/// If default resource is not registered, app's default resource is being used.
pub fn default_service<F, S>(mut self, f: F) -> Self
where
F: IntoServiceFactory<S>,
F: IntoServiceFactory<S, WebRequest<Err>>,
S: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
> + 'static,
@ -325,8 +325,8 @@ where
Err,
M,
impl ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -334,13 +334,13 @@ where
>
where
U: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
>,
F: IntoServiceFactory<U>,
F: IntoServiceFactory<U, WebRequest<Err>>,
{
Scope {
filter: self.filter.and_then(filter.into_factory()),
@ -383,18 +383,14 @@ where
impl<Err, M, T> WebServiceFactory<Err> for Scope<Err, M, T>
where
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
> + 'static,
M: Transform<ScopeService<T::Service, Err>> + 'static,
M::Service: Service<
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
>,
M::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
Err: ErrorRenderer,
{
fn register(mut self, config: &mut WebServiceConfig<Err>) {
@ -474,17 +470,13 @@ struct ScopeServiceFactory<M, F, Err: ErrorRenderer> {
routing: ScopeRouterFactory<Err>,
}
impl<M, F, Err> ServiceFactory for ScopeServiceFactory<M, F, Err>
impl<M, F, Err> ServiceFactory<WebRequest<Err>> for ScopeServiceFactory<M, F, Err>
where
M: Transform<ScopeService<F::Service, Err>> + 'static,
M::Service: Service<
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
>,
M::Service: Service<WebRequest<Err>, Response = WebResponse, Error = Err::Container>,
F: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
InitError = (),
@ -492,7 +484,6 @@ where
Err: ErrorRenderer,
{
type Config = ();
type Request = WebRequest<Err>;
type Response = WebResponse;
type Error = Err::Container;
type Service = M::Service;
@ -517,16 +508,11 @@ pub struct ScopeService<F, Err: ErrorRenderer> {
routing: Rc<ScopeRouter<Err>>,
}
impl<F, Err> Service for ScopeService<F, Err>
impl<F, Err> Service<WebRequest<Err>> for ScopeService<F, Err>
where
F: Service<
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
>,
F: Service<WebRequest<Err>, Response = WebRequest<Err>, Error = Err::Container>,
Err: ErrorRenderer,
{
type Request = WebRequest<Err>;
type Response = WebResponse;
type Error = Err::Container;
type Future = ScopeServiceResponse<F, Err>;
@ -552,21 +538,17 @@ where
}
pin_project_lite::pin_project! {
pub struct ScopeServiceResponse<F: Service, Err: ErrorRenderer> {
pub struct ScopeServiceResponse<F: Service<WebRequest<Err>>, Err: ErrorRenderer> {
#[pin]
filter: F::Future,
routing: Rc<ScopeRouter<Err>>,
endpoint: Option<<ScopeRouter<Err> as Service>::Future>,
endpoint: Option<<ScopeRouter<Err> as Service<WebRequest<Err>>>::Future>,
}
}
impl<F, Err> Future for ScopeServiceResponse<F, Err>
where
F: Service<
Request = WebRequest<Err>,
Response = WebRequest<Err>,
Error = Err::Container,
>,
F: Service<WebRequest<Err>, Response = WebRequest<Err>, Error = Err::Container>,
Err: ErrorRenderer,
{
type Output = Result<WebResponse, Err::Container>;
@ -595,9 +577,8 @@ struct ScopeRouterFactory<Err: ErrorRenderer> {
case_insensitive: bool,
}
impl<Err: ErrorRenderer> ServiceFactory for ScopeRouterFactory<Err> {
impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for ScopeRouterFactory<Err> {
type Config = ();
type Request = WebRequest<Err>;
type Response = WebResponse;
type Error = Err::Container;
type InitError = ();
@ -646,8 +627,7 @@ struct ScopeRouter<Err: ErrorRenderer> {
default: Option<HttpService<Err>>,
}
impl<Err: ErrorRenderer> Service for ScopeRouter<Err> {
type Request = WebRequest<Err>;
impl<Err: ErrorRenderer> Service<WebRequest<Err>> for ScopeRouter<Err> {
type Response = WebResponse;
type Error = Err::Container;
type Future = Either<BoxResponse<Err>, Ready<Self::Response, Self::Error>>;

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

@ -9,7 +9,7 @@ use crate::http::{
body::MessageBody, HttpService, KeepAlive, Request, Response, ResponseError,
};
use crate::server::{Server, ServerBuilder};
use crate::{service::map_config, IntoServiceFactory, Service, ServiceFactory};
use crate::{service::map_config, IntoServiceFactory, ServiceFactory};
use crate::{time::Seconds, util::PoolId};
use super::config::AppConfig;
@ -43,11 +43,10 @@ struct Config {
pub struct HttpServer<F, I, S, B>
where
F: Fn() -> I + Send + Clone + 'static,
I: IntoServiceFactory<S>,
S: ServiceFactory<Config = AppConfig, Request = Request>,
I: IntoServiceFactory<S, Request>,
S: ServiceFactory<Request, Config = AppConfig>,
S::Error: ResponseError,
S::InitError: fmt::Debug,
<S::Service as Service>::Future: 'static,
S::Response: Into<Response<B>>,
B: MessageBody,
{
@ -61,13 +60,11 @@ where
impl<F, I, S, B> HttpServer<F, I, S, B>
where
F: Fn() -> I + Send + Clone + 'static,
I: IntoServiceFactory<S>,
S: ServiceFactory<Config = AppConfig, Request = Request>,
S::Error: ResponseError + 'static,
I: IntoServiceFactory<S, Request>,
S: ServiceFactory<Request, Config = AppConfig> + 'static,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Future: 'static,
S::Response: Into<Response<B>> + 'static,
<S::Service as Service>::Future: 'static,
S::Response: Into<Response<B>>,
B: MessageBody + 'static,
{
/// Create new http server with application factory
@ -508,8 +505,8 @@ where
impl<F, I, S, B> HttpServer<F, I, S, B>
where
F: Fn() -> I + Send + Clone + 'static,
I: IntoServiceFactory<S>,
S: ServiceFactory<Config = AppConfig, Request = Request>,
I: IntoServiceFactory<S, Request>,
S: ServiceFactory<Request, Config = AppConfig>,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>>,

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

@ -134,10 +134,10 @@ impl<Err: ErrorRenderer> WebServiceConfig<Err> {
factory: F,
nested: Option<Rc<ResourceMap>>,
) where
F: IntoServiceFactory<S>,
F: IntoServiceFactory<S, WebRequest<Err>>,
S: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
InitError = (),
@ -217,10 +217,10 @@ impl WebServiceAdapter {
/// Set a service factory implementation and generate web service.
pub fn finish<T, F, Err>(self, service: F) -> impl WebServiceFactory<Err>
where
F: IntoServiceFactory<T>,
F: IntoServiceFactory<T, WebRequest<Err>>,
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
InitError = (),
@ -246,8 +246,8 @@ struct WebServiceImpl<T> {
impl<T, Err> WebServiceFactory<Err> for WebServiceImpl<T>
where
T: ServiceFactory<
WebRequest<Err>,
Config = (),
Request = WebRequest<Err>,
Response = WebResponse,
Error = Err::Container,
InitError = (),

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

@ -31,22 +31,17 @@ use crate::web::rmap::ResourceMap;
use crate::web::{FromRequest, HttpResponse, Responder, WebRequest, WebResponse};
/// Create service that always responds with `HttpResponse::Ok()`
pub fn ok_service<Err: ErrorRenderer>() -> impl Service<
Request = WebRequest<Err>,
Response = WebResponse,
Error = std::convert::Infallible,
> {
pub fn ok_service<Err: ErrorRenderer>(
) -> impl Service<WebRequest<Err>, Response = WebResponse, Error = std::convert::Infallible>
{
default_service::<Err>(StatusCode::OK)
}
/// Create service that responds with response with specified status code
pub fn default_service<Err: ErrorRenderer>(
status_code: StatusCode,
) -> impl Service<
Request = WebRequest<Err>,
Response = WebResponse,
Error = std::convert::Infallible,
> {
) -> impl Service<WebRequest<Err>, Response = WebResponse, Error = std::convert::Infallible>
{
(move |req: WebRequest<Err>| {
Ready::Ok(req.into_response(HttpResponse::build(status_code).finish()))
})
@ -78,15 +73,10 @@ pub fn default_service<Err: ErrorRenderer>(
/// ```
pub async fn init_service<R, S, E>(
app: R,
) -> impl Service<Request = Request, Response = WebResponse, Error = E>
) -> impl Service<Request, Response = WebResponse, Error = E>
where
R: IntoServiceFactory<S>,
S: ServiceFactory<
Config = AppConfig,
Request = Request,
Response = WebResponse,
Error = E,
>,
R: IntoServiceFactory<S, Request>,
S: ServiceFactory<Request, Config = AppConfig, Response = WebResponse, Error = E>,
S::InitError: std::fmt::Debug,
{
let srv = app.into_factory();
@ -118,7 +108,7 @@ where
/// ```
pub async fn call_service<S, R, E>(app: &S, req: R) -> S::Response
where
S: Service<Request = R, Response = WebResponse, Error = E>,
S: Service<R, Response = WebResponse, Error = E>,
E: std::fmt::Debug,
{
app.call(req).await.unwrap()
@ -151,7 +141,7 @@ where
/// ```
pub async fn read_response<S>(app: &S, req: Request) -> Bytes
where
S: Service<Request = Request, Response = WebResponse>,
S: Service<Request, Response = WebResponse>,
{
let mut resp = app
.call(req)
@ -250,7 +240,7 @@ where
/// ```
pub async fn read_response_json<S, T>(app: &S, req: Request) -> T
where
S: Service<Request = Request, Response = WebResponse>,
S: Service<Request, Response = WebResponse>,
T: DeserializeOwned,
{
let body = read_response::<S>(app, req).await;
@ -552,12 +542,11 @@ impl TestRequest {
pub fn server<F, I, S, B>(factory: F) -> TestServer
where
F: Fn() -> I + Send + Clone + 'static,
I: IntoServiceFactory<S>,
S: ServiceFactory<Config = AppConfig, Request = Request> + 'static,
S::Error: ResponseError + 'static,
I: IntoServiceFactory<S, Request>,
S: ServiceFactory<Request, Config = AppConfig> + 'static,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Response: Into<HttpResponse<B>> + 'static,
<S::Service as Service>::Future: 'static,
S::Response: Into<HttpResponse<B>>,
B: MessageBody + 'static,
{
server_with(TestServerConfig::default(), factory)
@ -591,12 +580,11 @@ where
pub fn server_with<F, I, S, B>(cfg: TestServerConfig, factory: F) -> TestServer
where
F: Fn() -> I + Send + Clone + 'static,
I: IntoServiceFactory<S>,
S: ServiceFactory<Config = AppConfig, Request = Request> + 'static,
S::Error: ResponseError + 'static,
I: IntoServiceFactory<S, Request>,
S: ServiceFactory<Request, Config = AppConfig> + 'static,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Response: Into<HttpResponse<B>> + 'static,
<S::Service as Service>::Future: 'static,
S::Response: Into<HttpResponse<B>>,
B: MessageBody + 'static,
{
let (tx, rx) = mpsc::channel();

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

@ -7,7 +7,7 @@ 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};
use crate::{IntoServiceFactory, ServiceFactory};
use super::config::AppConfig;
use super::error::ErrorRenderer;
@ -285,13 +285,11 @@ where
pub fn server<F, I, S, B>(factory: F) -> HttpServer<F, I, S, B>
where
F: Fn() -> I + Send + Clone + 'static,
I: IntoServiceFactory<S>,
S: ServiceFactory<Config = AppConfig, Request = Request>,
S::Error: ResponseError + 'static,
I: IntoServiceFactory<S, Request>,
S: ServiceFactory<Request, Config = AppConfig> + 'static,
S::Error: ResponseError,
S::InitError: fmt::Debug,
S::Response: Into<Response<B>> + 'static,
S::Future: 'static,
<S::Service as Service>::Future: 'static,
S::Response: Into<Response<B>>,
B: MessageBody + 'static,
{
HttpServer::new(factory)

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

@ -20,13 +20,10 @@ pub async fn start<T, F, S, Err>(
factory: F,
) -> Result<HttpResponse, Err>
where
T: ServiceFactory<
Config = WebSocketsSink,
Request = Frame,
Response = Option<Message>,
> + 'static,
T: ServiceFactory<Frame, Config = WebSocketsSink, Response = Option<Message>>
+ 'static,
T::Error: error::Error,
F: IntoServiceFactory<T>,
F: IntoServiceFactory<T, Frame>,
S: Stream<Item = Result<Bytes, PayloadError>> + Unpin + 'static,
Err: From<T::InitError> + From<HandshakeError>,
{
@ -44,13 +41,10 @@ pub async fn start_with<T, F, S, Err, Tx, Rx>(
factory: F,
) -> Result<HttpResponse, Err>
where
T: ServiceFactory<
Config = ws::StreamEncoder<Tx>,
Request = Frame,
Response = Option<Message>,
> + 'static,
T: ServiceFactory<Frame, Config = ws::StreamEncoder<Tx>, Response = Option<Message>>
+ 'static,
T::Error: error::Error,
F: IntoServiceFactory<T>,
F: IntoServiceFactory<T, Frame>,
S: Stream<Item = Result<Bytes, PayloadError>> + Unpin + 'static,
Err: From<T::InitError> + From<HandshakeError>,
Tx: Sink<Result<Bytes, Box<dyn error::Error>>> + Clone + Unpin + 'static,

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

@ -61,7 +61,7 @@ impl WsClient<Base, ()> {
uri: U,
) -> WsClientBuilder<
Base,
impl Service<Request = Connect<Uri>, Response = Io, Error = ConnectError>,
impl Service<Connect<Uri>, Response = Io, Error = ConnectError>,
>
where
Uri: TryFrom<U>,
@ -76,7 +76,7 @@ impl WsClient<Base, ()> {
Uri: TryFrom<U>,
<Uri as TryFrom<U>>::Error: Into<HttpError>,
F: Filter,
T: Service<Request = Connect<Uri>, Response = Io<F>, Error = ConnectError>,
T: Service<Connect<Uri>, Response = Io<F>, Error = ConnectError>,
{
WsClientBuilder::new(uri).connector(connector)
}
@ -131,7 +131,7 @@ impl<F, T> WsClient<F, T> {
impl<F, T> WsClient<F, T>
where
F: Filter,
T: Service<Request = Connect<Uri>, Response = Io<F>, Error = ConnectError>,
T: Service<Connect<Uri>, Response = Io<F>, Error = ConnectError>,
{
/// Complete request construction and connect to a websockets server.
pub fn connect(
@ -277,7 +277,7 @@ impl WsClientBuilder<Base, ()> {
uri: U,
) -> WsClientBuilder<
Base,
impl Service<Request = Connect<Uri>, Response = Io, Error = ConnectError>,
impl Service<Connect<Uri>, Response = Io, Error = ConnectError>,
>
where
Uri: TryFrom<U>,
@ -315,7 +315,7 @@ impl WsClientBuilder<Base, ()> {
impl<F, T> WsClientBuilder<F, T>
where
T: Service<Request = Connect<Uri>, Response = Io<F>, Error = ConnectError>,
T: Service<Connect<Uri>, Response = Io<F>, Error = ConnectError>,
{
/// Set socket address of the server.
///
@ -494,7 +494,7 @@ where
pub fn connector<F1, T1>(&mut self, connector: T1) -> WsClientBuilder<F1, T1>
where
F1: Filter,
T1: Service<Request = Connect<Uri>, Response = Io<F1>, Error = ConnectError>,
T1: Service<Connect<Uri>, Response = Io<F1>, Error = ConnectError>,
{
let inner = self.inner.take().expect("cannot reuse WsClient builder");
@ -734,8 +734,8 @@ impl WsConnection<Sealed> {
/// Start client websockets service.
pub async fn start<T, U>(self, service: U) -> Result<(), WsError<T::Error>>
where
T: Service<Request = ws::Frame, Response = Option<ws::Message>> + 'static,
U: IntoService<T>,
T: Service<ws::Frame, Response = Option<ws::Message>> + 'static,
U: IntoService<T, ws::Frame>,
{
let service = apply_fn(
service.into_service().map_err(WsError::Service),