add configuration parameter to transform factory

actix-service/src/and_then_apply.rs

@@ -169,7 +169,7 @@ impl<T, A, B, C> NewService<C> for AndThenTransformNewService<T, A, B, C>
 where
     A: NewService<C>,
     B: NewService<C, Error = A::Error, InitError = A::InitError>,
-    T: NewTransform<B::Service, Request = A::Response, InitError = A::InitError>,
+    T: NewTransform<B::Service, C, Request = A::Response, InitError = A::InitError>,
     T::Error: From<A::Error>,
 {
     type Request = A::Request;
@@ -187,7 +187,7 @@ where
             t: None,
             fut_a: self.a.new_service(cfg),
             fut_b: self.b.new_service(cfg),
-            fut_t: self.t.new_transform(),
+            fut_t: self.t.new_transform(cfg),
         }
     }
 }
@@ -196,7 +196,7 @@ pub struct AndThenTransformNewServiceFuture<T, A, B, C>
 where
     A: NewService<C>,
     B: NewService<C, Error = A::Error, InitError = A::InitError>,
-    T: NewTransform<B::Service, Request = A::Response, InitError = A::InitError>,
+    T: NewTransform<B::Service, C, Request = A::Response, InitError = A::InitError>,
     T::Error: From<A::Error>,
 {
     fut_b: B::Future,
@@ -211,7 +211,7 @@ impl<T, A, B, C> Future for AndThenTransformNewServiceFuture<T, A, B, C>
 where
     A: NewService<C>,
     B: NewService<C, Error = A::Error, InitError = A::InitError>,
-    T: NewTransform<B::Service, Request = A::Response, InitError = A::InitError>,
+    T: NewTransform<B::Service, C, Request = A::Response, InitError = A::InitError>,
     T::Error: From<A::Error>,
 {
     type Item = AndThenTransform<T::Transform, A::Service, B::Service>;

actix-service/src/apply.rs

@@ -89,7 +89,7 @@ where
 /// `ApplyNewService` new service combinator
 pub struct ApplyNewService<T, S, C>
 where
-    T: NewTransform<S::Service, InitError = S::InitError>,
+    T: NewTransform<S::Service, C, InitError = S::InitError>,
     T::Error: From<S::Error>,
     S: NewService<C>,
 {
@@ -100,12 +100,12 @@ where
 
 impl<T, S, C> ApplyNewService<T, S, C>
 where
-    T: NewTransform<S::Service, InitError = S::InitError>,
+    T: NewTransform<S::Service, C, InitError = S::InitError>,
     T::Error: From<S::Error>,
     S: NewService<C>,
 {
     /// Create new `ApplyNewService` new service instance
-    pub fn new<T1: IntoNewTransform<T, S::Service>, S1: IntoNewService<S, C>>(
+    pub fn new<T1: IntoNewTransform<T, S::Service, C>, S1: IntoNewService<S, C>>(
         transform: T1,
         service: S1,
     ) -> Self {
@@ -118,7 +118,7 @@ where
 }
 
 impl<F, S, In, Out, Cfg>
-    ApplyNewService<FnNewTransform<F, S::Service, In, Out, S::InitError>, S, Cfg>
+    ApplyNewService<FnNewTransform<F, S::Service, In, Out, S::InitError, Cfg>, S, Cfg>
 where
     F: FnMut(In, &mut S::Service) -> Out + Clone,
     Out: IntoFuture,
@@ -137,7 +137,7 @@ where
 
 impl<T, S, C> Clone for ApplyNewService<T, S, C>
 where
-    T: NewTransform<S::Service, InitError = S::InitError> + Clone,
+    T: NewTransform<S::Service, C, InitError = S::InitError> + Clone,
     T::Error: From<S::Error>,
     S: NewService<C> + Clone,
 {
@@ -152,7 +152,7 @@ where
 
 impl<T, S, C> NewService<C> for ApplyNewService<T, S, C>
 where
-    T: NewTransform<S::Service, InitError = S::InitError>,
+    T: NewTransform<S::Service, C, InitError = S::InitError>,
     T::Error: From<S::Error>,
     S: NewService<C>,
 {
@@ -166,7 +166,7 @@ where
 
     fn new_service(&self, cfg: &C) -> Self::Future {
         ApplyNewServiceFuture {
-            fut_t: self.transform.new_transform(),
+            fut_t: self.transform.new_transform(cfg),
             fut_s: self.service.new_service(cfg),
             service: None,
             transform: None,
@@ -176,7 +176,7 @@ where
 
 pub struct ApplyNewServiceFuture<T, S, C>
 where
-    T: NewTransform<S::Service, InitError = S::InitError>,
+    T: NewTransform<S::Service, C, InitError = S::InitError>,
     T::Error: From<S::Error>,
     S: NewService<C>,
 {
@@ -188,7 +188,7 @@ where
 
 impl<T, S, C> Future for ApplyNewServiceFuture<T, S, C>
 where
-    T: NewTransform<S::Service, InitError = S::InitError>,
+    T: NewTransform<S::Service, C, InitError = S::InitError>,
     T::Error: From<S::Error>,
     S: NewService<C>,
 {

actix-service/src/fn_service.rs

@@ -3,7 +3,8 @@ use std::marker::PhantomData;
 use futures::future::{ok, FutureResult};
 use futures::{Async, IntoFuture, Poll};
 
-use super::{IntoConfigurableNewService, IntoNewService, IntoService, NewService, Service};
+use crate::Never;
+use crate::{IntoConfigurableNewService, IntoNewService, IntoService, NewService, Service};
 
 /// Create `NewService` for function that can act as Service
 pub fn fn_service<F, Req, Out, Cfg>(f: F) -> FnNewService<F, Req, Out, Cfg>
@@ -124,7 +125,7 @@ where
     type Error = Out::Error;
     type Service = FnService<F, Req, Out>;
 
-    type InitError = ();
+    type InitError = Never;
     type Future = FutureResult<Self::Service, Self::InitError>;
 
     fn new_service(&self, _: &Cfg) -> Self::Future {

actix-service/src/fn_transform.rs

@@ -3,7 +3,7 @@ use std::marker::PhantomData;
 use futures::future::{ok, FutureResult};
 use futures::{Async, IntoFuture, Poll};
 
-use super::{IntoNewTransform, IntoTransform, NewTransform, Transform};
+use crate::{IntoNewTransform, IntoTransform, NewTransform, Transform};
 
 pub struct FnTransform<F, S, Req, Res>
 where
@@ -66,16 +66,16 @@ where
     }
 }
 
-pub struct FnNewTransform<F, S, Req, Out, Err>
+pub struct FnNewTransform<F, S, Req, Out, Err, Cfg>
 where
     F: FnMut(Req, &mut S) -> Out + Clone,
     Out: IntoFuture,
 {
     f: F,
-    _t: PhantomData<(S, Req, Out, Err)>,
+    _t: PhantomData<(S, Req, Out, Err, Cfg)>,
 }
 
-impl<F, S, Req, Res, Err> FnNewTransform<F, S, Req, Res, Err>
+impl<F, S, Req, Res, Err, Cfg> FnNewTransform<F, S, Req, Res, Err, Cfg>
 where
     F: FnMut(Req, &mut S) -> Res + Clone,
     Res: IntoFuture,
@@ -85,7 +85,7 @@ where
     }
 }
 
-impl<F, S, Req, Res, Err> NewTransform<S> for FnNewTransform<F, S, Req, Res, Err>
+impl<F, S, Req, Res, Err, Cfg> NewTransform<S, Cfg> for FnNewTransform<F, S, Req, Res, Err, Cfg>
 where
     F: FnMut(Req, &mut S) -> Res + Clone,
     Res: IntoFuture,
@@ -97,22 +97,23 @@ where
     type InitError = Err;
     type Future = FutureResult<Self::Transform, Self::InitError>;
 
-    fn new_transform(&self) -> Self::Future {
+    fn new_transform(&self, _: &Cfg) -> Self::Future {
         ok(FnTransform::new(self.f.clone()))
     }
 }
 
-impl<F, S, Req, Res, Err> IntoNewTransform<FnNewTransform<F, S, Req, Res, Err>, S> for F
+impl<F, S, Req, Res, Err, Cfg>
+    IntoNewTransform<FnNewTransform<F, S, Req, Res, Err, Cfg>, S, Cfg> for F
 where
     F: FnMut(Req, &mut S) -> Res + Clone,
     Res: IntoFuture,
 {
-    fn into_new_transform(self) -> FnNewTransform<F, S, Req, Res, Err> {
+    fn into_new_transform(self) -> FnNewTransform<F, S, Req, Res, Err, Cfg> {
         FnNewTransform::new(self)
     }
 }
 
-impl<F, S, Req, Res, Err> Clone for FnNewTransform<F, S, Req, Res, Err>
+impl<F, S, Req, Res, Err, Cfg> Clone for FnNewTransform<F, S, Req, Res, Err, Cfg>
 where
     F: FnMut(Req, &mut S) -> Res + Clone,
     Res: IntoFuture,

actix-service/src/lib.rs

@@ -33,6 +33,9 @@ pub use self::map_init_err::MapInitErr;
 pub use self::then::{Then, ThenNewService};
 pub use self::transform::{IntoNewTransform, IntoTransform, NewTransform, Transform};
 
+#[derive(Copy, Clone, Debug)]
+pub enum Never {}
+
 /// An asynchronous function from `Request` to a `Response`.
 pub trait Service {
     /// Requests handled by the service.
@@ -189,7 +192,7 @@ impl<T: ?Sized> ServiceExt for T where T: Service {}
 /// `NewService` trait, and uses that new `Service` value to process inbound
 /// requests on that new TCP stream.
 ///
-/// `Config` parameter defines service factory configuration type.
+/// `Config` is a service factory configuration type.
 pub trait NewService<Config = ()> {
     /// Requests handled by the service.
     type Request;

actix-service/src/transform.rs

@@ -1,3 +1,6 @@
+use std::rc::Rc;
+use std::sync::Arc;
+
 use futures::{Future, Poll};
 
 use crate::transform_map_err::{TransformMapErr, TransformMapErrNewTransform};
@@ -44,7 +47,9 @@ pub trait Transform<Service> {
 }
 
 /// `Transform` service factory
-pub trait NewTransform<Service> {
+///
+/// `Config` is a service factory configuration type.
+pub trait NewTransform<Service, Config = ()> {
     /// Requests handled by the service.
     type Request;
 
@@ -69,11 +74,11 @@ pub trait NewTransform<Service> {
     type Future: Future<Item = Self::Transform, Error = Self::InitError>;
 
     /// Create and return a new service value asynchronously.
-    fn new_transform(&self) -> Self::Future;
+    fn new_transform(&self, cfg: &Config) -> Self::Future;
 
     /// Map this transforms's output to a different type, returning a new transform
     /// of the resulting type.
-    fn map_err<F, E>(self, f: F) -> TransformMapErrNewTransform<Self, Service, F, E>
+    fn map_err<F, E>(self, f: F) -> TransformMapErrNewTransform<Self, Service, Config, F, E>
     where
         Self: Sized,
         F: Fn(Self::Error) -> E,
@@ -120,6 +125,38 @@ where
     }
 }
 
+impl<S, C, T> NewTransform<S, C> for Rc<T>
+where
+    T: NewTransform<S, C>,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Transform = T::Transform;
+    type InitError = T::InitError;
+    type Future = T::Future;
+
+    fn new_transform(&self, cfg: &C) -> T::Future {
+        self.as_ref().new_transform(cfg)
+    }
+}
+
+impl<S, C, T> NewTransform<S, C> for Arc<T>
+where
+    T: NewTransform<S, C>,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Transform = T::Transform;
+    type InitError = T::InitError;
+    type Future = T::Future;
+
+    fn new_transform(&self, cfg: &C) -> T::Future {
+        self.as_ref().new_transform(cfg)
+    }
+}
+
 /// Trait for types that can be converted to a `TransformService`
 pub trait IntoTransform<T, S>
 where
@@ -130,9 +167,9 @@ where
 }
 
 /// Trait for types that can be converted to a TransfromNewService
-pub trait IntoNewTransform<T, S>
+pub trait IntoNewTransform<T, S, C = ()>
 where
-    T: NewTransform<S>,
+    T: NewTransform<S, C>,
 {
     /// Convert to an `TranformNewService`
     fn into_new_transform(self) -> T;
@@ -147,9 +184,9 @@ where
     }
 }
 
-impl<T, S> IntoNewTransform<T, S> for T
+impl<T, S, C> IntoNewTransform<T, S, C> for T
 where
-    T: NewTransform<S>,
+    T: NewTransform<S, C>,
 {
     fn into_new_transform(self) -> T {
         self

actix-service/src/transform_map_err.rs

@@ -98,17 +98,17 @@ where
 /// transform's error.
 ///
 /// This is created by the `NewTransform::map_err` method.
-pub struct TransformMapErrNewTransform<T, S, F, E> {
+pub struct TransformMapErrNewTransform<T, S, C, F, E> {
     t: T,
     f: F,
-    e: PhantomData<(S, E)>,
+    e: PhantomData<(S, C, E)>,
 }
 
-impl<T, S, F, E> TransformMapErrNewTransform<T, S, F, E> {
+impl<T, S, C, F, E> TransformMapErrNewTransform<T, S, C, F, E> {
     /// Create new `MapErr` new service instance
     pub fn new(t: T, f: F) -> Self
     where
-        T: NewTransform<S>,
+        T: NewTransform<S, C>,
         F: Fn(T::Error) -> E,
     {
         Self {
@@ -119,7 +119,7 @@ impl<T, S, F, E> TransformMapErrNewTransform<T, S, F, E> {
     }
 }
 
-impl<T, S, F, E> Clone for TransformMapErrNewTransform<T, S, F, E>
+impl<T, S, C, F, E> Clone for TransformMapErrNewTransform<T, S, C, F, E>
 where
     T: Clone,
     F: Clone,
@@ -133,9 +133,9 @@ where
     }
 }
 
-impl<T, S, F, E> NewTransform<S> for TransformMapErrNewTransform<T, S, F, E>
+impl<T, S, C, F, E> NewTransform<S, C> for TransformMapErrNewTransform<T, S, C, F, E>
 where
-    T: NewTransform<S>,
+    T: NewTransform<S, C>,
     F: Fn(T::Error) -> E + Clone,
 {
     type Request = T::Request;
@@ -144,25 +144,25 @@ where
     type Transform = TransformMapErr<T::Transform, S, F, E>;
 
     type InitError = T::InitError;
-    type Future = TransformMapErrNewTransformFuture<T, S, F, E>;
+    type Future = TransformMapErrNewTransformFuture<T, S, C, F, E>;
 
-    fn new_transform(&self) -> Self::Future {
+    fn new_transform(&self, cfg: &C) -> Self::Future {
-        TransformMapErrNewTransformFuture::new(self.t.new_transform(), self.f.clone())
+        TransformMapErrNewTransformFuture::new(self.t.new_transform(cfg), self.f.clone())
     }
 }
 
-pub struct TransformMapErrNewTransformFuture<T, S, F, E>
+pub struct TransformMapErrNewTransformFuture<T, S, C, F, E>
 where
-    T: NewTransform<S>,
+    T: NewTransform<S, C>,
     F: Fn(T::Error) -> E,
 {
     fut: T::Future,
     f: F,
 }
 
-impl<T, S, F, E> TransformMapErrNewTransformFuture<T, S, F, E>
+impl<T, S, C, F, E> TransformMapErrNewTransformFuture<T, S, C, F, E>
 where
-    T: NewTransform<S>,
+    T: NewTransform<S, C>,
     F: Fn(T::Error) -> E,
 {
     fn new(fut: T::Future, f: F) -> Self {
@@ -170,9 +170,9 @@ where
     }
 }
 
-impl<T, S, F, E> Future for TransformMapErrNewTransformFuture<T, S, F, E>
+impl<T, S, C, F, E> Future for TransformMapErrNewTransformFuture<T, S, C, F, E>
 where
-    T: NewTransform<S>,
+    T: NewTransform<S, C>,
     F: Fn(T::Error) -> E + Clone,
 {
     type Item = TransformMapErr<T::Transform, S, F, E>;

actix-utils/src/lib.rs

@@ -10,6 +10,3 @@ pub mod order;
 pub mod stream;
 pub mod time;
 pub mod timeout;
-
-#[derive(Copy, Clone, Debug)]
-pub enum Never {}