migrate ntex-io

ntex-io/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [0.1.0-b.5] - 2021-12-23
+
+* Add `SealedService` and `SealedFactory` helpers
+
 ## [0.1.0-b.4] - 2021-12-23
 
 * Introduce `Sealed` type instead of `Box<dyn Filter>`

ntex-io/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-io"
-version = "0.1.0-b.4"
+version = "0.1.0-b.5"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Utilities for encoding and decoding frames"
 keywords = ["network", "framework", "async", "futures"]
@@ -29,7 +29,7 @@ bitflags = "1.3"
 ntex-codec = "0.6.0"
 ntex-bytes = "0.1.8"
 ntex-util = "0.1.4"
-ntex-service = "0.2.1"
+ntex-service = "0.3.0"
 fxhash = "0.2.1"
 log = "0.4"
 pin-project-lite = "0.2"

ntex-io/src/dispatcher.rs

@@ -16,7 +16,7 @@ pin_project_lite::pin_project! {
     /// and pass then to the service.
     pub struct Dispatcher<S, U>
     where
-        S: Service<Request = DispatchItem<U>, Response = Option<Response<U>>>,
+        S: Service<DispatchItem<U>, Response = Option<Response<U>>>,
         S: 'static,
         U: Encoder,
         U: Decoder,
@@ -30,7 +30,7 @@ pin_project_lite::pin_project! {
 
 struct DispatcherInner<S, U>
 where
-    S: Service<Request = DispatchItem<U>, Response = Option<Response<U>>>,
+    S: Service<DispatchItem<U>, Response = Option<Response<U>>>,
     U: Encoder + Decoder,
 {
     io: IoBoxed,
@@ -46,7 +46,7 @@ where
 
 struct DispatcherShared<S, U>
 where
-    S: Service<Request = DispatchItem<U>, Response = Option<Response<U>>>,
+    S: Service<DispatchItem<U>, Response = Option<Response<U>>>,
     U: Encoder + Decoder,
 {
     codec: U,
@@ -85,11 +85,11 @@ impl<S, U> From<Either<S, U>> for DispatcherError<S, U> {
 
 impl<S, U> Dispatcher<S, U>
 where
-    S: Service<Request = DispatchItem<U>, Response = Option<Response<U>>> + 'static,
+    S: Service<DispatchItem<U>, Response = Option<Response<U>>> + 'static,
     U: Decoder + Encoder + 'static,
 {
     /// Construct new `Dispatcher` instance.
-    pub fn new<F: IntoService<S>>(
+    pub fn new<F: IntoService<S, DispatchItem<U>>>(
         io: IoBoxed,
         codec: U,
         service: F,
@@ -158,7 +158,7 @@ where
 
 impl<S, U> DispatcherShared<S, U>
 where
-    S: Service<Request = DispatchItem<U>, Response = Option<Response<U>>> + 'static,
+    S: Service<DispatchItem<U>, Response = Option<Response<U>>> + 'static,
     U: Encoder + Decoder + 'static,
 {
     fn handle_result(&self, item: Result<S::Response, S::Error>, io: &IoRef) {
@@ -178,7 +178,7 @@ where
 
 impl<S, U> future::Future for Dispatcher<S, U>
 where
-    S: Service<Request = DispatchItem<U>, Response = Option<Response<U>>> + 'static,
+    S: Service<DispatchItem<U>, Response = Option<Response<U>>> + 'static,
     U: Decoder + Encoder + 'static,
 {
     type Output = Result<(), S::Error>;
@@ -335,7 +335,7 @@ where
 
 impl<S, U> DispatcherInner<S, U>
 where
-    S: Service<Request = DispatchItem<U>, Response = Option<Response<U>>> + 'static,
+    S: Service<DispatchItem<U>, Response = Option<Response<U>>> + 'static,
     U: Decoder + Encoder + 'static,
 {
     /// spawn service call

ntex-io/src/lib.rs

@@ -29,7 +29,9 @@ pub use self::io::{Io, IoRef, OnDisconnect};
 pub use self::tasks::{ReadContext, WriteContext};
 pub use self::time::Timer;
 
-pub use self::utils::{filter_factory, seal};
+pub use self::utils::{
+    filter_factory, seal, sealed_service, SealedFactory, SealedService,
+};
 
 pub type IoBoxed = Io<Sealed>;
 
@@ -151,15 +153,15 @@ pub mod rt {
 pub fn into_boxed<F, S>(
     srv: S,
 ) -> impl ntex_service::ServiceFactory<
+    Io<F>,
     Config = S::Config,
-    Request = Io<F>,
     Response = S::Response,
     Error = S::Error,
     InitError = S::InitError,
 >
 where
     F: Filter + 'static,
-    S: ntex_service::ServiceFactory<Request = IoBoxed>,
+    S: ntex_service::ServiceFactory<IoBoxed>,
 {
     seal(srv)
 }

ntex-io/src/utils.rs

@@ -1,7 +1,7 @@
-use std::{marker::PhantomData, task::Context, task::Poll};
+use std::{future::Future, marker::PhantomData, pin::Pin, task::Context, task::Poll};
 
 use ntex_service::{fn_factory_with_config, into_service, Service, ServiceFactory};
-use ntex_util::future::Ready;
+use ntex_util::{future::Ready, ready};
 
 use super::{Filter, FilterFactory, Io, IoBoxed};
 
@@ -9,15 +9,15 @@ use super::{Filter, FilterFactory, Io, IoBoxed};
 pub fn seal<F, S>(
     srv: S,
 ) -> impl ServiceFactory<
+    Io<F>,
     Config = S::Config,
-    Request = Io<F>,
     Response = S::Response,
     Error = S::Error,
     InitError = S::InitError,
 >
 where
     F: Filter + 'static,
-    S: ServiceFactory<Request = IoBoxed>,
+    S: ServiceFactory<IoBoxed>,
 {
     fn_factory_with_config(move |cfg: S::Config| {
         let fut = srv.new_service(cfg);
@@ -28,6 +28,18 @@ where
     })
 }
 
+/// Service that converts Io<F> responses from service to the IoBoxed
+pub fn sealed_service<S, R, F>(inner: S) -> SealedService<S, R>
+where
+    F: Filter,
+    S: Service<R, Response = Io<F>>,
+{
+    SealedService {
+        inner,
+        _t: PhantomData,
+    }
+}
+
 /// Create filter factory service
 pub fn filter_factory<T, F>(filter: T) -> FilterServiceFactory<T, F>
 where
@@ -40,18 +52,140 @@ where
     }
 }
 
+pub struct SealedFactory<S, R> {
+    inner: S,
+    _t: PhantomData<R>,
+}
+
+impl<S, R> SealedFactory<S, R> {
+    pub fn new(inner: S) -> Self {
+        Self {
+            inner,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<S: Clone, R> Clone for SealedFactory<S, R> {
+    fn clone(&self) -> Self {
+        Self::new(self.inner.clone())
+    }
+}
+
+impl<S, R, F> ServiceFactory<R> for SealedFactory<S, R>
+where
+    F: Filter,
+    S: ServiceFactory<R, Response = Io<F>>,
+{
+    type Config = S::Config;
+    type Response = IoBoxed;
+    type Error = S::Error;
+    type Service = SealedService<S::Service, R>;
+    type InitError = S::InitError;
+    type Future = SealedFactoryResponse<S, R>;
+
+    fn new_service(&self, cfg: S::Config) -> Self::Future {
+        SealedFactoryResponse {
+            fut: self.inner.new_service(cfg),
+            _t: PhantomData,
+        }
+    }
+}
+
+pub struct SealedService<S, R> {
+    inner: S,
+    _t: PhantomData<R>,
+}
+
+impl<S, R> SealedService<S, R> {
+    pub fn new(inner: S) -> Self {
+        Self {
+            inner,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<S: Clone, R> Clone for SealedService<S, R> {
+    fn clone(&self) -> Self {
+        Self::new(self.inner.clone())
+    }
+}
+
+impl<S, R, F> Service<R> for SealedService<S, R>
+where
+    F: Filter,
+    S: Service<R, Response = Io<F>>,
+{
+    type Response = IoBoxed;
+    type Error = S::Error;
+    type Future = SealedServiceResponse<S, R>;
+
+    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
+        self.inner.poll_ready(cx)
+    }
+
+    #[inline]
+    fn poll_shutdown(&self, cx: &mut Context<'_>, is_err: bool) -> Poll<()> {
+        self.inner.poll_shutdown(cx, is_err)
+    }
+
+    fn call(&self, req: R) -> Self::Future {
+        SealedServiceResponse {
+            fut: self.inner.call(req),
+        }
+    }
+}
+
+pin_project_lite::pin_project! {
+    pub struct SealedFactoryResponse<S: ServiceFactory<R>, R> {
+        #[pin]
+        fut: S::Future,
+        _t: PhantomData<R>
+    }
+}
+
+impl<S: ServiceFactory<R>, R> Future for SealedFactoryResponse<S, R> {
+    type Output = Result<SealedService<S::Service, R>, S::InitError>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(
+            ready!(self.project().fut.poll(cx)).map(|inner| SealedService {
+                inner,
+                _t: PhantomData,
+            }),
+        )
+    }
+}
+
+pin_project_lite::pin_project! {
+    pub struct SealedServiceResponse<S: Service<R>, R> {
+        #[pin]
+        fut: S::Future,
+    }
+}
+
+impl<S: Service<R, Response = Io<F>>, R, F: Filter> Future
+    for SealedServiceResponse<S, R>
+{
+    type Output = Result<IoBoxed, S::Error>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(ready!(self.project().fut.poll(cx)).map(|io| io.seal()))
+    }
+}
+
 pub struct FilterServiceFactory<T, F> {
     filter: T,
     _t: PhantomData<F>,
 }
 
-impl<T, F> ServiceFactory for FilterServiceFactory<T, F>
+impl<T, F> ServiceFactory<Io<F>> for FilterServiceFactory<T, F>
 where
     T: FilterFactory<F> + Clone,
     F: Filter,
 {
     type Config = ();
-    type Request = Io<F>;
     type Response = Io<T::Filter>;
     type Error = T::Error;
     type Service = FilterService<T, F>;
@@ -71,12 +205,11 @@ pub struct FilterService<T, F> {
     _t: PhantomData<F>,
 }
 
-impl<T, F> Service for FilterService<T, F>
+impl<T, F> Service<Io<F>> for FilterService<T, F>
 where
     T: FilterFactory<F> + Clone,
     F: Filter,
 {
-    type Request = Io<F>;
     type Response = Io<T::Filter>;
     type Error = T::Error;
     type Future = T::Future;