add FramedParts::with_read_buf method

Cargo.toml

@@ -1,18 +1,3 @@
-[package]
-name = "actix-net"
-version = "0.3.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix net - framework for the compisible network services for Rust (experimental)"
-readme = "README.md"
-keywords = ["network", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-net/"
-categories = ["network-programming", "asynchronous"]
-license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
-edition = "2018"
-
 [workspace]
 members = [
   "actix-codec",
@@ -24,14 +9,3 @@ members = [
   "actix-utils",
   "router",
 ]
-
-[dev-dependencies]
-#actix-service = "0.2.0"
-actix-service = { path="actix-service" }
-actix-codec = "0.1.0"
-actix-rt = { path="actix-rt" }
-actix-server = { path="actix-server", features=["ssl"] }
-env_logger = "0.5"
-futures = "0.1.24"
-openssl = { version="0.10" }
-tokio-openssl = { version="0.3" }

actix-codec/CHANGES.md

@@ -1,5 +1,10 @@
 # Changes
 
+## [0.1.0] - 2019-03-06
+
+* Added `FramedParts::with_read_buffer()` method.
+
+
 ## [0.1.0] - 2018-12-09
 
 * Move codec to separate crate

actix-codec/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-codec"
-version = "0.1.0"
+version = "0.1.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Utilities for encoding and decoding frames"
 keywords = ["network", "framework", "async", "futures"]

actix-codec/src/framed.rs

@@ -349,4 +349,17 @@ impl<T, U> FramedParts<T, U> {
             _priv: (),
         }
     }
+
+    /// Create a new `FramedParts` with read buffer
+    pub fn with_read_buf(io: T, codec: U, read_buf: BytesMut) -> FramedParts<T, U> {
+        FramedParts {
+            io,
+            codec,
+            read_buf,
+            write_buf: BytesMut::new(),
+            write_buf_lw: LW,
+            write_buf_hw: HW,
+            _priv: (),
+        }
+    }
 }

actix-connector/CHANGES.md

@@ -1,14 +1,21 @@
 # Changes
 
-## [0.2.0] - 2019-01-xx
+## [0.3.0] - 2019-03-02
 
-### Changes
+### Changed
+
+* Migrate to actix-service 0.3
+
+
+## [0.2.0] - 2019-02-01
+
+### Changed
 
 * Migrate to actix-service 0.2
 
 * Upgrade trust-dns-resolver
 
-* Use tokio-current-thread instead of diract actix-rt dipendency
+* Use tokio-current-thread instead of direct actix-rt dipendency
 
 
 ## [0.1.1] - 2019-01-13

actix-connector/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-connector"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Connector - tcp connector service"
 keywords = ["network", "framework", "async", "futures"]
@@ -11,7 +11,7 @@ categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
-workspace = "../"
+workspace = ".."
 
 [package.metadata.docs.rs]
 features = ["ssl"]
@@ -27,7 +27,7 @@ default = []
 ssl = ["openssl", "tokio-openssl"]
 
 [dependencies]
-#actix-service = "0.1.6"
+#actix-service = "0.3.0"
 actix-service = { path="../actix-service" }
 actix-codec = "0.1.0"
 futures = "0.1"

actix-connector/src/connector.rs

@@ -4,8 +4,8 @@ use std::net::{IpAddr, SocketAddr};
 use std::time::Duration;
 use std::{fmt, io};
 
-use actix_service::{NewService, Service};
+use actix_service::{fn_factory, NewService, Service};
-use futures::future::{ok, Either, FutureResult};
+use futures::future::{ok, Either};
 use futures::{try_ready, Async, Future, Poll};
 use tokio_tcp::{ConnectFuture, TcpStream};
 use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
@@ -167,8 +167,8 @@ impl Connector {
     /// Create new connector with custom resolver
     pub fn with_resolver(
         resolver: Resolver<Connect>,
-    ) -> impl Service<Request = Connect, Response = (Connect, TcpStream), Error = ConnectorError>
+    ) -> impl Service<Connect, Response = (Connect, TcpStream), Error = ConnectorError> + Clone
-                 + Clone {
+    {
         Connector { resolver }
     }
 
@@ -177,12 +177,13 @@ impl Connector {
         cfg: ResolverConfig,
         opts: ResolverOpts,
     ) -> impl NewService<
-        Request = Connect,
+        Connect,
+        (),
         Response = (Connect, TcpStream),
         Error = ConnectorError,
         InitError = E,
     > + Clone {
-        move || -> FutureResult<Connector, E> { ok(Connector::new(cfg.clone(), opts)) }
+        fn_factory(move || ok(Connector::new(cfg.clone(), opts)))
     }
 }
 
@@ -194,8 +195,7 @@ impl Clone for Connector {
     }
 }
 
-impl Service for Connector {
+impl Service<Connect> for Connector {
-    type Request = Connect;
     type Response = (Connect, TcpStream);
     type Error = ConnectorError;
     type Future = Either<ConnectorFuture, ConnectorTcpFuture>;
@@ -272,8 +272,7 @@ impl<T: RequestPort> Default for TcpConnector<T> {
     }
 }
 
-impl<T: RequestPort> Service for TcpConnector<T> {
+impl<T: RequestPort> Service<(T, VecDeque<IpAddr>)> for TcpConnector<T> {
-    type Request = (T, VecDeque<IpAddr>);
     type Response = (T, TcpStream);
     type Error = io::Error;
     type Future = TcpConnectorResponse<T>;
@@ -353,8 +352,7 @@ impl DefaultConnector {
     }
 }
 
-impl Service for DefaultConnector {
+impl Service<Connect> for DefaultConnector {
-    type Request = Connect;
     type Response = TcpStream;
     type Error = ConnectorError;
     type Future = DefaultConnectorFuture;

actix-connector/src/resolver.rs

@@ -67,8 +67,7 @@ impl<T> Clone for Resolver<T> {
     }
 }
 
-impl<T: RequestHost> Service for Resolver<T> {
+impl<T: RequestHost> Service<T> for Resolver<T> {
-    type Request = T;
     type Response = (T, VecDeque<IpAddr>);
     type Error = ResolveError;
     type Future = ResolverFuture<T>;

actix-connector/src/ssl/openssl.rs

@@ -26,8 +26,7 @@ impl<R, T, E> OpensslConnector<R, T, E> {
 impl<R: RequestHost, T: AsyncRead + AsyncWrite> OpensslConnector<R, T, ()> {
     pub fn service(
         connector: SslConnector,
-    ) -> impl Service<Request = (R, T), Response = (R, SslStream<T>), Error = HandshakeError<T>>
+    ) -> impl Service<(R, T), Response = (R, SslStream<T>), Error = HandshakeError<T>> {
-    {
         OpensslConnectorService {
             connector: connector,
             _t: PhantomData,
@@ -44,15 +43,16 @@ impl<R, T, E> Clone for OpensslConnector<R, T, E> {
     }
 }
 
-impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService for OpensslConnector<R, T, E> {
+impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService<(R, T), ()>
-    type Request = (R, T);
+    for OpensslConnector<R, T, E>
+{
     type Response = (R, SslStream<T>);
     type Error = HandshakeError<T>;
     type Service = OpensslConnectorService<R, T>;
     type InitError = E;
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, _: &()) -> Self::Future {
         ok(OpensslConnectorService {
             connector: self.connector.clone(),
             _t: PhantomData,
@@ -65,8 +65,9 @@ pub struct OpensslConnectorService<R, T> {
     _t: PhantomData<(R, T)>,
 }
 
-impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service for OpensslConnectorService<R, T> {
+impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service<(R, T)>
-    type Request = (R, T);
+    for OpensslConnectorService<R, T>
+{
     type Response = (R, SslStream<T>);
     type Error = HandshakeError<T>;
     type Future = ConnectAsyncExt<R, T>;

actix-rt/CHANGES.md

@@ -1,5 +1,11 @@
 # Changes
 
+## [0.2.0] - 2019-03-06
+
+* `run` method returns `io::Result<()>`
+
+* Removed `Handle`
+
 ## [0.1.0] - 2018-12-09
 
 * Initial release

actix-rt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-rt"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix runtime"
 keywords = ["network", "framework", "async", "futures"]
@@ -20,7 +20,7 @@ path = "src/lib.rs"
 [dependencies]
 log = "0.4"
 bytes = "0.4"
-futures = "0.1.24"
+futures = "0.1.25"
 tokio-current-thread = "0.1"
 tokio-executor = "0.1.5"
 tokio-reactor = "0.1.7"

actix-rt/src/builder.rs

@@ -72,7 +72,7 @@ impl Builder {
     /// This function will start tokio runtime and will finish once the
     /// `System::stop()` message get called.
     /// Function `f` get called within tokio runtime context.
-    pub fn run<F>(self, f: F) -> i32
+    pub fn run<F>(self, f: F) -> io::Result<()>
     where
         F: FnOnce() + 'static,
     {
@@ -140,7 +140,7 @@ pub struct SystemRunner {
 impl SystemRunner {
     /// This function will start event loop and will finish once the
     /// `System::stop()` function is called.
-    pub fn run(self) -> i32 {
+    pub fn run(self) -> io::Result<()> {
         let SystemRunner { mut rt, stop, .. } = self;
 
         // run loop
@@ -148,12 +148,21 @@ impl SystemRunner {
             Arbiter::run_system();
             Ok::<_, ()>(())
         }));
-        let code = match rt.block_on(stop) {
+        let result = match rt.block_on(stop) {
-            Ok(code) => code,
+            Ok(code) => {
-            Err(_) => 1,
+                if code != 0 {
+                    Err(io::Error::new(
+                        io::ErrorKind::Other,
+                        format!("Non-zero exit code: {}", code),
+                    ))
+                } else {
+                    Ok(())
+                }
+            }
+            Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
         };
         Arbiter::stop_system();
-        code
+        result
     }
 
     /// Execute a future and wait for result.

actix-rt/src/lib.rs

@@ -7,7 +7,7 @@ mod system;
 
 pub use self::arbiter::Arbiter;
 pub use self::builder::{Builder, SystemRunner};
-pub use self::runtime::{Handle, Runtime};
+pub use self::runtime::Runtime;
 pub use self::system::System;
 
 /// Spawns a future on the current arbiter.

actix-rt/src/runtime.rs

@@ -1,9 +1,7 @@
 use std::error::Error;
-use std::fmt;
+use std::{fmt, io};
-use std::io;
 
-use futures::{future, Future};
+use futures::Future;
-use tokio_current_thread::Handle as ExecutorHandle;
 use tokio_current_thread::{self as current_thread, CurrentThread};
 use tokio_executor;
 use tokio_reactor::{self, Reactor};
@@ -26,58 +24,6 @@ pub struct Runtime {
     executor: CurrentThread<Timer<Reactor>>,
 }
 
-/// Handle to spawn a future on the corresponding `CurrentThread` runtime instance
-#[derive(Debug, Clone)]
-pub struct Handle(ExecutorHandle);
-
-impl Handle {
-    /// Spawn a future onto the `CurrentThread` runtime instance corresponding to this handle
-    ///
-    /// # Panics
-    ///
-    /// This function panics if the spawn fails. Failure occurs if the `CurrentThread`
-    /// instance of the `Handle` does not exist anymore.
-    pub fn spawn<F>(&self, future: F) -> Result<(), tokio_executor::SpawnError>
-    where
-        F: Future<Item = (), Error = ()> + Send + 'static,
-    {
-        self.0.spawn(future)
-    }
-
-    /// Provides a best effort **hint** to whether or not `spawn` will succeed.
-    ///
-    /// This function may return both false positives **and** false negatives.
-    /// If `status` returns `Ok`, then a call to `spawn` will *probably*
-    /// succeed, but may fail. If `status` returns `Err`, a call to `spawn` will
-    /// *probably* fail, but may succeed.
-    ///
-    /// This allows a caller to avoid creating the task if the call to `spawn`
-    /// has a high likelihood of failing.
-    pub fn status(&self) -> Result<(), tokio_executor::SpawnError> {
-        self.0.status()
-    }
-}
-
-impl<T> future::Executor<T> for Handle
-where
-    T: Future<Item = (), Error = ()> + Send + 'static,
-{
-    fn execute(&self, future: T) -> Result<(), future::ExecuteError<T>> {
-        if let Err(e) = self.status() {
-            let kind = if e.is_at_capacity() {
-                future::ExecuteErrorKind::NoCapacity
-            } else {
-                future::ExecuteErrorKind::Shutdown
-            };
-
-            return Err(future::ExecuteError::new(kind, future));
-        }
-
-        let _ = self.spawn(future);
-        Ok(())
-    }
-}
-
 /// Error returned by the `run` function.
 #[derive(Debug)]
 pub struct RunError {
@@ -120,14 +66,6 @@ impl Runtime {
         }
     }
 
-    /// Get a new handle to spawn futures on the single-threaded Tokio runtime
-    ///
-    /// Different to the runtime itself, the handle can be sent to different
-    /// threads.
-    pub fn handle(&self) -> Handle {
-        Handle(self.executor.handle().clone())
-    }
-
     /// Spawn a future onto the single-threaded Tokio runtime.
     ///
     /// See [module level][mod] documentation for more details.

actix-rt/src/system.rs

@@ -1,4 +1,5 @@
 use std::cell::RefCell;
+use std::io;
 
 use futures::sync::mpsc::UnboundedSender;
 
@@ -109,7 +110,7 @@ impl System {
     /// This function will start tokio runtime and will finish once the
     /// `System::stop()` message get called.
     /// Function `f` get called within tokio runtime context.
-    pub fn run<F>(f: F) -> i32
+    pub fn run<F>(f: F) -> io::Result<()>
     where
         F: FnOnce() + 'static,
     {

actix-server/CHANGES.md

@@ -1,8 +1,43 @@
 # Changes
 
-## [0.2.0] - 2019-02-xx
+## [0.4.0] - 2019-03-xx
 
-## Changes
+* Upgrade actix-service
+
+
+## [0.3.1] - 2019-03-04
+
+### Added
+
+* Add `ServerBuilder::maxconnrate` sets the maximum per-worker number of concurrent connections
+
+* Add helper ssl error `SslError`
+
+
+### Changed
+
+* Rename `StreamServiceFactory` to `ServiceFactory`
+
+* Deprecate `StreamServiceFactory`
+
+
+## [0.3.0] - 2019-03-02
+
+### Changed
+
+* Use new `NewService` trait
+
+
+## [0.2.1] - 2019-02-09
+
+### Changed
+
+* Drop service response
+
+
+## [0.2.0] - 2019-02-01
+
+### Changed
 
 * Migrate to actix-service 0.2
 
@@ -11,14 +46,14 @@
 
 ## [0.1.3] - 2018-12-21
 
-## Fixed
+### Fixed
 
 * Fix max concurrent connections handling
 
 
 ## [0.1.2] - 2018-12-12
 
-## Changed
+### Changed
 
 * rename ServiceConfig::rt() to ServiceConfig::apply()
 

actix-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-server"
-version = "0.2.0"
+version = "0.3.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix server - General purpose tcp server"
 keywords = ["network", "framework", "async", "futures"]
@@ -11,7 +11,7 @@ categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
-workspace = "../"
+workspace = ".."
 
 [package.metadata.docs.rs]
 features = ["ssl", "tls", "rust-tls"]
@@ -33,17 +33,15 @@ ssl = ["openssl", "tokio-openssl"]
 rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
 
 [dependencies]
-#actix-service = "0.2.0"
+#actix-service = "0.3.2"
 actix-service = { path="../actix-service" }
-actix-rt = "0.1.0"
+actix-rt = "0.2.0"
 
 log = "0.4"
 num_cpus = "1.0"
 
-# io
 mio = "^0.6.13"
 net2 = "0.2"
-bytes = "0.4"
 futures = "0.1"
 slab = "0.4"
 tokio-io = "0.1"

actix-server/src/builder.rs

@@ -14,11 +14,10 @@ use tokio_timer::sleep;
 use crate::accept::{AcceptLoop, AcceptNotify, Command};
 use crate::config::{ConfiguredService, ServiceConfig};
 use crate::server::{Server, ServerCommand};
-use crate::services::{InternalServiceFactory, StreamNewService, StreamServiceFactory};
+use crate::services::{InternalServiceFactory, ServiceFactory, StreamNewService};
-use crate::services::{ServiceFactory, ServiceNewService};
 use crate::signals::{Signal, Signals};
 use crate::worker::{self, Worker, WorkerAvailability, WorkerClient};
-use crate::Token;
+use crate::{ssl, Token};
 
 /// Server builder
 pub struct ServerBuilder {
@@ -82,9 +81,18 @@ impl ServerBuilder {
         self
     }
 
-    /// Stop actix system.
+    /// Sets the maximum per-worker concurrent connection establish process.
     ///
-    /// `SystemExit` message stops currently running system.
+    /// All listeners will stop accepting connections when this limit is reached. It
+    /// can be used to limit the global SSL CPU usage.
+    ///
+    /// By default max connections is set to a 256.
+    pub fn maxconnrate(self, num: usize) -> Self {
+        ssl::max_concurrent_ssl_connect(num);
+        self
+    }
+
+    /// Stop actix system.
     pub fn system_exit(mut self) -> Self {
         self.exit = true;
         self
@@ -138,7 +146,7 @@ impl ServerBuilder {
     /// Add new service to the server.
     pub fn bind<F, U, N: AsRef<str>>(mut self, name: N, addr: U, factory: F) -> io::Result<Self>
     where
-        F: StreamServiceFactory,
+        F: ServiceFactory,
         U: net::ToSocketAddrs,
     {
         let sockets = bind_addr(addr)?;
@@ -163,31 +171,11 @@ impl ServerBuilder {
         lst: net::TcpListener,
         factory: F,
     ) -> Self
-    where
-        F: StreamServiceFactory,
-    {
-        let token = self.token.next();
-        self.services.push(StreamNewService::create(
-            name.as_ref().to_string(),
-            token,
-            factory,
-        ));
-        self.sockets.push((token, lst));
-        self
-    }
-
-    /// Add new service to the server.
-    pub fn listen2<F, N: AsRef<str>>(
-        mut self,
-        name: N,
-        lst: net::TcpListener,
-        factory: F,
-    ) -> Self
     where
         F: ServiceFactory,
     {
         let token = self.token.next();
-        self.services.push(ServiceNewService::create(
+        self.services.push(StreamNewService::create(
             name.as_ref().to_string(),
             token,
             factory,
@@ -204,9 +192,6 @@ impl ServerBuilder {
     /// This methods panics if no socket addresses get bound.
     ///
     /// ```rust,ignore
-    /// # extern crate futures;
-    /// # extern crate actix_web;
-    /// # use futures::Future;
     /// use actix_web::*;
     ///
     /// fn main() {

actix-server/src/config.rs

@@ -114,7 +114,7 @@ impl InternalServiceFactory for ConfiguredService {
         // construct services
         let mut fut = Vec::new();
         for (token, ns) in rt.services {
-            fut.push(ns.new_service().map(move |service| (token, service)));
+            fut.push(ns.new_service(&()).map(move |service| (token, service)));
         }
 
         Box::new(join_all(fut).map_err(|e| {
@@ -169,8 +169,8 @@ impl ServiceRuntime {
 
     pub fn service<T, F>(&mut self, name: &str, service: F)
     where
-        F: IntoNewService<T>,
+        F: IntoNewService<T, TcpStream>,
-        T: NewService<Request = TcpStream, Response = ()> + 'static,
+        T: NewService<TcpStream, Response = ()> + 'static,
         T::Future: 'static,
         T::Service: 'static,
         T::InitError: fmt::Debug,
@@ -191,7 +191,7 @@ impl ServiceRuntime {
 
 type BoxedNewService = Box<
     NewService<
-        Request = (Option<CounterGuard>, ServerMessage),
+        (Option<CounterGuard>, ServerMessage),
         Response = (),
         Error = (),
         InitError = (),
@@ -204,23 +204,22 @@ struct ServiceFactory<T> {
     inner: T,
 }
 
-impl<T> NewService for ServiceFactory<T>
+impl<T> NewService<(Option<CounterGuard>, ServerMessage)> for ServiceFactory<T>
 where
-    T: NewService<Request = TcpStream, Response = ()>,
+    T: NewService<TcpStream, Response = ()>,
     T::Future: 'static,
     T::Service: 'static,
     T::Error: 'static,
     T::InitError: fmt::Debug + 'static,
 {
-    type Request = (Option<CounterGuard>, ServerMessage);
     type Response = ();
     type Error = ();
     type InitError = ();
     type Service = BoxedServerService;
     type Future = Box<Future<Item = BoxedServerService, Error = ()>>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, _: &()) -> Self::Future {
-        Box::new(self.inner.new_service().map_err(|_| ()).map(|s| {
+        Box::new(self.inner.new_service(&()).map_err(|_| ()).map(|s| {
             let service: BoxedServerService = Box::new(StreamService::new(s));
             service
         }))

actix-server/src/lib.rs

@@ -13,7 +13,10 @@ mod worker;
 pub use self::builder::ServerBuilder;
 pub use self::config::{ServiceConfig, ServiceRuntime};
 pub use self::server::Server;
-pub use self::services::{ServerMessage, ServiceFactory, StreamServiceFactory};
+pub use self::services::ServiceFactory;
+
+#[doc(hidden)]
+pub use self::services::ServiceFactory as StreamServiceFactory;
 
 /// Socket id token
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -28,6 +31,6 @@ impl Token {
 }
 
 /// Start server building process
-pub fn build() -> ServerBuilder {
+pub fn new() -> ServerBuilder {
     ServerBuilder::default()
 }

actix-server/src/services.rs

@@ -13,7 +13,7 @@ use super::Token;
 use crate::counter::CounterGuard;
 
 /// Server message
-pub enum ServerMessage {
+pub(crate) enum ServerMessage {
     /// New stream
     Connect(net::TcpStream),
     /// Gracefull shutdown
@@ -22,14 +22,8 @@ pub enum ServerMessage {
     ForceShutdown,
 }
 
-pub trait StreamServiceFactory: Send + Clone + 'static {
-    type NewService: NewService<Request = TcpStream, Response = ()>;
-
-    fn create(&self) -> Self::NewService;
-}
-
 pub trait ServiceFactory: Send + Clone + 'static {
-    type NewService: NewService<Request = ServerMessage, Response = ()>;
+    type NewService: NewService<TcpStream>;
 
     fn create(&self) -> Self::NewService;
 }
@@ -44,7 +38,7 @@ pub(crate) trait InternalServiceFactory: Send {
 
 pub(crate) type BoxedServerService = Box<
     Service<
-        Request = (Option<CounterGuard>, ServerMessage),
+        (Option<CounterGuard>, ServerMessage),
         Response = (),
         Error = (),
         Future = FutureResult<(), ()>,
@@ -61,13 +55,12 @@ impl<T> StreamService<T> {
     }
 }
 
-impl<T> Service for StreamService<T>
+impl<T> Service<(Option<CounterGuard>, ServerMessage)> for StreamService<T>
 where
-    T: Service<Request = TcpStream, Response = ()>,
+    T: Service<TcpStream>,
     T::Future: 'static,
     T::Error: 'static,
 {
-    type Request = (Option<CounterGuard>, ServerMessage);
     type Response = ();
     type Error = ();
     type Future = FutureResult<(), ()>;
@@ -86,7 +79,7 @@ where
                 if let Ok(stream) = stream {
                     spawn(self.service.call(stream).then(move |res| {
                         drop(guard);
-                        res.map_err(|_| ())
+                        res.map_err(|_| ()).map(|_| ())
                     }));
                     ok(())
                 } else {
@@ -98,87 +91,7 @@ where
     }
 }
 
-pub(crate) struct ServerService<T> {
+pub(crate) struct StreamNewService<F: ServiceFactory> {
-    service: T,
-}
-
-impl<T> ServerService<T> {
-    fn new(service: T) -> Self {
-        ServerService { service }
-    }
-}
-
-impl<T> Service for ServerService<T>
-where
-    T: Service<Request = ServerMessage, Response = ()>,
-    T::Future: 'static,
-    T::Error: 'static,
-{
-    type Request = (Option<CounterGuard>, ServerMessage);
-    type Response = ();
-    type Error = ();
-    type Future = FutureResult<(), ()>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready().map_err(|_| ())
-    }
-
-    fn call(&mut self, (guard, req): (Option<CounterGuard>, ServerMessage)) -> Self::Future {
-        spawn(self.service.call(req).then(move |res| {
-            drop(guard);
-            res.map_err(|_| ())
-        }));
-        ok(())
-    }
-}
-
-pub(crate) struct ServiceNewService<F: ServiceFactory> {
-    name: String,
-    inner: F,
-    token: Token,
-}
-
-impl<F> ServiceNewService<F>
-where
-    F: ServiceFactory,
-{
-    pub(crate) fn create(name: String, token: Token, inner: F) -> Box<InternalServiceFactory> {
-        Box::new(Self { name, inner, token })
-    }
-}
-
-impl<F> InternalServiceFactory for ServiceNewService<F>
-where
-    F: ServiceFactory,
-{
-    fn name(&self, _: Token) -> &str {
-        &self.name
-    }
-
-    fn clone_factory(&self) -> Box<InternalServiceFactory> {
-        Box::new(Self {
-            name: self.name.clone(),
-            inner: self.inner.clone(),
-            token: self.token,
-        })
-    }
-
-    fn create(&self) -> Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
-        let token = self.token;
-        Box::new(
-            self.inner
-                .create()
-                .new_service()
-                .map_err(|_| ())
-                .map(move |inner| {
-                    let service: BoxedServerService = Box::new(ServerService::new(inner));
-                    vec![(token, service)]
-                }),
-        )
-    }
-}
-
-pub(crate) struct StreamNewService<F: StreamServiceFactory> {
     name: String,
     inner: F,
     token: Token,
@@ -186,7 +99,7 @@ pub(crate) struct StreamNewService<F: StreamServiceFactory> {
 
 impl<F> StreamNewService<F>
 where
-    F: StreamServiceFactory,
+    F: ServiceFactory,
 {
     pub(crate) fn create(name: String, token: Token, inner: F) -> Box<InternalServiceFactory> {
         Box::new(Self { name, token, inner })
@@ -195,7 +108,7 @@ where
 
 impl<F> InternalServiceFactory for StreamNewService<F>
 where
-    F: StreamServiceFactory,
+    F: ServiceFactory,
 {
     fn name(&self, _: Token) -> &str {
         &self.name
@@ -214,7 +127,7 @@ where
         Box::new(
             self.inner
                 .create()
-                .new_service()
+                .new_service(&())
                 .map_err(|_| ())
                 .map(move |inner| {
                     let service: BoxedServerService = Box::new(StreamService::new(inner));
@@ -241,19 +154,7 @@ impl InternalServiceFactory for Box<InternalServiceFactory> {
 impl<F, T> ServiceFactory for F
 where
     F: Fn() -> T + Send + Clone + 'static,
-    T: NewService<Request = ServerMessage, Response = ()>,
+    T: NewService<TcpStream>,
-{
-    type NewService = T;
-
-    fn create(&self) -> T {
-        (self)()
-    }
-}
-
-impl<F, T> StreamServiceFactory for F
-where
-    F: Fn() -> T + Send + Clone + 'static,
-    T: NewService<Request = TcpStream, Response = ()>,
 {
     type NewService = T;
 

actix-server/src/ssl/mod.rs

@@ -33,3 +33,9 @@ pub(crate) static MAX_CONN: AtomicUsize = AtomicUsize::new(256);
 thread_local! {
     static MAX_CONN_COUNTER: Counter = Counter::new(MAX_CONN.load(Ordering::Relaxed));
 }
+
+/// Ssl error combinded with service error.
+pub enum SslError<E1, E2> {
+    Ssl(E1),
+    Service(E2),
+}

actix-server/src/ssl/nativetls.rs

@@ -36,15 +36,14 @@ impl<T: AsyncRead + AsyncWrite> Clone for NativeTlsAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService for NativeTlsAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite> NewService<T> for NativeTlsAcceptor<T> {
-    type Request = T;
     type Response = TlsStream<T>;
     type Error = Error;
     type Service = NativeTlsAcceptorService<T>;
     type InitError = ();
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, _: &()) -> Self::Future {
         MAX_CONN_COUNTER.with(|conns| {
             ok(NativeTlsAcceptorService {
                 acceptor: self.acceptor.clone(),
@@ -61,8 +60,7 @@ pub struct NativeTlsAcceptorService<T> {
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service for NativeTlsAcceptorService<T> {
+impl<T: AsyncRead + AsyncWrite> Service<T> for NativeTlsAcceptorService<T> {
-    type Request = T;
     type Response = TlsStream<T>;
     type Error = Error;
     type Future = Accept<T>;

actix-server/src/ssl/openssl.rs

@@ -36,15 +36,14 @@ impl<T: AsyncRead + AsyncWrite> Clone for OpensslAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService for OpensslAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite> NewService<T> for OpensslAcceptor<T> {
-    type Request = T;
     type Response = SslStream<T>;
     type Error = HandshakeError<T>;
     type Service = OpensslAcceptorService<T>;
     type InitError = ();
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, _: &()) -> Self::Future {
         MAX_CONN_COUNTER.with(|conns| {
             ok(OpensslAcceptorService {
                 acceptor: self.acceptor.clone(),
@@ -61,8 +60,7 @@ pub struct OpensslAcceptorService<T> {
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service for OpensslAcceptorService<T> {
+impl<T: AsyncRead + AsyncWrite> Service<T> for OpensslAcceptorService<T> {
-    type Request = T;
     type Response = SslStream<T>;
     type Error = HandshakeError<T>;
     type Future = OpensslAcceptorServiceFut<T>;

actix-server/src/ssl/rustls.rs

@@ -38,15 +38,14 @@ impl<T> Clone for RustlsAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService for RustlsAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite> NewService<T> for RustlsAcceptor<T> {
-    type Request = T;
     type Response = TlsStream<T, ServerSession>;
     type Error = io::Error;
     type Service = RustlsAcceptorService<T>;
     type InitError = ();
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, _: &()) -> Self::Future {
         MAX_CONN_COUNTER.with(|conns| {
             ok(RustlsAcceptorService {
                 acceptor: self.config.clone().into(),
@@ -63,8 +62,7 @@ pub struct RustlsAcceptorService<T> {
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service for RustlsAcceptorService<T> {
+impl<T: AsyncRead + AsyncWrite> Service<T> for RustlsAcceptorService<T> {
-    type Request = T;
     type Response = TlsStream<T, ServerSession>;
     type Error = io::Error;
     type Future = RustlsAcceptorServiceFut<T>;

actix-service/CHANGES.md

@@ -1,5 +1,61 @@
 # Changes
 
+## [0.3.2] - 2019-03-xx
+
+### Added
+
+* Add `ApplyTransform` new service for transform and new service.
+
+### Changed
+
+* Revert IntoFuture change
+
+
+## [0.3.2] - 2019-03-04
+
+### Changed
+
+* Change `NewService::Future` and `Transform::Future` to the `IntoFuture` trait.
+
+* Export `AndThenTransform` type
+
+
+## [0.3.1] - 2019-03-04
+
+### Changed
+
+* Simplify Transform trait
+
+
+## [0.3.0] - 2019-03-02
+
+## Added
+
+* Added boxed NewService and Service.
+
+## Changed
+
+* Added `Config` parameter to `NewService` trait.
+
+* Added `Config` parameter to `NewTransform` trait.
+
+
+## [0.2.2] - 2019-02-19
+
+### Added
+
+* Added `NewService` impl for `Rc<S> where S: NewService`
+
+* Added `NewService` impl for `Arc<S> where S: NewService`
+
+
+## [0.2.1] - 2019-02-03
+
+### Changed
+
+* Generalize `.apply` combinator with Transform trait
+
+
 ## [0.2.0] - 2019-02-01
 
 ### Changed

actix-service/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-service"
-version = "0.2.0"
+version = "0.3.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Service"
 keywords = ["network", "framework", "async", "futures"]
@@ -11,7 +11,7 @@ categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
-workspace = "../"
+workspace = ".."
 
 [badges]
 travis-ci = { repository = "actix/actix-service", branch = "master" }
@@ -24,3 +24,7 @@ path = "src/lib.rs"
 
 [dependencies]
 futures = "0.1.24"
+void = "1.0.2"
+
+[dev-dependencies]
+actix-rt = "0.1"

actix-service/src/and_then.rs

@@ -14,10 +14,10 @@ pub struct AndThen<A, B> {
 
 impl<A, B> AndThen<A, B> {
     /// Create new `AndThen` combinator
-    pub fn new(a: A, b: B) -> Self
+    pub fn new<R>(a: A, b: B) -> Self
     where
-        A: Service,
+        A: Service<R>,
-        B: Service<Request = A::Response, Error = A::Error>,
+        B: Service<A::Response, Error = A::Error>,
     {
         Self { a, b: Cell::new(b) }
     }
@@ -35,40 +35,39 @@ where
     }
 }
 
-impl<A, B> Service for AndThen<A, B>
+impl<A, B, R> Service<R> for AndThen<A, B>
 where
-    A: Service,
+    A: Service<R>,
-    B: Service<Request = A::Response, Error = A::Error>,
+    B: Service<A::Response, Error = A::Error>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
-    type Future = AndThenFuture<A, B>;
+    type Future = AndThenFuture<A, B, R>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         try_ready!(self.a.poll_ready());
         self.b.get_mut().poll_ready()
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: R) -> Self::Future {
         AndThenFuture::new(self.a.call(req), self.b.clone())
     }
 }
 
-pub struct AndThenFuture<A, B>
+pub struct AndThenFuture<A, B, R>
 where
-    A: Service,
+    A: Service<R>,
-    B: Service<Request = A::Response, Error = A::Error>,
+    B: Service<A::Response, Error = A::Error>,
 {
     b: Cell<B>,
     fut_b: Option<B::Future>,
     fut_a: Option<A::Future>,
 }
 
-impl<A, B> AndThenFuture<A, B>
+impl<A, B, R> AndThenFuture<A, B, R>
 where
-    A: Service,
+    A: Service<R>,
-    B: Service<Request = A::Response, Error = A::Error>,
+    B: Service<A::Response, Error = A::Error>,
 {
     fn new(a: A::Future, b: Cell<B>) -> Self {
         AndThenFuture {
@@ -79,10 +78,10 @@ where
     }
 }
 
-impl<A, B> Future for AndThenFuture<A, B>
+impl<A, B, R> Future for AndThenFuture<A, B, R>
 where
-    A: Service,
+    A: Service<R>,
-    B: Service<Request = A::Response, Error = A::Error>,
+    B: Service<A::Response, Error = A::Error>,
 {
     type Item = B::Response;
     type Error = A::Error;
@@ -112,10 +111,10 @@ pub struct AndThenNewService<A, B> {
 
 impl<A, B> AndThenNewService<A, B> {
     /// Create new `AndThen` combinator
-    pub fn new<F: IntoNewService<B>>(a: A, f: F) -> Self
+    pub fn new<R, C, F: IntoNewService<B, A::Response, C>>(a: A, f: F) -> Self
     where
-        A: NewService,
+        A: NewService<R, C>,
-        B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>,
+        B: NewService<A::Response, C, Error = A::Error, InitError = A::InitError>,
     {
         Self {
             a,
@@ -124,21 +123,20 @@ impl<A, B> AndThenNewService<A, B> {
     }
 }
 
-impl<A, B> NewService for AndThenNewService<A, B>
+impl<A, B, R, C> NewService<R, C> for AndThenNewService<A, B>
 where
-    A: NewService,
+    A: NewService<R, C>,
-    B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>,
+    B: NewService<A::Response, C, Error = A::Error, InitError = A::InitError>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
     type Service = AndThen<A::Service, B::Service>;
 
     type InitError = A::InitError;
-    type Future = AndThenNewServiceFuture<A, B>;
+    type Future = AndThenNewServiceFuture<A, B, R, C>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &C) -> Self::Future {
-        AndThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
+        AndThenNewServiceFuture::new(self.a.new_service(cfg), self.b.new_service(cfg))
     }
 }
 
@@ -155,10 +153,10 @@ where
     }
 }
 
-pub struct AndThenNewServiceFuture<A, B>
+pub struct AndThenNewServiceFuture<A, B, R, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
-    B: NewService<Request = A::Response>,
+    B: NewService<A::Response, C>,
 {
     fut_b: B::Future,
     fut_a: A::Future,
@@ -166,10 +164,10 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B> AndThenNewServiceFuture<A, B>
+impl<A, B, R, C> AndThenNewServiceFuture<A, B, R, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
-    B: NewService<Request = A::Response>,
+    B: NewService<A::Response, C, Error = A::Error, InitError = A::InitError>,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
         AndThenNewServiceFuture {
@@ -181,10 +179,10 @@ where
     }
 }
 
-impl<A, B> Future for AndThenNewServiceFuture<A, B>
+impl<A, B, R, C> Future for AndThenNewServiceFuture<A, B, R, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
-    B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>,
+    B: NewService<A::Response, C, Error = A::Error, InitError = A::InitError>,
 {
     type Item = AndThen<A::Service, B::Service>;
     type Error = A::InitError;
@@ -224,8 +222,7 @@ mod tests {
     use crate::{NewService, Service, ServiceExt};
 
     struct Srv1(Rc<Cell<usize>>);
-    impl Service for Srv1 {
+    impl Service<&'static str> for Srv1 {
-        type Request = &'static str;
         type Response = &'static str;
         type Error = ();
         type Future = FutureResult<Self::Response, ()>;
@@ -243,8 +240,7 @@ mod tests {
     #[derive(Clone)]
     struct Srv2(Rc<Cell<usize>>);
 
-    impl Service for Srv2 {
+    impl Service<&'static str> for Srv2 {
-        type Request = &'static str;
         type Response = (&'static str, &'static str);
         type Error = ();
         type Future = FutureResult<Self::Response, ()>;
@@ -286,7 +282,7 @@ mod tests {
         let new_srv = blank
             .into_new_service()
             .and_then(move || Ok(Srv2(cnt.clone())));
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
             let res = srv.call("srv1").poll();
             assert!(res.is_ok());
             assert_eq!(res.unwrap(), Async::Ready(("srv1", "srv2")));

actix-service/src/and_then_apply.rs

@@ -1,161 +1,39 @@
 use std::marker::PhantomData;
+use std::rc::Rc;
 
-use futures::{try_ready, Async, Future, IntoFuture, Poll};
+use futures::{Async, Future, Poll};
 
-use super::{IntoNewService, IntoService, NewService, Service};
+use crate::and_then::AndThen;
-use crate::cell::Cell;
+use crate::from_err::FromErr;
+use crate::{NewService, Transform};
 
-/// `Apply` service combinator
+/// `Apply` new service combinator
-pub struct AndThenApply<A, B, F, Out>
+pub struct AndThenTransform<T, A, B, BR> {
-where
-    A: Service,
-    B: Service<Error = A::Error>,
-    F: FnMut(A::Response, &mut B) -> Out,
-    Out: IntoFuture,
-    Out::Error: Into<A::Error>,
-{
-    a: A,
-    b: Cell<B>,
-    f: Cell<F>,
-    r: PhantomData<(Out,)>,
-}
-
-impl<A, B, F, Out> AndThenApply<A, B, F, Out>
-where
-    A: Service,
-    B: Service<Error = A::Error>,
-    F: FnMut(A::Response, &mut B) -> Out,
-    Out: IntoFuture,
-    Out::Error: Into<A::Error>,
-{
-    /// Create new `Apply` combinator
-    pub fn new<A1: IntoService<A>, B1: IntoService<B>>(a: A1, b: B1, f: F) -> Self {
-        Self {
-            f: Cell::new(f),
-            a: a.into_service(),
-            b: Cell::new(b.into_service()),
-            r: PhantomData,
-        }
-    }
-}
-
-impl<A, B, F, Out> Clone for AndThenApply<A, B, F, Out>
-where
-    A: Service + Clone,
-    B: Service<Error = A::Error>,
-    F: FnMut(A::Response, &mut B) -> Out,
-    Out: IntoFuture,
-    Out::Error: Into<A::Error>,
-{
-    fn clone(&self) -> Self {
-        AndThenApply {
-            a: self.a.clone(),
-            b: self.b.clone(),
-            f: self.f.clone(),
-            r: PhantomData,
-        }
-    }
-}
-
-impl<A, B, F, Out> Service for AndThenApply<A, B, F, Out>
-where
-    A: Service,
-    B: Service<Error = A::Error>,
-    F: FnMut(A::Response, &mut B) -> Out,
-    Out: IntoFuture,
-    Out::Error: Into<A::Error>,
-{
-    type Request = A::Request;
-    type Response = Out::Item;
-    type Error = A::Error;
-    type Future = AndThenApplyFuture<A, B, F, Out>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        try_ready!(self.a.poll_ready());
-        self.b.get_mut().poll_ready().map_err(|e| e.into())
-    }
-
-    fn call(&mut self, req: A::Request) -> Self::Future {
-        AndThenApplyFuture {
-            b: self.b.clone(),
-            f: self.f.clone(),
-            fut_b: None,
-            fut_a: Some(self.a.call(req)),
-        }
-    }
-}
-
-pub struct AndThenApplyFuture<A, B, F, Out>
-where
-    A: Service,
-    B: Service<Error = A::Error>,
-    F: FnMut(A::Response, &mut B) -> Out,
-    Out: IntoFuture,
-    Out::Error: Into<A::Error>,
-{
-    b: Cell<B>,
-    f: Cell<F>,
-    fut_a: Option<A::Future>,
-    fut_b: Option<Out::Future>,
-}
-
-impl<A, B, F, Out> Future for AndThenApplyFuture<A, B, F, Out>
-where
-    A: Service,
-    B: Service<Error = A::Error>,
-    F: FnMut(A::Response, &mut B) -> Out,
-    Out: IntoFuture,
-    Out::Error: Into<A::Error>,
-{
-    type Item = Out::Item;
-    type Error = A::Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(ref mut fut) = self.fut_b {
-            return fut.poll().map_err(|e| e.into());
-        }
-
-        match self.fut_a.as_mut().expect("Bug in actix-service").poll() {
-            Ok(Async::Ready(resp)) => {
-                let _ = self.fut_a.take();
-                self.fut_b =
-                    Some((&mut *self.f.get_mut())(resp, self.b.get_mut()).into_future());
-                self.poll()
-            }
-            Ok(Async::NotReady) => Ok(Async::NotReady),
-            Err(err) => Err(err.into()),
-        }
-    }
-}
-
-/// `ApplyNewService` new service combinator
-pub struct AndThenApplyNewService<A, B, F, Out> {
     a: A,
     b: B,
-    f: Cell<F>,
+    t: Rc<T>,
-    r: PhantomData<(Out)>,
+    _t: PhantomData<BR>,
 }
 
-impl<A, B, F, Out> AndThenApplyNewService<A, B, F, Out>
+impl<T, A, B, BR> AndThenTransform<T, A, B, BR> {
-where
-    A: NewService,
-    B: NewService<Error = A::Error, InitError = A::InitError>,
-    F: FnMut(A::Response, &mut B::Service) -> Out,
-    Out: IntoFuture,
-    Out::Error: Into<A::Error>,
-{
     /// Create new `ApplyNewService` new service instance
-    pub fn new<A1: IntoNewService<A>, B1: IntoNewService<B>>(a: A1, b: B1, f: F) -> Self {
+    pub fn new<AR, C>(t: T, a: A, b: B) -> Self
+    where
+        A: NewService<AR, C>,
+        B: NewService<BR, C, InitError = A::InitError>,
+        T: Transform<B::Service, A::Response, InitError = A::InitError>,
+        T::Error: From<A::Error>,
+    {
         Self {
-            f: Cell::new(f),
+            a,
-            a: a.into_new_service(),
+            b,
-            b: b.into_new_service(),
+            t: Rc::new(t),
-            r: PhantomData,
+            _t: std::marker::PhantomData,
         }
     }
 }
 
-impl<A, B, F, Out> Clone for AndThenApplyNewService<A, B, F, Out>
+impl<T, A, B, BR> Clone for AndThenTransform<T, A, B, BR>
 where
     A: Clone,
     B: Clone,
@@ -164,85 +42,87 @@ where
         Self {
             a: self.a.clone(),
             b: self.b.clone(),
-            f: self.f.clone(),
+            t: self.t.clone(),
-            r: PhantomData,
+            _t: std::marker::PhantomData,
         }
     }
 }
 
-impl<A, B, F, Out> NewService for AndThenApplyNewService<A, B, F, Out>
+impl<T, A, B, AR, BR, C> NewService<AR, C> for AndThenTransform<T, A, B, BR>
 where
-    A: NewService,
+    A: NewService<AR, C>,
-    B: NewService<Error = A::Error, InitError = A::InitError>,
+    B: NewService<BR, C, InitError = A::InitError>,
-    F: FnMut(A::Response, &mut B::Service) -> Out,
+    T: Transform<B::Service, A::Response, InitError = A::InitError>,
-    Out: IntoFuture,
+    T::Error: From<A::Error>,
-    Out::Error: Into<A::Error>,
 {
-    type Request = A::Request;
+    type Response = T::Response;
-    type Response = Out::Item;
+    type Error = T::Error;
-    type Error = A::Error;
 
-    type InitError = A::InitError;
+    type InitError = T::InitError;
-    type Service = AndThenApply<A::Service, B::Service, F, Out>;
+    type Service = AndThen<FromErr<A::Service, T::Error>, T::Transform>;
-    type Future = AndThenApplyNewServiceFuture<A, B, F, Out>;
+    type Future = AndThenTransformFuture<T, A, B, AR, BR, C>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &C) -> Self::Future {
-        AndThenApplyNewServiceFuture {
+        AndThenTransformFuture {
             a: None,
-            b: None,
+            t: None,
-            f: self.f.clone(),
+            t_cell: self.t.clone(),
-            fut_a: self.a.new_service(),
+            fut_a: self.a.new_service(cfg),
-            fut_b: self.b.new_service(),
+            fut_b: self.b.new_service(cfg),
+            fut_t: None,
         }
     }
 }
 
-pub struct AndThenApplyNewServiceFuture<A, B, F, Out>
+pub struct AndThenTransformFuture<T, A, B, AR, BR, C>
 where
-    A: NewService,
+    A: NewService<AR, C>,
-    B: NewService<Error = A::Error, InitError = A::InitError>,
+    B: NewService<BR, C, InitError = A::InitError>,
-    F: FnMut(A::Response, &mut B::Service) -> Out,
+    T: Transform<B::Service, A::Response, InitError = A::InitError>,
-    Out: IntoFuture,
+    T::Error: From<A::Error>,
-    Out::Error: Into<A::Error>,
 {
-    fut_b: B::Future,
     fut_a: A::Future,
-    f: Cell<F>,
+    fut_b: B::Future,
+    fut_t: Option<T::Future>,
     a: Option<A::Service>,
-    b: Option<B::Service>,
+    t: Option<T::Transform>,
+    t_cell: Rc<T>,
 }
 
-impl<A, B, F, Out> Future for AndThenApplyNewServiceFuture<A, B, F, Out>
+impl<T, A, B, AR, BR, C> Future for AndThenTransformFuture<T, A, B, AR, BR, C>
 where
-    A: NewService,
+    A: NewService<AR, C>,
-    B: NewService<Error = A::Error, InitError = A::InitError>,
+    B: NewService<BR, C, InitError = A::InitError>,
-    F: FnMut(A::Response, &mut B::Service) -> Out,
+    T: Transform<B::Service, A::Response, InitError = A::InitError>,
-    Out: IntoFuture,
+    T::Error: From<A::Error>,
-    Out::Error: Into<A::Error>,
 {
-    type Item = AndThenApply<A::Service, B::Service, F, Out>;
+    type Item = AndThen<FromErr<A::Service, T::Error>, T::Transform>;
-    type Error = A::InitError;
+    type Error = T::InitError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if self.fut_t.is_none() {
+            if let Async::Ready(service) = self.fut_b.poll()? {
+                self.fut_t = Some(self.t_cell.new_transform(service));
+            }
+        }
+
         if self.a.is_none() {
             if let Async::Ready(service) = self.fut_a.poll()? {
                 self.a = Some(service);
             }
         }
 
-        if self.b.is_none() {
+        if let Some(ref mut fut) = self.fut_t {
-            if let Async::Ready(service) = self.fut_b.poll()? {
+            if let Async::Ready(transform) = fut.poll()? {
-                self.b = Some(service);
+                self.t = Some(transform);
             }
         }
 
-        if self.a.is_some() && self.b.is_some() {
+        if self.a.is_some() && self.t.is_some() {
-            Ok(Async::Ready(AndThenApply {
+            Ok(Async::Ready(AndThen::new(
-                f: self.f.clone(),
+                FromErr::new(self.a.take().unwrap()),
-                a: self.a.take().unwrap(),
+                self.t.take().unwrap(),
-                b: Cell::new(self.b.take().unwrap()),
+            )))
-                r: PhantomData,
-            }))
         } else {
             Ok(Async::NotReady)
         }
@@ -258,8 +138,7 @@ mod tests {
 
     #[derive(Clone)]
     struct Srv;
-    impl Service for Srv {
+    impl Service<()> for Srv {
-        type Request = ();
         type Response = ();
         type Error = ();
         type Future = FutureResult<(), ()>;
@@ -274,12 +153,14 @@ mod tests {
     }
 
     #[test]
-    fn test_call() {
+    fn test_apply() {
         let blank = |req| Ok(req);
 
-        let mut srv = blank.into_service().apply(Srv, |req: &'static str, srv| {
+        let mut srv = blank
-            srv.call(()).map(move |res| (req, res))
+            .into_service()
-        });
+            .apply_fn(Srv, |req: &'static str, srv: &mut Srv| {
+                srv.call(()).map(move |res| (req, res))
+            });
         assert!(srv.poll_ready().is_ok());
         let res = srv.call("srv").poll();
         assert!(res.is_ok());
@@ -291,10 +172,10 @@ mod tests {
         let blank = || Ok::<_, ()>((|req| Ok(req)).into_service());
 
         let new_srv = blank.into_new_service().apply(
+            |req: &'static str, srv: &mut Srv| srv.call(()).map(move |res| (req, res)),
             || Ok(Srv),
-            |req: &'static str, srv| srv.call(()).map(move |res| (req, res)),
         );
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
             assert!(srv.poll_ready().is_ok());
             let res = srv.call("srv").poll();
             assert!(res.is_ok());

actix-service/src/and_then_apply_fn.rs

@@ -0,0 +1,298 @@
+use std::marker::PhantomData;
+
+use futures::{try_ready, Async, Future, IntoFuture, Poll};
+
+use super::{IntoNewService, IntoService, NewService, Service};
+use crate::cell::Cell;
+
+/// `Apply` service combinator
+pub struct AndThenApply<A, B, F, Out, AReq, BReq> {
+    a: A,
+    b: Cell<B>,
+    f: Cell<F>,
+    r: PhantomData<(Out, AReq, BReq)>,
+}
+
+impl<A, B, F, Out, AReq, BReq> AndThenApply<A, B, F, Out, AReq, BReq>
+where
+    A: Service<AReq>,
+    B: Service<BReq, Error = A::Error>,
+    F: FnMut(A::Response, &mut B) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    /// Create new `Apply` combinator
+    pub fn new<A1: IntoService<A, AReq>, B1: IntoService<B, BReq>>(a: A1, b: B1, f: F) -> Self {
+        Self {
+            f: Cell::new(f),
+            a: a.into_service(),
+            b: Cell::new(b.into_service()),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Out, AReq, BReq> Clone for AndThenApply<A, B, F, Out, AReq, BReq>
+where
+    A: Clone,
+{
+    fn clone(&self) -> Self {
+        AndThenApply {
+            a: self.a.clone(),
+            b: self.b.clone(),
+            f: self.f.clone(),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Out, AReq, BReq> Service<AReq> for AndThenApply<A, B, F, Out, AReq, BReq>
+where
+    A: Service<AReq>,
+    B: Service<BReq, Error = A::Error>,
+    F: FnMut(A::Response, &mut B) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    type Response = Out::Item;
+    type Error = A::Error;
+    type Future = AndThenApplyFuture<A, B, F, Out, AReq, BReq>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        try_ready!(self.a.poll_ready());
+        self.b.get_mut().poll_ready()
+    }
+
+    fn call(&mut self, req: AReq) -> Self::Future {
+        AndThenApplyFuture {
+            b: self.b.clone(),
+            f: self.f.clone(),
+            fut_b: None,
+            fut_a: Some(self.a.call(req)),
+            _t: PhantomData,
+        }
+    }
+}
+
+pub struct AndThenApplyFuture<A, B, F, Out, AReq, BReq>
+where
+    A: Service<AReq>,
+    B: Service<BReq, Error = A::Error>,
+    F: FnMut(A::Response, &mut B) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    b: Cell<B>,
+    f: Cell<F>,
+    fut_a: Option<A::Future>,
+    fut_b: Option<Out::Future>,
+    _t: PhantomData<(AReq, BReq)>,
+}
+
+impl<A, B, F, Out, AReq, BReq> Future for AndThenApplyFuture<A, B, F, Out, AReq, BReq>
+where
+    A: Service<AReq>,
+    B: Service<BReq, Error = A::Error>,
+    F: FnMut(A::Response, &mut B) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    type Item = Out::Item;
+    type Error = A::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if let Some(ref mut fut) = self.fut_b {
+            return fut.poll().map_err(|e| e.into());
+        }
+
+        match self.fut_a.as_mut().expect("Bug in actix-service").poll() {
+            Ok(Async::Ready(resp)) => {
+                let _ = self.fut_a.take();
+                self.fut_b =
+                    Some((&mut *self.f.get_mut())(resp, self.b.get_mut()).into_future());
+                self.poll()
+            }
+            Ok(Async::NotReady) => Ok(Async::NotReady),
+            Err(err) => Err(err),
+        }
+    }
+}
+
+/// `ApplyNewService` new service combinator
+pub struct AndThenApplyNewService<A, B, F, Out, AReq, BReq, Cfg> {
+    a: A,
+    b: B,
+    f: Cell<F>,
+    r: PhantomData<(Out, AReq, BReq, Cfg)>,
+}
+
+impl<A, B, F, Out, AReq, BReq, Cfg> AndThenApplyNewService<A, B, F, Out, AReq, BReq, Cfg>
+where
+    A: NewService<AReq, Cfg>,
+    B: NewService<BReq, Cfg, Error = A::Error, InitError = A::InitError>,
+    F: FnMut(A::Response, &mut B::Service) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    /// Create new `ApplyNewService` new service instance
+    pub fn new<A1: IntoNewService<A, AReq, Cfg>, B1: IntoNewService<B, BReq, Cfg>>(
+        a: A1,
+        b: B1,
+        f: F,
+    ) -> Self {
+        Self {
+            f: Cell::new(f),
+            a: a.into_new_service(),
+            b: b.into_new_service(),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Out, AReq, BReq, Cfg> Clone
+    for AndThenApplyNewService<A, B, F, Out, AReq, BReq, Cfg>
+where
+    A: Clone,
+    B: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            a: self.a.clone(),
+            b: self.b.clone(),
+            f: self.f.clone(),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Out, AReq, BReq, Cfg> NewService<AReq, Cfg>
+    for AndThenApplyNewService<A, B, F, Out, AReq, BReq, Cfg>
+where
+    A: NewService<AReq, Cfg>,
+    B: NewService<BReq, Cfg, Error = A::Error, InitError = A::InitError>,
+    F: FnMut(A::Response, &mut B::Service) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    type Response = Out::Item;
+    type Error = A::Error;
+    type Service = AndThenApply<A::Service, B::Service, F, Out, AReq, BReq>;
+
+    type InitError = A::InitError;
+    type Future = AndThenApplyNewServiceFuture<A, B, F, Out, AReq, BReq, Cfg>;
+
+    fn new_service(&self, cfg: &Cfg) -> Self::Future {
+        AndThenApplyNewServiceFuture {
+            a: None,
+            b: None,
+            f: self.f.clone(),
+            fut_a: self.a.new_service(cfg).into_future(),
+            fut_b: self.b.new_service(cfg).into_future(),
+        }
+    }
+}
+
+pub struct AndThenApplyNewServiceFuture<A, B, F, Out, AReq, BReq, Cfg>
+where
+    A: NewService<AReq, Cfg>,
+    B: NewService<BReq, Cfg, Error = A::Error, InitError = A::InitError>,
+    F: FnMut(A::Response, &mut B::Service) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    fut_b: B::Future,
+    fut_a: A::Future,
+    f: Cell<F>,
+    a: Option<A::Service>,
+    b: Option<B::Service>,
+}
+
+impl<A, B, F, Out, AReq, BReq, Cfg> Future
+    for AndThenApplyNewServiceFuture<A, B, F, Out, AReq, BReq, Cfg>
+where
+    A: NewService<AReq, Cfg>,
+    B: NewService<BReq, Cfg, Error = A::Error, InitError = A::InitError>,
+    F: FnMut(A::Response, &mut B::Service) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    type Item = AndThenApply<A::Service, B::Service, F, Out, AReq, BReq>;
+    type Error = A::InitError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if self.a.is_none() {
+            if let Async::Ready(service) = self.fut_a.poll()? {
+                self.a = Some(service);
+            }
+        }
+
+        if self.b.is_none() {
+            if let Async::Ready(service) = self.fut_b.poll()? {
+                self.b = Some(service);
+            }
+        }
+
+        if self.a.is_some() && self.b.is_some() {
+            Ok(Async::Ready(AndThenApply {
+                f: self.f.clone(),
+                a: self.a.take().unwrap(),
+                b: Cell::new(self.b.take().unwrap()),
+                r: PhantomData,
+            }))
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use futures::future::{ok, FutureResult};
+    use futures::{Async, Future, Poll};
+
+    use crate::blank::{Blank, BlankNewService};
+    use crate::{NewService, Service, ServiceExt};
+
+    #[derive(Clone)]
+    struct Srv;
+    impl Service<()> for Srv {
+        type Response = ();
+        type Error = ();
+        type Future = FutureResult<(), ()>;
+
+        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+            Ok(Async::Ready(()))
+        }
+
+        fn call(&mut self, _: ()) -> Self::Future {
+            ok(())
+        }
+    }
+
+    #[test]
+    fn test_call() {
+        let mut srv = Blank::new().apply_fn(Srv, |req: &'static str, srv| {
+            srv.call(()).map(move |res| (req, res))
+        });
+        assert!(srv.poll_ready().is_ok());
+        let res = srv.call("srv").poll();
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), Async::Ready(("srv", ())));
+    }
+
+    #[test]
+    fn test_new_service() {
+        let new_srv = BlankNewService::new_unit().apply_fn(
+            || Ok(Srv),
+            |req: &'static str, srv| srv.call(()).map(move |res| (req, res)),
+        );
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
+            assert!(srv.poll_ready().is_ok());
+            let res = srv.call("srv").poll();
+            assert!(res.is_ok());
+            assert_eq!(res.unwrap(), Async::Ready(("srv", ())));
+        } else {
+            panic!()
+        }
+    }
+}

actix-service/src/apply.rs

@@ -5,24 +5,23 @@ use futures::{Async, Future, IntoFuture, Poll};
 use super::{IntoNewService, IntoService, NewService, Service};
 
 /// `Apply` service combinator
-pub struct Apply<T, F, In, Out>
+pub struct Apply<T, R, F, In, Out> {
-where
-    T: Service,
-{
     service: T,
     f: F,
-    r: PhantomData<(In, Out)>,
+    r: PhantomData<(R, In, Out)>,
 }
 
-impl<T, F, In, Out> Apply<T, F, In, Out>
+impl<T, R, F, In, Out> Apply<T, R, F, In, Out>
 where
-    T: Service,
     F: FnMut(In, &mut T) -> Out,
-    Out: IntoFuture,
-    Out::Error: From<T::Error>,
 {
     /// Create new `Apply` combinator
-    pub fn new<I: IntoService<T>>(service: I, f: F) -> Self {
+    pub fn new<I: IntoService<T, R>>(service: I, f: F) -> Self
+    where
+        T: Service<R>,
+        Out: IntoFuture,
+        Out::Error: From<T::Error>,
+    {
         Self {
             service: service.into_service(),
             f,
@@ -31,9 +30,9 @@ where
     }
 }
 
-impl<T, F, In, Out> Clone for Apply<T, F, In, Out>
+impl<T, R, F, In, Out> Clone for Apply<T, R, F, In, Out>
 where
-    T: Service + Clone,
+    T: Clone,
     F: Clone,
 {
     fn clone(&self) -> Self {
@@ -45,14 +44,13 @@ where
     }
 }
 
-impl<T, F, In, Out> Service for Apply<T, F, In, Out>
+impl<T, R, F, In, Out> Service<In> for Apply<T, R, F, In, Out>
 where
-    T: Service,
+    T: Service<R>,
     F: FnMut(In, &mut T) -> Out,
     Out: IntoFuture,
     Out::Error: From<T::Error>,
 {
-    type Request = In;
     type Response = Out::Item;
     type Error = Out::Error;
     type Future = Out::Future;
@@ -67,24 +65,21 @@ where
 }
 
 /// `ApplyNewService` new service combinator
-pub struct ApplyNewService<T, F, In, Out>
+pub struct ApplyNewService<T, F, In, Out, Req> {
-where
-    T: NewService,
-{
     service: T,
     f: F,
-    r: PhantomData<(In, Out)>,
+    r: PhantomData<(In, Out, Req)>,
 }
 
-impl<T, F, In, Out> ApplyNewService<T, F, In, Out>
+impl<T, F, In, Out, Req> ApplyNewService<T, F, In, Out, Req> {
-where
-    T: NewService,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
-    Out::Error: From<T::Error>,
-{
     /// Create new `ApplyNewService` new service instance
-    pub fn new<F1: IntoNewService<T>>(service: F1, f: F) -> Self {
+    pub fn new<Cfg, F1: IntoNewService<T, Req, Cfg>>(service: F1, f: F) -> Self
+    where
+        T: NewService<Req, Cfg>,
+        F: FnMut(In, &mut T::Service) -> Out + Clone,
+        Out: IntoFuture,
+        Out::Error: From<T::Error>,
+    {
         Self {
             f,
             service: service.into_new_service(),
@@ -93,11 +88,10 @@ where
     }
 }
 
-impl<T, F, In, Out> Clone for ApplyNewService<T, F, In, Out>
+impl<T, F, In, Out, Req> Clone for ApplyNewService<T, F, In, Out, Req>
 where
-    T: NewService + Clone,
+    T: Clone,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
+    F: Clone,
-    Out: IntoFuture,
 {
     fn clone(&self) -> Self {
         Self {
@@ -108,29 +102,28 @@ where
     }
 }
 
-impl<T, F, In, Out> NewService for ApplyNewService<T, F, In, Out>
+impl<T, F, In, Out, Req, Cfg> NewService<In, Cfg> for ApplyNewService<T, F, In, Out, Req>
 where
-    T: NewService,
+    T: NewService<Req, Cfg>,
     F: FnMut(In, &mut T::Service) -> Out + Clone,
     Out: IntoFuture,
     Out::Error: From<T::Error>,
 {
-    type Request = In;
     type Response = Out::Item;
     type Error = Out::Error;
-    type Service = Apply<T::Service, F, In, Out>;
+    type Service = Apply<T::Service, Req, F, In, Out>;
 
     type InitError = T::InitError;
-    type Future = ApplyNewServiceFuture<T, F, In, Out>;
+    type Future = ApplyNewServiceFuture<T, F, In, Out, Req, Cfg>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &Cfg) -> Self::Future {
-        ApplyNewServiceFuture::new(self.service.new_service(), self.f.clone())
+        ApplyNewServiceFuture::new(self.service.new_service(cfg), self.f.clone())
     }
 }
 
-pub struct ApplyNewServiceFuture<T, F, In, Out>
+pub struct ApplyNewServiceFuture<T, F, In, Out, Req, Cfg>
 where
-    T: NewService,
+    T: NewService<Req, Cfg>,
     F: FnMut(In, &mut T::Service) -> Out + Clone,
     Out: IntoFuture,
 {
@@ -139,9 +132,9 @@ where
     r: PhantomData<(In, Out)>,
 }
 
-impl<T, F, In, Out> ApplyNewServiceFuture<T, F, In, Out>
+impl<T, F, In, Out, Req, Cfg> ApplyNewServiceFuture<T, F, In, Out, Req, Cfg>
 where
-    T: NewService,
+    T: NewService<Req, Cfg>,
     F: FnMut(In, &mut T::Service) -> Out + Clone,
     Out: IntoFuture,
 {
@@ -154,14 +147,14 @@ where
     }
 }
 
-impl<T, F, In, Out> Future for ApplyNewServiceFuture<T, F, In, Out>
+impl<T, F, In, Out, Req, Cfg> Future for ApplyNewServiceFuture<T, F, In, Out, Req, Cfg>
 where
-    T: NewService,
+    T: NewService<Req, Cfg>,
     F: FnMut(In, &mut T::Service) -> Out + Clone,
     Out: IntoFuture,
     Out::Error: From<T::Error>,
 {
-    type Item = Apply<T::Service, F, In, Out>;
+    type Item = Apply<T::Service, Req, F, In, Out>;
     type Error = T::InitError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@@ -178,12 +171,12 @@ mod tests {
     use futures::future::{ok, FutureResult};
     use futures::{Async, Future, Poll};
 
-    use crate::{IntoNewService, IntoService, NewService, Service, ServiceExt};
+    use super::*;
+    use crate::{IntoService, NewService, Service, ServiceExt};
 
     #[derive(Clone)]
     struct Srv;
-    impl Service for Srv {
+    impl Service<()> for Srv {
-        type Request = ();
         type Response = ();
         type Error = ();
         type Future = FutureResult<(), ()>;
@@ -201,9 +194,11 @@ mod tests {
     fn test_call() {
         let blank = |req| Ok(req);
 
-        let mut srv = blank.into_service().apply(Srv, |req: &'static str, srv| {
+        let mut srv = blank
-            srv.call(()).map(move |res| (req, res))
+            .into_service()
-        });
+            .apply_fn(Srv, |req: &'static str, srv| {
+                srv.call(()).map(move |res| (req, res))
+            });
         assert!(srv.poll_ready().is_ok());
         let res = srv.call("srv").poll();
         assert!(res.is_ok());
@@ -212,13 +207,11 @@ mod tests {
 
     #[test]
     fn test_new_service() {
-        let blank = || Ok::<_, ()>((|req| Ok(req)).into_service());
+        let new_srv = ApplyNewService::new(
-
+            || Ok::<_, ()>(Srv),
-        let new_srv = blank.into_new_service().apply(
-            || Ok(Srv),
             |req: &'static str, srv| srv.call(()).map(move |res| (req, res)),
         );
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
             assert!(srv.poll_ready().is_ok());
             let res = srv.call("srv").poll();
             assert!(res.is_ok());

actix-service/src/blank.rs

@@ -0,0 +1,81 @@
+use std::marker::PhantomData;
+
+use futures::future::{ok, FutureResult};
+use futures::{Async, Poll};
+
+use super::{NewService, Service};
+
+/// Empty service
+#[derive(Clone)]
+pub struct Blank<R, E> {
+    _t: PhantomData<(R, E)>,
+}
+
+impl<R, E> Blank<R, E> {
+    pub fn err<E1>(self) -> Blank<R, E1> {
+        Blank { _t: PhantomData }
+    }
+}
+
+impl<R> Blank<R, ()> {
+    #[allow(clippy::new_ret_no_self)]
+    pub fn new<E>() -> Blank<R, E> {
+        Blank { _t: PhantomData }
+    }
+}
+
+impl<R, E> Default for Blank<R, E> {
+    fn default() -> Blank<R, E> {
+        Blank { _t: PhantomData }
+    }
+}
+
+impl<R, E> Service<R> for Blank<R, E> {
+    type Response = R;
+    type Error = E;
+    type Future = FutureResult<R, E>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, req: R) -> Self::Future {
+        ok(req)
+    }
+}
+
+/// Empty service factory
+pub struct BlankNewService<R, E1, E2 = ()> {
+    _t: PhantomData<(R, E1, E2)>,
+}
+
+impl<R, E1, E2> BlankNewService<R, E1, E2> {
+    pub fn new() -> BlankNewService<R, E1, E2> {
+        BlankNewService { _t: PhantomData }
+    }
+}
+
+impl<R, E1> BlankNewService<R, E1, ()> {
+    pub fn new_unit() -> BlankNewService<R, E1, ()> {
+        BlankNewService { _t: PhantomData }
+    }
+}
+
+impl<R, E1, E2> Default for BlankNewService<R, E1, E2> {
+    fn default() -> BlankNewService<R, E1, E2> {
+        Self::new()
+    }
+}
+
+impl<R, E1, E2> NewService<R, ()> for BlankNewService<R, E1, E2> {
+    type Response = R;
+    type Error = E1;
+    type Service = Blank<R, E1>;
+
+    type InitError = E2;
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &()) -> Self::Future {
+        ok(Blank::default())
+    }
+}

actix-service/src/boxed.rs

@@ -0,0 +1,144 @@
+use std::marker::PhantomData;
+
+use crate::{NewService, Service};
+use futures::{Future, IntoFuture, Poll};
+
+pub type BoxedService<Req, Res, Err> = Box<
+    Service<Req, Response = Res, Error = Err, Future = Box<Future<Item = Res, Error = Err>>>,
+>;
+
+/// Create boxed new service
+pub fn new_service<T, R, C>(
+    service: T,
+) -> BoxedNewService<C, R, T::Response, T::Error, T::InitError>
+where
+    C: 'static,
+    T: NewService<R, C> + 'static,
+    T::Response: 'static,
+    T::Service: 'static,
+    T::Future: 'static,
+    T::Error: 'static,
+    T::InitError: 'static,
+    R: 'static,
+{
+    BoxedNewService(Box::new(NewServiceWrapper {
+        service,
+        _t: PhantomData,
+    }))
+}
+
+/// Create boxed service
+pub fn service<T, R>(service: T) -> BoxedService<R, T::Response, T::Error>
+where
+    T: Service<R> + 'static,
+    T::Future: 'static,
+    R: 'static,
+{
+    Box::new(ServiceWrapper {
+        service,
+        _t: PhantomData,
+    })
+}
+
+type Inner<C, Req, Res, Err, InitErr> = Box<
+    NewService<
+        Req,
+        C,
+        Response = Res,
+        Error = Err,
+        InitError = InitErr,
+        Service = BoxedService<Req, Res, Err>,
+        Future = Box<Future<Item = BoxedService<Req, Res, Err>, Error = InitErr>>,
+    >,
+>;
+
+pub struct BoxedNewService<C, Req, Res, Err, InitErr>(Inner<C, Req, Res, Err, InitErr>);
+
+impl<C, Req, Res, Err, InitErr> NewService<Req, C>
+    for BoxedNewService<C, Req, Res, Err, InitErr>
+where
+    Req: 'static,
+    Res: 'static,
+    Err: 'static,
+    InitErr: 'static,
+{
+    type Response = Res;
+    type Error = Err;
+    type InitError = InitErr;
+    type Service = BoxedService<Req, Res, Err>;
+    type Future = Box<Future<Item = Self::Service, Error = Self::InitError>>;
+
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        self.0.new_service(cfg)
+    }
+}
+
+struct NewServiceWrapper<T: NewService<R, C>, R, C> {
+    service: T,
+    _t: std::marker::PhantomData<(R, C)>,
+}
+
+impl<C, T, Req, Res, Err, InitErr> NewService<Req, C> for NewServiceWrapper<T, Req, C>
+where
+    Req: 'static,
+    Res: 'static,
+    Err: 'static,
+    InitErr: 'static,
+    T: NewService<Req, C, Response = Res, Error = Err, InitError = InitErr>,
+    T::Future: 'static,
+    T::Service: 'static,
+    <T::Service as Service<Req>>::Future: 'static,
+{
+    type Response = Res;
+    type Error = Err;
+    type InitError = InitErr;
+    type Service = BoxedService<Req, Res, Err>;
+    type Future = Box<Future<Item = Self::Service, Error = Self::InitError>>;
+
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        Box::new(
+            self.service
+                .new_service(cfg)
+                .into_future()
+                .map(ServiceWrapper::boxed),
+        )
+    }
+}
+
+struct ServiceWrapper<T: Service<R>, R> {
+    service: T,
+    _t: PhantomData<R>,
+}
+
+impl<T, R> ServiceWrapper<T, R>
+where
+    T: Service<R> + 'static,
+    T::Future: 'static,
+    R: 'static,
+{
+    fn boxed(service: T) -> BoxedService<R, T::Response, T::Error> {
+        Box::new(ServiceWrapper {
+            service,
+            _t: PhantomData,
+        })
+    }
+}
+
+impl<T, Req, Res, Err> Service<Req> for ServiceWrapper<T, Req>
+where
+    T: Service<Req, Response = Res, Error = Err>,
+    T::Future: 'static,
+    Req: 'static,
+{
+    type Response = Res;
+    type Error = Err;
+    type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.service.poll_ready()
+    }
+
+    fn call(&mut self, req: Req) -> Self::Future {
+        Box::new(self.service.call(req))
+    }
+}

actix-service/src/fn_service.rs

@@ -1,56 +1,79 @@
-use std::marker;
+use std::marker::PhantomData;
 
-use futures::{
+use futures::future::{ok, FutureResult};
-    future::{ok, FutureResult},
+use futures::{Async, IntoFuture, Poll};
-    Async, IntoFuture, Poll,
-};
 
-use super::{IntoNewService, IntoService, NewService, Service};
+use crate::{IntoConfigurableNewService, IntoNewService, IntoService, NewService, Service};
 
-pub struct FnService<F, Req, Resp, E, Fut>
+/// Create `NewService` for function that can act as Service
+pub fn fn_service<F, Req, Out, Cfg>(f: F) -> FnNewService<F, Req, Out, Cfg>
 where
-    F: FnMut(Req) -> Fut,
+    F: FnMut(Req) -> Out + Clone,
-    Fut: IntoFuture<Item = Resp, Error = E>,
+    Out: IntoFuture,
 {
-    f: F,
+    FnNewService::new(f)
-    _t: marker::PhantomData<(Req, Resp, E)>,
 }
 
-impl<F, Req, Resp, E, Fut> FnService<F, Req, Resp, E, Fut>
+/// Create `NewService` for function that can produce services
+pub fn fn_factory<F, R, S, E, Req>(f: F) -> FnNewServiceNoConfig<F, R, S, E, Req>
 where
-    F: FnMut(Req) -> Fut,
+    F: Fn() -> R,
-    Fut: IntoFuture<Item = Resp, Error = E>,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service<Req>,
+{
+    FnNewServiceNoConfig::new(f)
+}
+
+/// Create `NewService` for function that can produce services with configuration
+pub fn fn_cfg_factory<F, C, R, S, E, Req>(f: F) -> FnNewServiceConfig<F, C, R, S, E, Req>
+where
+    F: Fn(&C) -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service<Req>,
+{
+    FnNewServiceConfig::new(f)
+}
+
+pub struct FnService<F, Req, Out>
+where
+    F: FnMut(Req) -> Out,
+    Out: IntoFuture,
+{
+    f: F,
+    _t: PhantomData<(Req,)>,
+}
+
+impl<F, Req, Out> FnService<F, Req, Out>
+where
+    F: FnMut(Req) -> Out,
+    Out: IntoFuture,
 {
     pub fn new(f: F) -> Self {
-        FnService {
+        FnService { f, _t: PhantomData }
-            f,
-            _t: marker::PhantomData,
-        }
     }
 }
 
-impl<F, Req, Resp, E, Fut> Clone for FnService<F, Req, Resp, E, Fut>
+impl<F, Req, Out> Clone for FnService<F, Req, Out>
 where
-    F: FnMut(Req) -> Fut + Clone,
+    F: FnMut(Req) -> Out + Clone,
-    Fut: IntoFuture<Item = Resp, Error = E>,
+    Out: IntoFuture,
 {
     fn clone(&self) -> Self {
         FnService {
             f: self.f.clone(),
-            _t: marker::PhantomData,
+            _t: PhantomData,
         }
     }
 }
 
-impl<F, Req, Resp, E, Fut> Service for FnService<F, Req, Resp, E, Fut>
+impl<F, Req, Out> Service<Req> for FnService<F, Req, Out>
 where
-    F: FnMut(Req) -> Fut,
+    F: FnMut(Req) -> Out,
-    Fut: IntoFuture<Item = Resp, Error = E>,
+    Out: IntoFuture,
 {
-    type Request = Req;
+    type Response = Out::Item;
-    type Response = Resp;
+    type Error = Out::Error;
-    type Error = E;
+    type Future = Out::Future;
-    type Future = Fut::Future;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         Ok(Async::Ready(()))
@@ -61,71 +84,210 @@ where
     }
 }
 
-impl<F, Req, Resp, Err, Fut> IntoService<FnService<F, Req, Resp, Err, Fut>> for F
+impl<F, Req, Out> IntoService<FnService<F, Req, Out>, Req> for F
 where
-    F: FnMut(Req) -> Fut + 'static,
+    F: FnMut(Req) -> Out + 'static,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    Out: IntoFuture,
 {
-    fn into_service(self) -> FnService<F, Req, Resp, Err, Fut> {
+    fn into_service(self) -> FnService<F, Req, Out> {
         FnService::new(self)
     }
 }
 
-pub struct FnNewService<F, Req, Resp, Err, Fut>
+pub struct FnNewService<F, Req, Out, Cfg>
 where
-    F: FnMut(Req) -> Fut,
+    F: FnMut(Req) -> Out,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    Out: IntoFuture,
 {
     f: F,
-    _t: marker::PhantomData<(Req, Resp, Err)>,
+    _t: PhantomData<(Req, Cfg)>,
 }
 
-impl<F, Req, Resp, Err, Fut> FnNewService<F, Req, Resp, Err, Fut>
+impl<F, Req, Out, Cfg> FnNewService<F, Req, Out, Cfg>
 where
-    F: FnMut(Req) -> Fut + Clone,
+    F: FnMut(Req) -> Out + Clone,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    Out: IntoFuture,
 {
     pub fn new(f: F) -> Self {
-        FnNewService {
+        FnNewService { f, _t: PhantomData }
-            f,
-            _t: marker::PhantomData,
-        }
     }
 }
 
-impl<F, Req, Resp, Err, Fut> NewService for FnNewService<F, Req, Resp, Err, Fut>
+impl<F, Req, Out, Cfg> NewService<Req, Cfg> for FnNewService<F, Req, Out, Cfg>
 where
-    F: FnMut(Req) -> Fut + Clone,
+    F: FnMut(Req) -> Out + Clone,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    Out: IntoFuture,
 {
-    type Request = Req;
+    type Response = Out::Item;
-    type Response = Resp;
+    type Error = Out::Error;
-    type Error = Err;
+    type Service = FnService<F, Req, Out>;
-    type Service = FnService<F, Req, Resp, Err, Fut>;
+
     type InitError = ();
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, _: &Cfg) -> Self::Future {
         ok(FnService::new(self.f.clone()))
     }
 }
 
-impl<F, Req, Resp, Err, Fut> IntoNewService<FnNewService<F, Req, Resp, Err, Fut>> for F
+impl<F, Req, Out, Cfg> Clone for FnNewService<F, Req, Out, Cfg>
 where
-    F: FnMut(Req) -> Fut + Clone + 'static,
+    F: FnMut(Req) -> Out + Clone,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    Out: IntoFuture,
-{
-    fn into_new_service(self) -> FnNewService<F, Req, Resp, Err, Fut> {
-        FnNewService::new(self)
-    }
-}
-
-impl<F, Req, Resp, Err, Fut> Clone for FnNewService<F, Req, Resp, Err, Fut>
-where
-    F: FnMut(Req) -> Fut + Clone,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
 {
     fn clone(&self) -> Self {
         Self::new(self.f.clone())
     }
 }
+
+impl<F, Req, Out, Cfg> IntoNewService<FnNewService<F, Req, Out, Cfg>, Req, Cfg> for F
+where
+    F: Fn(Req) -> Out + Clone,
+    Out: IntoFuture,
+{
+    fn into_new_service(self) -> FnNewService<F, Req, Out, Cfg> {
+        FnNewService::new(self)
+    }
+}
+
+/// Converter for `Fn() -> Future<Service>` fn
+pub struct FnNewServiceNoConfig<F, R, S, E, Req>
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service<Req>,
+{
+    f: F,
+    _t: PhantomData<Req>,
+}
+
+impl<F, R, S, E, Req> FnNewServiceNoConfig<F, R, S, E, Req>
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service<Req>,
+{
+    pub fn new(f: F) -> Self {
+        FnNewServiceNoConfig { f, _t: PhantomData }
+    }
+}
+
+impl<F, R, S, E, Req> NewService<Req, ()> for FnNewServiceNoConfig<F, R, S, E, Req>
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service<Req>,
+{
+    type Response = S::Response;
+    type Error = S::Error;
+    type Service = S;
+
+    type InitError = E;
+    type Future = R::Future;
+
+    fn new_service(&self, _: &()) -> Self::Future {
+        (self.f)().into_future()
+    }
+}
+
+impl<F, R, S, E, Req> Clone for FnNewServiceNoConfig<F, R, S, E, Req>
+where
+    F: Fn() -> R + Clone,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service<Req>,
+{
+    fn clone(&self) -> Self {
+        Self::new(self.f.clone())
+    }
+}
+
+impl<F, R, S, E, Req> IntoNewService<FnNewServiceNoConfig<F, R, S, E, Req>, Req, ()> for F
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service<Req>,
+{
+    fn into_new_service(self) -> FnNewServiceNoConfig<F, R, S, E, Req> {
+        FnNewServiceNoConfig::new(self)
+    }
+}
+
+/// Convert `Fn(&Config) -> Future<Service>` fn to NewService
+pub struct FnNewServiceConfig<F, C, R, S, E, Req>
+where
+    F: Fn(&C) -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service<Req>,
+{
+    f: F,
+    _t: PhantomData<(C, R, S, E, Req)>,
+}
+
+impl<F, C, R, S, E, Req> FnNewServiceConfig<F, C, R, S, E, Req>
+where
+    F: Fn(&C) -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service<Req>,
+{
+    pub fn new(f: F) -> Self {
+        FnNewServiceConfig { f, _t: PhantomData }
+    }
+}
+
+impl<F, C, R, S, E, Req> NewService<Req, C> for FnNewServiceConfig<F, C, R, S, E, Req>
+where
+    F: Fn(&C) -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service<Req>,
+{
+    type Response = S::Response;
+    type Error = S::Error;
+    type Service = S;
+
+    type InitError = E;
+    type Future = R::Future;
+
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        (self.f)(cfg).into_future()
+    }
+}
+
+impl<F, C, R, S, E, Req> Clone for FnNewServiceConfig<F, C, R, S, E, Req>
+where
+    F: Fn(&C) -> R + Clone,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service<Req>,
+{
+    fn clone(&self) -> Self {
+        Self::new(self.f.clone())
+    }
+}
+
+impl<F, C, R, S, E, Req>
+    IntoConfigurableNewService<FnNewServiceConfig<F, C, R, S, E, Req>, Req, C> for F
+where
+    F: Fn(&C) -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service<Req>,
+{
+    fn into_new_service(self) -> FnNewServiceConfig<F, C, R, S, E, Req> {
+        FnNewServiceConfig::new(self)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{IntoService, Service, ServiceExt};
+
+    #[test]
+    fn test_fn_service() {
+        let mut rt = actix_rt::Runtime::new().unwrap();
+
+        let srv = (|_t: &str| -> Result<usize, ()> { Ok(1) }).into_service();
+        let mut srv = srv.and_then(|test: usize| Ok(test));
+
+        let s = "HELLO".to_owned();
+        let res = rt.block_on(srv.call(&s)).unwrap();
+        assert_eq!(res, 1);
+    }
+}

actix-service/src/fn_transform.rs

@@ -0,0 +1,65 @@
+use std::marker::PhantomData;
+
+use futures::future::{ok, FutureResult};
+use futures::IntoFuture;
+
+use crate::{Apply, IntoTransform, Service, Transform};
+
+pub struct FnTransform<F, S, R, In, Out, Err>
+where
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
+{
+    f: F,
+    _t: PhantomData<(S, R, In, Out, Err)>,
+}
+
+impl<F, S, R, In, Out, Err> FnTransform<F, S, R, In, Out, Err>
+where
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
+{
+    pub fn new(f: F) -> Self {
+        FnTransform { f, _t: PhantomData }
+    }
+}
+
+impl<F, S, R, In, Out, Err> Transform<S, In> for FnTransform<F, S, R, In, Out, Err>
+where
+    S: Service<R>,
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
+    Out::Error: From<S::Error>,
+{
+    type Response = Out::Item;
+    type Error = Out::Error;
+    type Transform = Apply<S, R, F, In, Out>;
+    type InitError = Err;
+    type Future = FutureResult<Self::Transform, Self::InitError>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        ok(Apply::new(service, self.f.clone()))
+    }
+}
+
+impl<F, S, R, In, Out, Err> IntoTransform<FnTransform<F, S, R, In, Out, Err>, S, In> for F
+where
+    S: Service<R>,
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
+    Out::Error: From<S::Error>,
+{
+    fn into_transform(self) -> FnTransform<F, S, R, In, Out, Err> {
+        FnTransform::new(self)
+    }
+}
+
+impl<F, S, R, In, Out, Err> Clone for FnTransform<F, S, R, In, Out, Err>
+where
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
+{
+    fn clone(&self) -> Self {
+        Self::new(self.f.clone())
+    }
+}

actix-service/src/from_err.rs

@@ -13,9 +13,9 @@ pub struct FromErr<A, E> {
 }
 
 impl<A, E> FromErr<A, E> {
-    pub(crate) fn new(service: A) -> Self
+    pub(crate) fn new<R>(service: A) -> Self
     where
-        A: Service,
+        A: Service<R>,
         E: From<A::Error>,
     {
         FromErr {
@@ -37,21 +37,20 @@ where
     }
 }
 
-impl<A, E> Service for FromErr<A, E>
+impl<A, E, R> Service<R> for FromErr<A, E>
 where
-    A: Service,
+    A: Service<R>,
     E: From<A::Error>,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
-    type Future = FromErrFuture<A, E>;
+    type Future = FromErrFuture<A, R, E>;
 
     fn poll_ready(&mut self) -> Poll<(), E> {
         self.service.poll_ready().map_err(E::from)
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: R) -> Self::Future {
         FromErrFuture {
             fut: self.service.call(req),
             f: PhantomData,
@@ -59,14 +58,14 @@ where
     }
 }
 
-pub struct FromErrFuture<A: Service, E> {
+pub struct FromErrFuture<A: Service<R>, R, E> {
     fut: A::Future,
     f: PhantomData<E>,
 }
 
-impl<A, E> Future for FromErrFuture<A, E>
+impl<A, R, E> Future for FromErrFuture<A, R, E>
 where
-    A: Service,
+    A: Service<R>,
     E: From<A::Error>,
 {
     type Item = A::Response;
@@ -81,23 +80,23 @@ where
 /// service's error.
 ///
 /// This is created by the `NewServiceExt::from_err` method.
-pub struct FromErrNewService<A, E> {
+pub struct FromErrNewService<A, E, C> {
     a: A,
-    e: PhantomData<E>,
+    e: PhantomData<(E, C)>,
 }
 
-impl<A, E> FromErrNewService<A, E> {
+impl<A, E, C> FromErrNewService<A, E, C> {
     /// Create new `FromErr` new service instance
-    pub fn new(a: A) -> Self
+    pub fn new<R>(a: A) -> Self
     where
-        A: NewService,
+        A: NewService<R, C>,
         E: From<A::Error>,
     {
         Self { a, e: PhantomData }
     }
 }
 
-impl<A, E> Clone for FromErrNewService<A, E>
+impl<A, E, C> Clone for FromErrNewService<A, E, C>
 where
     A: Clone,
 {
@@ -109,39 +108,38 @@ where
     }
 }
 
-impl<A, E> NewService for FromErrNewService<A, E>
+impl<A, E, C, R> NewService<R, C> for FromErrNewService<A, E, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
     E: From<A::Error>,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
     type Service = FromErr<A::Service, E>;
 
     type InitError = A::InitError;
-    type Future = FromErrNewServiceFuture<A, E>;
+    type Future = FromErrNewServiceFuture<A, E, C, R>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &C) -> Self::Future {
         FromErrNewServiceFuture {
-            fut: self.a.new_service(),
+            fut: self.a.new_service(cfg),
             e: PhantomData,
         }
     }
 }
 
-pub struct FromErrNewServiceFuture<A, E>
+pub struct FromErrNewServiceFuture<A, E, C, R>
 where
-    A: NewService,
+    A: NewService<R, C>,
     E: From<A::Error>,
 {
     fut: A::Future,
     e: PhantomData<E>,
 }
 
-impl<A, E> Future for FromErrNewServiceFuture<A, E>
+impl<A, E, C, R> Future for FromErrNewServiceFuture<A, E, C, R>
 where
-    A: NewService,
+    A: NewService<R, C>,
     E: From<A::Error>,
 {
     type Item = FromErr<A::Service, E>;
@@ -164,8 +162,7 @@ mod tests {
     use crate::{IntoNewService, NewService, Service, ServiceExt};
 
     struct Srv;
-    impl Service for Srv {
+    impl Service<()> for Srv {
-        type Request = ();
         type Response = ();
         type Error = ();
         type Future = FutureResult<(), ()>;
@@ -208,7 +205,7 @@ mod tests {
     fn test_new_service() {
         let blank = || Ok::<_, ()>(Srv);
         let new_srv = blank.into_new_service().from_err::<Error>();
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
             let res = srv.call(()).poll();
             assert!(res.is_err());
             assert_eq!(res.err().unwrap(), Error);

actix-service/src/lib.rs

@@ -1,31 +1,44 @@
+use std::rc::Rc;
+use std::sync::Arc;
+
 use futures::{Future, IntoFuture, Poll};
 
+pub use void::Void;
+
 mod and_then;
 mod and_then_apply;
+mod and_then_apply_fn;
 mod apply;
+pub mod blank;
+pub mod boxed;
 mod cell;
 mod fn_service;
+mod fn_transform;
 mod from_err;
 mod map;
 mod map_err;
 mod map_init_err;
 mod then;
+mod transform;
+mod transform_map_init_err;
 
 pub use self::and_then::{AndThen, AndThenNewService};
-pub use self::and_then_apply::{AndThenApply, AndThenApplyNewService};
+use self::and_then_apply::AndThenTransform;
+use self::and_then_apply_fn::{AndThenApply, AndThenApplyNewService};
 pub use self::apply::{Apply, ApplyNewService};
-pub use self::fn_service::{FnNewService, FnService};
+pub use self::fn_service::{fn_cfg_factory, fn_factory, fn_service, FnService};
+pub use self::fn_transform::FnTransform;
 pub use self::from_err::{FromErr, FromErrNewService};
 pub use self::map::{Map, MapNewService};
 pub use self::map_err::{MapErr, MapErrNewService};
 pub use self::map_init_err::MapInitErr;
 pub use self::then::{Then, ThenNewService};
+pub use self::transform::{ApplyTransform, IntoTransform, Transform};
 
 /// An asynchronous function from `Request` to a `Response`.
-pub trait Service {
+///
-    /// Requests handled by the service.
+/// `Request` - requests handled by the service.
-    type Request;
+pub trait Service<Request> {
-
     /// Responses given by the service.
     type Response;
 
@@ -55,22 +68,26 @@ pub trait Service {
     ///
     /// Calling `call` without calling `poll_ready` is permitted. The
     /// implementation must be resilient to this fact.
-    fn call(&mut self, req: Self::Request) -> Self::Future;
+    fn call(&mut self, req: Request) -> Self::Future;
 }
 
 /// An extension trait for `Service`s that provides a variety of convenient
 /// adapters
-pub trait ServiceExt: Service {
+pub trait ServiceExt<Request>: Service<Request> {
     /// Apply function to specified service and use it as a next service in
     /// chain.
-    fn apply<B, I, F, Out, Req>(self, service: I, f: F) -> AndThenApply<Self, B, F, Out>
+    fn apply_fn<F, B, B1, Out, Req>(
+        self,
+        service: B1,
+        f: F,
+    ) -> AndThenApply<Self, B, F, Out, Request, Req>
     where
         Self: Sized,
-        B: Service<Request = Req, Error = Self::Error>,
-        I: IntoService<B>,
         F: FnMut(Self::Response, &mut B) -> Out,
         Out: IntoFuture,
         Out::Error: Into<Self::Error>,
+        B: Service<Req, Error = Self::Error>,
+        B1: IntoService<B, Req>,
     {
         AndThenApply::new(self, service, f)
     }
@@ -87,8 +104,8 @@ pub trait ServiceExt: Service {
     fn and_then<F, B>(self, service: F) -> AndThen<Self, B>
     where
         Self: Sized,
-        F: IntoService<B>,
+        F: IntoService<B, Self::Response>,
-        B: Service<Request = Self::Response, Error = Self::Error>,
+        B: Service<Self::Response, Error = Self::Error>,
     {
         AndThen::new(self, service.into_service())
     }
@@ -114,7 +131,7 @@ pub trait ServiceExt: Service {
     fn then<B>(self, service: B) -> Then<Self, B>
     where
         Self: Sized,
-        B: Service<Request = Result<Self::Response, Self::Error>, Error = Self::Error>,
+        B: Service<Result<Self::Response, Self::Error>, Error = Self::Error>,
     {
         Then::new(self, service)
     }
@@ -153,7 +170,7 @@ pub trait ServiceExt: Service {
     }
 }
 
-impl<T: ?Sized> ServiceExt for T where T: Service {}
+impl<T: ?Sized, R> ServiceExt<R> for T where T: Service<R> {}
 
 /// Creates new `Service` values.
 ///
@@ -162,10 +179,10 @@ impl<T: ?Sized> ServiceExt for T where T: Service {}
 /// accepts new TCP streams, obtains a new `Service` value using the
 /// `NewService` trait, and uses that new `Service` value to process inbound
 /// requests on that new TCP stream.
-pub trait NewService {
+///
-    /// Requests handled by the service.
+/// * `Request` - requests handled by the service.
-    type Request;
+/// * `Config` - is a service factory configuration type.
-
+pub trait NewService<Request, Config = ()> {
     /// Responses given by the service
     type Response;
 
@@ -173,11 +190,7 @@ pub trait NewService {
     type Error;
 
     /// The `Service` value created by this factory
-    type Service: Service<
+    type Service: Service<Request, Response = Self::Response, Error = Self::Error>;
-        Request = Self::Request,
-        Response = Self::Response,
-        Error = Self::Error,
-    >;
 
     /// Errors produced while building a service.
     type InitError;
@@ -186,19 +199,37 @@ pub trait NewService {
     type Future: Future<Item = Self::Service, Error = Self::InitError>;
 
     /// Create and return a new service value asynchronously.
-    fn new_service(&self) -> Self::Future;
+    fn new_service(&self, cfg: &Config) -> Self::Future;
 
     /// Apply function to specified service and use it as a next service in
     /// chain.
-    fn apply<B, I, F, Out, Req>(
+    fn apply<T, T1, B, B1, Req>(
+        self,
+        transform: T1,
+        service: B1,
+    ) -> AndThenTransform<T, Self, B, Req>
+    where
+        Self: Sized,
+        T: Transform<B::Service, Self::Response, InitError = Self::InitError>,
+        T::Error: From<Self::Error>,
+        T1: IntoTransform<T, B::Service, Self::Response>,
+        B: NewService<Req, Config, InitError = Self::InitError>,
+        B1: IntoNewService<B, Req, Config>,
+    {
+        AndThenTransform::new(transform.into_transform(), self, service.into_new_service())
+    }
+
+    /// Apply function to specified service and use it as a next service in
+    /// chain.
+    fn apply_fn<B, I, F, Out, Req>(
         self,
         service: I,
         f: F,
-    ) -> AndThenApplyNewService<Self, B, F, Out>
+    ) -> AndThenApplyNewService<Self, B, F, Out, Request, Req, Config>
     where
         Self: Sized,
-        B: NewService<Request = Req, Error = Self::Error, InitError = Self::InitError>,
+        B: NewService<Req, Config, Error = Self::Error, InitError = Self::InitError>,
-        I: IntoNewService<B>,
+        I: IntoNewService<B, Req, Config>,
         F: FnMut(Self::Response, &mut B::Service) -> Out,
         Out: IntoFuture,
         Out::Error: Into<Self::Error>,
@@ -210,12 +241,8 @@ pub trait NewService {
     fn and_then<F, B>(self, new_service: F) -> AndThenNewService<Self, B>
     where
         Self: Sized,
-        F: IntoNewService<B>,
+        F: IntoNewService<B, Self::Response, Config>,
-        B: NewService<
+        B: NewService<Self::Response, Config, Error = Self::Error, InitError = Self::InitError>,
-            Request = Self::Response,
-            Error = Self::Error,
-            InitError = Self::InitError,
-        >,
     {
         AndThenNewService::new(self, new_service)
     }
@@ -226,7 +253,7 @@ pub trait NewService {
     ///
     /// Note that this function consumes the receiving new service and returns a
     /// wrapped version of it.
-    fn from_err<E>(self) -> FromErrNewService<Self, E>
+    fn from_err<E>(self) -> FromErrNewService<Self, E, Config>
     where
         Self: Sized,
         E: From<Self::Error>,
@@ -240,22 +267,23 @@ pub trait NewService {
     ///
     /// Note that this function consumes the receiving future and returns a
     /// wrapped version of it.
-    fn then<F, B>(self, new_service: F) -> ThenNewService<Self, B>
+    fn then<F, B>(self, new_service: F) -> ThenNewService<Self, B, Config>
     where
         Self: Sized,
-        F: IntoNewService<B>,
+        F: IntoNewService<B, Result<Self::Response, Self::Error>, Config>,
         B: NewService<
-            Request = Result<Self::Response, Self::Error>,
+            Result<Self::Response, Self::Error>,
+            Config,
             Error = Self::Error,
             InitError = Self::InitError,
         >,
     {
-        ThenNewService::new(self, new_service)
+        ThenNewService::new(self, new_service.into_new_service())
     }
 
     /// Map this service's output to a different type, returning a new service
     /// of the resulting type.
-    fn map<F, R>(self, f: F) -> MapNewService<Self, F, R>
+    fn map<F, R>(self, f: F) -> MapNewService<Self, F, R, Config>
     where
         Self: Sized,
         F: FnMut(Self::Response) -> R,
@@ -264,7 +292,7 @@ pub trait NewService {
     }
 
     /// Map this service's error to a different error, returning a new service.
-    fn map_err<F, E>(self, f: F) -> MapErrNewService<Self, F, E>
+    fn map_err<F, E>(self, f: F) -> MapErrNewService<Self, F, E, Config>
     where
         Self: Sized,
         F: Fn(Self::Error) -> E,
@@ -273,7 +301,7 @@ pub trait NewService {
     }
 
     /// Map this service's init error to a different error, returning a new service.
-    fn map_init_err<F, E>(self, f: F) -> MapInitErr<Self, F, E>
+    fn map_init_err<F, E>(self, f: F) -> MapInitErr<Self, F, E, Config>
     where
         Self: Sized,
         F: Fn(Self::InitError) -> E,
@@ -282,11 +310,10 @@ pub trait NewService {
     }
 }
 
-impl<'a, S> Service for &'a mut S
+impl<'a, S, R> Service<R> for &'a mut S
 where
-    S: Service + 'a,
+    S: Service<R> + 'a,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -295,16 +322,15 @@ where
         (**self).poll_ready()
     }
 
-    fn call(&mut self, request: Self::Request) -> S::Future {
+    fn call(&mut self, request: R) -> S::Future {
         (**self).call(request)
     }
 }
 
-impl<S> Service for Box<S>
+impl<S, R> Service<R> for Box<S>
 where
-    S: Service + ?Sized,
+    S: Service<R> + ?Sized,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -313,59 +339,89 @@ where
         (**self).poll_ready()
     }
 
-    fn call(&mut self, request: Self::Request) -> S::Future {
+    fn call(&mut self, request: R) -> S::Future {
         (**self).call(request)
     }
 }
 
-impl<F, R, E, S> NewService for F
+impl<S, R, C> NewService<R, C> for Rc<S>
 where
-    F: Fn() -> R,
+    S: NewService<R, C>,
-    R: IntoFuture<Item = S, Error = E>,
-    S: Service,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
-    type Service = S;
+    type Service = S::Service;
-    type InitError = E;
+    type InitError = S::InitError;
-    type Future = R::Future;
+    type Future = S::Future;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &C) -> S::Future {
-        (*self)().into_future()
+        self.as_ref().new_service(cfg)
+    }
+}
+
+impl<S, R, C> NewService<R, C> for Arc<S>
+where
+    S: NewService<R, C>,
+{
+    type Response = S::Response;
+    type Error = S::Error;
+    type Service = S::Service;
+    type InitError = S::InitError;
+    type Future = S::Future;
+
+    fn new_service(&self, cfg: &C) -> S::Future {
+        self.as_ref().new_service(cfg)
     }
 }
 
 /// Trait for types that can be converted to a `Service`
-pub trait IntoService<T>
+pub trait IntoService<T, R>
 where
-    T: Service,
+    T: Service<R>,
 {
     /// Convert to a `Service`
     fn into_service(self) -> T;
 }
 
-/// Trait for types that can be converted to a Service
+/// Trait for types that can be converted to a `NewService`
-pub trait IntoNewService<T>
+pub trait IntoNewService<T, R, C = ()>
 where
-    T: NewService,
+    T: NewService<R, C>,
 {
     /// Convert to an `NewService`
     fn into_new_service(self) -> T;
 }
 
-impl<T> IntoService<T> for T
+impl<T, R> IntoService<T, R> for T
 where
-    T: Service,
+    T: Service<R>,
 {
     fn into_service(self) -> T {
         self
     }
 }
 
-impl<T> IntoNewService<T> for T
+impl<T, R, C> IntoNewService<T, R, C> for T
 where
-    T: NewService,
+    T: NewService<R, C>,
+{
+    fn into_new_service(self) -> T {
+        self
+    }
+}
+
+/// Trait for types that can be converted to a configurable `NewService`
+pub trait IntoConfigurableNewService<T, R, C>
+where
+    T: NewService<R, C>,
+{
+    /// Convert to an `NewService`
+    fn into_new_service(self) -> T;
+}
+
+impl<T, R, C> IntoConfigurableNewService<T, R, C> for T
+where
+    T: NewService<R, C>,
 {
     fn into_new_service(self) -> T {
         self

actix-service/src/map.rs

@@ -15,9 +15,9 @@ pub struct Map<A, F, Response> {
 
 impl<A, F, Response> Map<A, F, Response> {
     /// Create new `Map` combinator
-    pub fn new(service: A, f: F) -> Self
+    pub fn new<R>(service: A, f: F) -> Self
     where
-        A: Service,
+        A: Service<R>,
         F: FnMut(A::Response) -> Response,
     {
         Self {
@@ -42,37 +42,36 @@ where
     }
 }
 
-impl<A, F, Response> Service for Map<A, F, Response>
+impl<A, F, R, Response> Service<R> for Map<A, F, Response>
 where
-    A: Service,
+    A: Service<R>,
     F: FnMut(A::Response) -> Response + Clone,
 {
-    type Request = A::Request;
     type Response = Response;
     type Error = A::Error;
-    type Future = MapFuture<A, F, Response>;
+    type Future = MapFuture<A, F, R, Response>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready()
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: R) -> Self::Future {
         MapFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
-pub struct MapFuture<A, F, Response>
+pub struct MapFuture<A, F, R, Response>
 where
-    A: Service,
+    A: Service<R>,
     F: FnMut(A::Response) -> Response,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, Response> MapFuture<A, F, Response>
+impl<A, F, R, Response> MapFuture<A, F, R, Response>
 where
-    A: Service,
+    A: Service<R>,
     F: FnMut(A::Response) -> Response,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -80,9 +79,9 @@ where
     }
 }
 
-impl<A, F, Response> Future for MapFuture<A, F, Response>
+impl<A, F, R, Response> Future for MapFuture<A, F, R, Response>
 where
-    A: Service,
+    A: Service<R>,
     F: FnMut(A::Response) -> Response,
 {
     type Item = Response;
@@ -97,18 +96,18 @@ where
 }
 
 /// `MapNewService` new service combinator
-pub struct MapNewService<A, F, Response> {
+pub struct MapNewService<A, F, Res, Cfg> {
     a: A,
     f: F,
-    r: PhantomData<Response>,
+    r: PhantomData<(Res, Cfg)>,
 }
 
-impl<A, F, Response> MapNewService<A, F, Response> {
+impl<A, F, Res, Cfg> MapNewService<A, F, Res, Cfg> {
     /// Create new `Map` new service instance
-    pub fn new(a: A, f: F) -> Self
+    pub fn new<Req>(a: A, f: F) -> Self
     where
-        A: NewService,
+        A: NewService<Req, Cfg>,
-        F: FnMut(A::Response) -> Response,
+        F: FnMut(A::Response) -> Res,
     {
         Self {
             a,
@@ -118,7 +117,7 @@ impl<A, F, Response> MapNewService<A, F, Response> {
     }
 }
 
-impl<A, F, Response> Clone for MapNewService<A, F, Response>
+impl<A, F, Res, Cfg> Clone for MapNewService<A, F, Res, Cfg>
 where
     A: Clone,
     F: Clone,
@@ -132,49 +131,48 @@ where
     }
 }
 
-impl<A, F, Response> NewService for MapNewService<A, F, Response>
+impl<A, F, Req, Res, Cfg> NewService<Req, Cfg> for MapNewService<A, F, Res, Cfg>
 where
-    A: NewService,
+    A: NewService<Req, Cfg>,
-    F: FnMut(A::Response) -> Response + Clone,
+    F: FnMut(A::Response) -> Res + Clone,
 {
-    type Request = A::Request;
+    type Response = Res;
-    type Response = Response;
     type Error = A::Error;
-    type Service = Map<A::Service, F, Response>;
+    type Service = Map<A::Service, F, Res>;
 
     type InitError = A::InitError;
-    type Future = MapNewServiceFuture<A, F, Response>;
+    type Future = MapNewServiceFuture<A, F, Req, Res, Cfg>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &Cfg) -> Self::Future {
-        MapNewServiceFuture::new(self.a.new_service(), self.f.clone())
+        MapNewServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-pub struct MapNewServiceFuture<A, F, Response>
+pub struct MapNewServiceFuture<A, F, Req, Res, Cfg>
 where
-    A: NewService,
+    A: NewService<Req, Cfg>,
-    F: FnMut(A::Response) -> Response,
+    F: FnMut(A::Response) -> Res,
 {
     fut: A::Future,
     f: Option<F>,
 }
 
-impl<A, F, Response> MapNewServiceFuture<A, F, Response>
+impl<A, F, Req, Res, Cfg> MapNewServiceFuture<A, F, Req, Res, Cfg>
 where
-    A: NewService,
+    A: NewService<Req, Cfg>,
-    F: FnMut(A::Response) -> Response,
+    F: FnMut(A::Response) -> Res,
 {
     fn new(fut: A::Future, f: F) -> Self {
         MapNewServiceFuture { f: Some(f), fut }
     }
 }
 
-impl<A, F, Response> Future for MapNewServiceFuture<A, F, Response>
+impl<A, F, Req, Res, Cfg> Future for MapNewServiceFuture<A, F, Req, Res, Cfg>
 where
-    A: NewService,
+    A: NewService<Req, Cfg>,
-    F: FnMut(A::Response) -> Response,
+    F: FnMut(A::Response) -> Res,
 {
-    type Item = Map<A::Service, F, Response>;
+    type Item = Map<A::Service, F, Res>;
     type Error = A::InitError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@@ -194,8 +192,7 @@ mod tests {
     use crate::{IntoNewService, Service, ServiceExt};
 
     struct Srv;
-    impl Service for Srv {
+    impl Service<()> for Srv {
-        type Request = ();
         type Response = ();
         type Error = ();
         type Future = FutureResult<(), ()>;
@@ -229,7 +226,7 @@ mod tests {
     fn test_new_service() {
         let blank = || Ok::<_, ()>(Srv);
         let new_srv = blank.into_new_service().map(|_| "ok");
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
             let res = srv.call(()).poll();
             assert!(res.is_ok());
             assert_eq!(res.unwrap(), Async::Ready("ok"));

actix-service/src/map_err.rs

@@ -16,9 +16,9 @@ pub struct MapErr<A, F, E> {
 
 impl<A, F, E> MapErr<A, F, E> {
     /// Create new `MapErr` combinator
-    pub fn new(service: A, f: F) -> Self
+    pub fn new<R>(service: A, f: F) -> Self
     where
-        A: Service,
+        A: Service<R>,
         F: Fn(A::Error) -> E,
     {
         Self {
@@ -43,47 +43,39 @@ where
     }
 }
 
-impl<A, F, E> Service for MapErr<A, F, E>
+impl<A, F, E, R> Service<R> for MapErr<A, F, E>
 where
-    A: Service,
+    A: Service<R>,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
-    type Future = MapErrFuture<A, F, E>;
+    type Future = MapErrFuture<A, F, E, R>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready().map_err(&self.f)
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: R) -> Self::Future {
-        MapErrFuture::new(self.service.call(req), self.f.clone())
+        MapErrFuture {
+            fut: self.service.call(req),
+            f: self.f.clone(),
+        }
     }
 }
 
-pub struct MapErrFuture<A, F, E>
+pub struct MapErrFuture<A, F, E, R>
 where
-    A: Service,
+    A: Service<R>,
     F: Fn(A::Error) -> E,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, E> MapErrFuture<A, F, E>
+impl<A, F, E, R> Future for MapErrFuture<A, F, E, R>
 where
-    A: Service,
+    A: Service<R>,
-    F: Fn(A::Error) -> E,
-{
-    fn new(fut: A::Future, f: F) -> Self {
-        MapErrFuture { f, fut }
-    }
-}
-
-impl<A, F, E> Future for MapErrFuture<A, F, E>
-where
-    A: Service,
     F: Fn(A::Error) -> E,
 {
     type Item = A::Response;
@@ -98,17 +90,17 @@ where
 /// service's error.
 ///
 /// This is created by the `NewServiceExt::map_err` method.
-pub struct MapErrNewService<A, F, E> {
+pub struct MapErrNewService<A, F, E, C> {
     a: A,
     f: F,
-    e: PhantomData<E>,
+    e: PhantomData<(E, C)>,
 }
 
-impl<A, F, E> MapErrNewService<A, F, E> {
+impl<A, F, E, C> MapErrNewService<A, F, E, C> {
     /// Create new `MapErr` new service instance
-    pub fn new(a: A, f: F) -> Self
+    pub fn new<R>(a: A, f: F) -> Self
     where
-        A: NewService,
+        A: NewService<R, C>,
         F: Fn(A::Error) -> E,
     {
         Self {
@@ -119,7 +111,7 @@ impl<A, F, E> MapErrNewService<A, F, E> {
     }
 }
 
-impl<A, F, E> Clone for MapErrNewService<A, F, E>
+impl<A, F, E, C> Clone for MapErrNewService<A, F, E, C>
 where
     A: Clone,
     F: Clone,
@@ -133,36 +125,35 @@ where
     }
 }
 
-impl<A, F, E> NewService for MapErrNewService<A, F, E>
+impl<A, F, E, R, C> NewService<R, C> for MapErrNewService<A, F, E, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
     type Service = MapErr<A::Service, F, E>;
 
     type InitError = A::InitError;
-    type Future = MapErrNewServiceFuture<A, F, E>;
+    type Future = MapErrNewServiceFuture<A, F, E, R, C>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &C) -> Self::Future {
-        MapErrNewServiceFuture::new(self.a.new_service(), self.f.clone())
+        MapErrNewServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-pub struct MapErrNewServiceFuture<A, F, E>
+pub struct MapErrNewServiceFuture<A, F, E, R, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
     F: Fn(A::Error) -> E,
 {
     fut: A::Future,
     f: F,
 }
 
-impl<A, F, E> MapErrNewServiceFuture<A, F, E>
+impl<A, F, E, R, C> MapErrNewServiceFuture<A, F, E, R, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -170,9 +161,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapErrNewServiceFuture<A, F, E>
+impl<A, F, E, R, C> Future for MapErrNewServiceFuture<A, F, E, R, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
     F: Fn(A::Error) -> E + Clone,
 {
     type Item = MapErr<A::Service, F, E>;
@@ -196,8 +187,7 @@ mod tests {
 
     struct Srv;
 
-    impl Service for Srv {
+    impl Service<()> for Srv {
-        type Request = ();
         type Response = ();
         type Error = ();
         type Future = FutureResult<(), ()>;
@@ -231,7 +221,7 @@ mod tests {
     fn test_new_service() {
         let blank = || Ok::<_, ()>(Srv);
         let new_srv = blank.into_new_service().map_err(|_| "error");
-        if let Async::Ready(mut srv) = new_srv.new_service().poll().unwrap() {
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
             let res = srv.call(()).poll();
             assert!(res.is_err());
             assert_eq!(res.err().unwrap(), "error");

actix-service/src/map_init_err.rs

@@ -5,17 +5,17 @@ use futures::{Future, Poll};
 use super::NewService;
 
 /// `MapInitErr` service combinator
-pub struct MapInitErr<A, F, E> {
+pub struct MapInitErr<A, F, E, C> {
     a: A,
     f: F,
-    e: PhantomData<E>,
+    e: PhantomData<(E, C)>,
 }
 
-impl<A, F, E> MapInitErr<A, F, E> {
+impl<A, F, E, C> MapInitErr<A, F, E, C> {
     /// Create new `MapInitErr` combinator
-    pub fn new(a: A, f: F) -> Self
+    pub fn new<R>(a: A, f: F) -> Self
     where
-        A: NewService,
+        A: NewService<R, C>,
         F: Fn(A::InitError) -> E,
     {
         Self {
@@ -26,7 +26,7 @@ impl<A, F, E> MapInitErr<A, F, E> {
     }
 }
 
-impl<A, F, E> Clone for MapInitErr<A, F, E>
+impl<A, F, E, C> Clone for MapInitErr<A, F, E, C>
 where
     A: Clone,
     F: Clone,
@@ -40,46 +40,38 @@ where
     }
 }
 
-impl<A, F, E> NewService for MapInitErr<A, F, E>
+impl<A, F, E, R, C> NewService<R, C> for MapInitErr<A, F, E, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
     F: Fn(A::InitError) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = A::Error;
     type Service = A::Service;
 
     type InitError = E;
-    type Future = MapInitErrFuture<A, F, E>;
+    type Future = MapInitErrFuture<A, F, E, R, C>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &C) -> Self::Future {
-        MapInitErrFuture::new(self.a.new_service(), self.f.clone())
+        MapInitErrFuture {
+            fut: self.a.new_service(cfg),
+            f: self.f.clone(),
+        }
     }
 }
 
-pub struct MapInitErrFuture<A, F, E>
+pub struct MapInitErrFuture<A, F, E, R, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
     F: Fn(A::InitError) -> E,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, E> MapInitErrFuture<A, F, E>
+impl<A, F, E, R, C> Future for MapInitErrFuture<A, F, E, R, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
-    F: Fn(A::InitError) -> E,
-{
-    fn new(fut: A::Future, f: F) -> Self {
-        MapInitErrFuture { f, fut }
-    }
-}
-
-impl<A, F, E> Future for MapInitErrFuture<A, F, E>
-where
-    A: NewService,
     F: Fn(A::InitError) -> E,
 {
     type Item = A::Service;

actix-service/src/then.rs

@@ -1,6 +1,8 @@
+use std::marker::PhantomData;
+
 use futures::{try_ready, Async, Future, Poll};
 
-use super::{IntoNewService, NewService, Service};
+use super::{NewService, Service};
 use crate::cell::Cell;
 
 /// Service for the `then` combinator, chaining a computation onto the end of
@@ -14,10 +16,10 @@ pub struct Then<A, B> {
 
 impl<A, B> Then<A, B> {
     /// Create new `Then` combinator
-    pub fn new(a: A, b: B) -> Then<A, B>
+    pub fn new<R>(a: A, b: B) -> Then<A, B>
     where
-        A: Service,
+        A: Service<R>,
-        B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
+        B: Service<Result<A::Response, A::Error>, Error = A::Error>,
     {
         Then { a, b: Cell::new(b) }
     }
@@ -35,40 +37,39 @@ where
     }
 }
 
-impl<A, B> Service for Then<A, B>
+impl<A, B, R> Service<R> for Then<A, B>
 where
-    A: Service,
+    A: Service<R>,
-    B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
+    B: Service<Result<A::Response, A::Error>, Error = A::Error>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = B::Error;
-    type Future = ThenFuture<A, B>;
+    type Future = ThenFuture<A, B, R>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         try_ready!(self.a.poll_ready());
         self.b.get_mut().poll_ready()
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: R) -> Self::Future {
         ThenFuture::new(self.a.call(req), self.b.clone())
     }
 }
 
-pub struct ThenFuture<A, B>
+pub struct ThenFuture<A, B, R>
 where
-    A: Service,
+    A: Service<R>,
-    B: Service<Request = Result<A::Response, A::Error>>,
+    B: Service<Result<A::Response, A::Error>>,
 {
     b: Cell<B>,
     fut_b: Option<B::Future>,
     fut_a: Option<A::Future>,
 }
 
-impl<A, B> ThenFuture<A, B>
+impl<A, B, R> ThenFuture<A, B, R>
 where
-    A: Service,
+    A: Service<R>,
-    B: Service<Request = Result<A::Response, A::Error>>,
+    B: Service<Result<A::Response, A::Error>>,
 {
     fn new(a: A::Future, b: Cell<B>) -> Self {
         ThenFuture {
@@ -79,10 +80,10 @@ where
     }
 }
 
-impl<A, B> Future for ThenFuture<A, B>
+impl<A, B, R> Future for ThenFuture<A, B, R>
 where
-    A: Service,
+    A: Service<R>,
-    B: Service<Request = Result<A::Response, A::Error>>,
+    B: Service<Result<A::Response, A::Error>>,
 {
     type Item = B::Response;
     type Error = B::Error;
@@ -109,53 +110,50 @@ where
 }
 
 /// `ThenNewService` new service combinator
-pub struct ThenNewService<A, B> {
+pub struct ThenNewService<A, B, C> {
     a: A,
     b: B,
+    _t: PhantomData<C>,
 }
 
-impl<A, B> ThenNewService<A, B> {
+impl<A, B, C> ThenNewService<A, B, C> {
     /// Create new `AndThen` combinator
-    pub fn new<F>(a: A, f: F) -> Self
+    pub fn new<R>(a: A, f: B) -> Self
     where
-        A: NewService,
+        A: NewService<R, C>,
         B: NewService<
-            Request = Result<A::Response, A::Error>,
+            Result<A::Response, A::Error>,
+            C,
             Error = A::Error,
             InitError = A::InitError,
         >,
-        F: IntoNewService<B>,
     {
         Self {
             a,
-            b: f.into_new_service(),
+            b: f,
+            _t: PhantomData,
         }
     }
 }
 
-impl<A, B> NewService for ThenNewService<A, B>
+impl<A, B, R, C> NewService<R, C> for ThenNewService<A, B, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
-    B: NewService<
+    B: NewService<Result<A::Response, A::Error>, C, Error = A::Error, InitError = A::InitError>,
-        Request = Result<A::Response, A::Error>,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
     type Service = Then<A::Service, B::Service>;
 
     type InitError = A::InitError;
-    type Future = ThenNewServiceFuture<A, B>;
+    type Future = ThenNewServiceFuture<A, B, R, C>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &C) -> Self::Future {
-        ThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
+        ThenNewServiceFuture::new(self.a.new_service(cfg), self.b.new_service(cfg))
     }
 }
 
-impl<A, B> Clone for ThenNewService<A, B>
+impl<A, B, C> Clone for ThenNewService<A, B, C>
 where
     A: Clone,
     B: Clone,
@@ -164,18 +162,15 @@ where
         Self {
             a: self.a.clone(),
             b: self.b.clone(),
+            _t: PhantomData,
         }
     }
 }
 
-pub struct ThenNewServiceFuture<A, B>
+pub struct ThenNewServiceFuture<A, B, R, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
-    B: NewService<
+    B: NewService<Result<A::Response, A::Error>, C, Error = A::Error, InitError = A::InitError>,
-        Request = Result<A::Response, A::Error>,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
 {
     fut_b: B::Future,
     fut_a: A::Future,
@@ -183,14 +178,10 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B> ThenNewServiceFuture<A, B>
+impl<A, B, R, C> ThenNewServiceFuture<A, B, R, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
-    B: NewService<
+    B: NewService<Result<A::Response, A::Error>, C, Error = A::Error, InitError = A::InitError>,
-        Request = Result<A::Response, A::Error>,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
         ThenNewServiceFuture {
@@ -202,14 +193,10 @@ where
     }
 }
 
-impl<A, B> Future for ThenNewServiceFuture<A, B>
+impl<A, B, R, C> Future for ThenNewServiceFuture<A, B, R, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
-    B: NewService<
+    B: NewService<Result<A::Response, A::Error>, C, Error = A::Error, InitError = A::InitError>,
-        Request = Result<A::Response, A::Error>,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
 {
     type Item = Then<A::Service, B::Service>;
     type Error = A::InitError;
@@ -249,8 +236,7 @@ mod tests {
 
     #[derive(Clone)]
     struct Srv1(Rc<Cell<usize>>);
-    impl Service for Srv1 {
+    impl Service<Result<&'static str, &'static str>> for Srv1 {
-        type Request = Result<&'static str, &'static str>;
         type Response = &'static str;
         type Error = ();
         type Future = FutureResult<Self::Response, Self::Error>;
@@ -270,8 +256,7 @@ mod tests {
 
     struct Srv2(Rc<Cell<usize>>);
 
-    impl Service for Srv2 {
+    impl Service<Result<&'static str, ()>> for Srv2 {
-        type Request = Result<&'static str, ()>;
         type Response = (&'static str, &'static str);
         type Error = ();
         type Future = FutureResult<Self::Response, ()>;
@@ -319,7 +304,7 @@ mod tests {
         let cnt2 = cnt.clone();
         let blank = move || Ok::<_, ()>(Srv1(cnt2.clone()));
         let new_srv = blank.into_new_service().then(move || Ok(Srv2(cnt.clone())));
-        if let Async::Ready(mut srv) = new_srv.clone().new_service().poll().unwrap() {
+        if let Async::Ready(mut srv) = new_srv.clone().new_service(&()).poll().unwrap() {
             let res = srv.call(Ok("srv1")).poll();
             assert!(res.is_ok());
             assert_eq!(res.unwrap(), Async::Ready(("srv1", "ok")));

actix-service/src/transform.rs

@@ -0,0 +1,167 @@
+use std::rc::Rc;
+use std::sync::Arc;
+
+use futures::{Async, Future, IntoFuture, Poll};
+
+use crate::transform_map_init_err::TransformMapInitErr;
+use crate::{NewService, Service};
+
+/// `Transform` service factory.
+///
+/// Transform factory creates service that wraps other services.
+///
+/// * `S` is a wrapped service.
+/// * `R` requests handled by this transform service.
+pub trait Transform<S, R> {
+    /// Responses given by the service.
+    type Response;
+
+    /// Errors produced by the service.
+    type Error;
+
+    /// The `TransformService` value created by this factory
+    type Transform: Service<R, Response = Self::Response, Error = Self::Error>;
+
+    /// Errors produced while building a service.
+    type InitError;
+
+    /// The future response value.
+    type Future: Future<Item = Self::Transform, Error = Self::InitError>;
+
+    /// Create and return a new service value asynchronously.
+    fn new_transform(&self, service: S) -> Self::Future;
+
+    /// Map this service's factory init error to a different error,
+    /// returning a new transform service factory.
+    fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::InitError) -> E,
+    {
+        TransformMapInitErr::new(self, f)
+    }
+}
+
+impl<T, S, R> Transform<S, R> for Rc<T>
+where
+    T: Transform<S, R>,
+{
+    type Response = T::Response;
+    type Error = T::Error;
+    type InitError = T::InitError;
+    type Transform = T::Transform;
+    type Future = T::Future;
+
+    fn new_transform(&self, service: S) -> T::Future {
+        self.as_ref().new_transform(service)
+    }
+}
+
+impl<T, S, R> Transform<S, R> for Arc<T>
+where
+    T: Transform<S, R>,
+{
+    type Response = T::Response;
+    type Error = T::Error;
+    type InitError = T::InitError;
+    type Transform = T::Transform;
+    type Future = T::Future;
+
+    fn new_transform(&self, service: S) -> T::Future {
+        self.as_ref().new_transform(service)
+    }
+}
+
+/// Trait for types that can be converted to a *transform service*
+pub trait IntoTransform<T, S, R>
+where
+    T: Transform<S, R>,
+{
+    /// Convert to a `TransformService`
+    fn into_transform(self) -> T;
+}
+
+impl<T, S, R> IntoTransform<T, S, R> for T
+where
+    T: Transform<S, R>,
+{
+    fn into_transform(self) -> T {
+        self
+    }
+}
+
+/// `Apply` transform new service
+#[derive(Clone)]
+pub struct ApplyTransform<T, S, R, Req, Cfg> {
+    a: S,
+    t: Rc<T>,
+    _t: std::marker::PhantomData<(R, Req, Cfg)>,
+}
+
+impl<T, S, R, Req, Cfg> ApplyTransform<T, S, R, Req, Cfg>
+where
+    S: NewService<Req, Cfg>,
+    T: Transform<S::Service, R, Error = S::Error, InitError = S::InitError>,
+{
+    /// Create new `ApplyNewService` new service instance
+    pub fn new<F: IntoTransform<T, S::Service, R>>(t: F, a: S) -> Self {
+        Self {
+            a,
+            t: Rc::new(t.into_transform()),
+            _t: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<T, S, R, Req, Cfg> NewService<R, Cfg> for ApplyTransform<T, S, R, Req, Cfg>
+where
+    S: NewService<Req, Cfg>,
+    T: Transform<S::Service, R, Error = S::Error, InitError = S::InitError>,
+{
+    type Response = T::Response;
+    type Error = T::Error;
+
+    type Service = T::Transform;
+    type InitError = T::InitError;
+    type Future = ApplyTransformFuture<T, S, R, Req, Cfg>;
+
+    fn new_service(&self, cfg: &Cfg) -> Self::Future {
+        ApplyTransformFuture {
+            t_cell: self.t.clone(),
+            fut_a: self.a.new_service(cfg).into_future(),
+            fut_t: None,
+        }
+    }
+}
+
+pub struct ApplyTransformFuture<T, S, R, Req, Cfg>
+where
+    S: NewService<Req, Cfg>,
+    T: Transform<S::Service, R, Error = S::Error, InitError = S::InitError>,
+{
+    fut_a: S::Future,
+    fut_t: Option<T::Future>,
+    t_cell: Rc<T>,
+}
+
+impl<T, S, R, Req, Cfg> Future for ApplyTransformFuture<T, S, R, Req, Cfg>
+where
+    S: NewService<Req, Cfg>,
+    T: Transform<S::Service, R, Error = S::Error, InitError = S::InitError>,
+{
+    type Item = T::Transform;
+    type Error = T::InitError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if self.fut_t.is_none() {
+            if let Async::Ready(service) = self.fut_a.poll()? {
+                self.fut_t = Some(self.t_cell.new_transform(service).into_future());
+            }
+        }
+        if let Some(ref mut fut) = self.fut_t {
+            fut.poll()
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+}

actix-service/src/transform_map_init_err.rs

@@ -0,0 +1,93 @@
+use std::marker::PhantomData;
+
+use futures::{Future, Poll};
+
+use super::Transform;
+
+/// NewTransform for the `map_init_err` combinator, changing the type of a new
+/// transform's error.
+///
+/// This is created by the `NewTransform::map_init_err` method.
+pub struct TransformMapInitErr<T, S, F, E> {
+    t: T,
+    f: F,
+    e: PhantomData<(S, E)>,
+}
+
+impl<T, S, F, E> TransformMapInitErr<T, S, F, E> {
+    /// Create new `MapInitErr` new transform instance
+    pub fn new<R>(t: T, f: F) -> Self
+    where
+        T: Transform<S, R>,
+        F: Fn(T::InitError) -> E,
+    {
+        Self {
+            t,
+            f,
+            e: PhantomData,
+        }
+    }
+}
+
+impl<T, S, F, E> Clone for TransformMapInitErr<T, S, F, E>
+where
+    T: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            t: self.t.clone(),
+            f: self.f.clone(),
+            e: PhantomData,
+        }
+    }
+}
+
+impl<T, R, S, F, E> Transform<S, R> for TransformMapInitErr<T, S, F, E>
+where
+    T: Transform<S, R>,
+    F: Fn(T::InitError) -> E + Clone,
+{
+    type Response = T::Response;
+    type Error = T::Error;
+    type Transform = T::Transform;
+
+    type InitError = E;
+    type Future = TransformMapInitErrFuture<T, R, S, F, E>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        TransformMapInitErrFuture::new(self.t.new_transform(service), self.f.clone())
+    }
+}
+
+pub struct TransformMapInitErrFuture<T, R, S, F, E>
+where
+    T: Transform<S, R>,
+    F: Fn(T::InitError) -> E,
+{
+    fut: T::Future,
+    f: F,
+}
+
+impl<T, R, S, F, E> TransformMapInitErrFuture<T, R, S, F, E>
+where
+    T: Transform<S, R>,
+    F: Fn(T::InitError) -> E,
+{
+    fn new(fut: T::Future, f: F) -> Self {
+        TransformMapInitErrFuture { f, fut }
+    }
+}
+
+impl<T, R, S, F, E> Future for TransformMapInitErrFuture<T, R, S, F, E>
+where
+    T: Transform<S, R>,
+    F: Fn(T::InitError) -> E + Clone,
+{
+    type Item = T::Transform;
+    type Error = E;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        self.fut.poll().map_err(&self.f)
+    }
+}

actix-test-server/Cargo.toml

@@ -34,12 +34,10 @@ rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
 
 [dependencies]
 actix-rt = "0.1.0"
-#actix-server = "0.1.0"
+#actix-server = "0.3.0"
 actix-server = { path="../actix-server" }
 
 log = "0.4"
-
-# io
 net2 = "0.2"
 futures = "0.1"
 tokio-tcp = "0.1"

actix-utils/CHANGES.md

@@ -1,6 +1,69 @@
 # Changes
 
-## [0.1.1] - 2018-xx-xx
+## [0.4.0] - 2019-03-xx
+
+* Upgrade actix-service
+
+
+## [0.3.2] - 2019-03-04
+
+### Changed
+
+* Use IntoFuture for new services
+
+
+## [0.3.1] - 2019-03-04
+
+### Changed
+
+* Use new type of transform trait
+
+
+## [0.3.0] - 2019-03-02
+
+### Changed
+
+* Use new `NewService` trait
+
+* BoxedNewService` and `BoxedService` types moved to actix-service crate.
+
+
+## [0.2.4] - 2019-02-21
+
+### Changed
+
+* Custom `BoxedNewService` implementation.
+
+
+## [0.2.3] - 2019-02-21
+
+### Added
+
+* Add `BoxedNewService` and `BoxedService`
+
+
+## [0.2.2] - 2019-02-11
+
+### Added
+
+* Add `Display` impl for `TimeoutError`
+
+* Add `Display` impl for `InOrderError`
+
+
+## [0.2.1] - 2019-02-06
+
+### Added
+
+* Add `InOrder` service. the service yields responses as they become available,
+  in the order that their originating requests were submitted to the service.
+
+### Changed
+
+* Convert `Timeout` and `InFlight` services to a transforms
+
+
+## [0.2.0] - 2019-02-01
 
 * Fix framed transport error handling
 
@@ -10,6 +73,8 @@
 
 * Added Service and NewService for Stream dispatcher
 
+* Switch to actix-service 0.2
+
 
 ## [0.1.0] - 2018-12-09
 

actix-utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-utils"
-version = "0.2.0"
+version = "0.3.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix utils - various actix net related services"
 keywords = ["network", "framework", "async", "futures"]
@@ -11,21 +11,21 @@ categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
-workspace = "../"
+workspace = ".."
 
 [lib]
 name = "actix_utils"
 path = "src/lib.rs"
 
 [dependencies]
-#actix-service = "0.1.6"
+#actix-service = "0.3.2"
 actix-service = { path="../actix-service" }
 actix-codec = "0.1.0"
 bytes = "0.4"
-futures = "0.1"
+futures = "0.1.24"
 tokio-timer = "0.2.8"
-tokio-current-thread = "0.1"
+tokio-current-thread = "0.1.4"
 log = "0.4"
 
 [dev-dependencies]
-actix-rt = "0.1"
+actix-rt = "0.1"

actix-utils/src/cloneable.rs

@@ -13,9 +13,9 @@ pub struct CloneableService<T: 'static> {
 }
 
 impl<T: 'static> CloneableService<T> {
-    pub fn new(service: T) -> Self
+    pub fn new<R>(service: T) -> Self
     where
-        T: Service,
+        T: Service<R>,
     {
         Self {
             service: Cell::new(service),
@@ -33,11 +33,10 @@ impl<T: 'static> Clone for CloneableService<T> {
     }
 }
 
-impl<T> Service for CloneableService<T>
+impl<T, R> Service<R> for CloneableService<T>
 where
-    T: Service + 'static,
+    T: Service<R> + 'static,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
     type Future = T::Future;
@@ -46,7 +45,7 @@ where
         self.service.get_mut().poll_ready()
     }
 
-    fn call(&mut self, req: T::Request) -> Self::Future {
+    fn call(&mut self, req: R) -> Self::Future {
         self.service.get_mut().call(req)
     }
 }

actix-utils/src/either.rs

@@ -1,6 +1,6 @@
 //! Contains `Either` service and related types and functions.
 use actix_service::{NewService, Service};
-use futures::{future, try_ready, Async, Future, Poll};
+use futures::{future, try_ready, Async, Future, IntoFuture, Poll};
 
 /// Combine two different service types into a single type.
 ///
@@ -21,12 +21,11 @@ impl<A: Clone, B: Clone> Clone for EitherService<A, B> {
     }
 }
 
-impl<A, B> Service for EitherService<A, B>
+impl<A, B, R> Service<R> for EitherService<A, B>
 where
-    A: Service,
+    A: Service<R>,
-    B: Service<Request = A::Request, Response = A::Response, Error = A::Error>,
+    B: Service<R, Response = A::Response, Error = A::Error>,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = A::Error;
     type Future = future::Either<A::Future, B::Future>;
@@ -38,7 +37,7 @@ where
         }
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: R) -> Self::Future {
         match self {
             EitherService::A(ref mut inner) => future::Either::A(inner.call(req)),
             EitherService::B(ref mut inner) => future::Either::B(inner.call(req)),
@@ -53,54 +52,38 @@ pub enum Either<A, B> {
 }
 
 impl<A, B> Either<A, B> {
-    pub fn new_a(srv: A) -> Self
+    pub fn new_a<R, C>(srv: A) -> Self
     where
-        A: NewService,
+        A: NewService<R, C>,
-        B: NewService<
+        B: NewService<R, C, Response = A::Response, Error = A::Error, InitError = A::InitError>,
-            Request = A::Request,
-            Response = A::Response,
-            Error = A::Error,
-            InitError = A::InitError,
-        >,
     {
         Either::A(srv)
     }
 
-    pub fn new_b(srv: B) -> Self
+    pub fn new_b<R, C>(srv: B) -> Self
     where
-        A: NewService,
+        A: NewService<R, C>,
-        B: NewService<
+        B: NewService<R, C, Response = A::Response, Error = A::Error, InitError = A::InitError>,
-            Request = A::Request,
-            Response = A::Response,
-            Error = A::Error,
-            InitError = A::InitError,
-        >,
     {
         Either::B(srv)
     }
 }
 
-impl<A, B> NewService for Either<A, B>
+impl<A, B, R, C> NewService<R, C> for Either<A, B>
 where
-    A: NewService,
+    A: NewService<R, C>,
-    B: NewService<
+    B: NewService<R, C, Response = A::Response, Error = A::Error, InitError = A::InitError>,
-        Request = A::Request,
-        Response = A::Response,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = A::Error;
     type InitError = A::InitError;
     type Service = EitherService<A::Service, B::Service>;
-    type Future = EitherNewService<A, B>;
+    type Future = EitherNewService<A, B, R, C>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &C) -> Self::Future {
         match self {
-            Either::A(ref inner) => EitherNewService::A(inner.new_service()),
+            Either::A(ref inner) => EitherNewService::A(inner.new_service(cfg)),
-            Either::B(ref inner) => EitherNewService::B(inner.new_service()),
+            Either::B(ref inner) => EitherNewService::B(inner.new_service(cfg)),
         }
     }
 }
@@ -115,20 +98,15 @@ impl<A: Clone, B: Clone> Clone for Either<A, B> {
 }
 
 #[doc(hidden)]
-pub enum EitherNewService<A: NewService, B: NewService> {
+pub enum EitherNewService<A: NewService<R, C>, B: NewService<R, C>, R, C> {
-    A(A::Future),
+    A(<A::Future as IntoFuture>::Future),
-    B(B::Future),
+    B(<B::Future as IntoFuture>::Future),
 }
 
-impl<A, B> Future for EitherNewService<A, B>
+impl<A, B, R, C> Future for EitherNewService<A, B, R, C>
 where
-    A: NewService,
+    A: NewService<R, C>,
-    B: NewService<
+    B: NewService<R, C, Response = A::Response, Error = A::Error, InitError = A::InitError>,
-        Request = A::Request,
-        Response = A::Response,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
 {
     type Item = EitherService<A::Service, B::Service>;
     type Error = A::InitError;

actix-utils/src/framed.rs

@@ -7,7 +7,7 @@ use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use actix_service::{IntoNewService, IntoService, NewService, Service};
 use futures::future::{ok, FutureResult};
 use futures::task::AtomicTask;
-use futures::{Async, Future, Poll, Sink, Stream};
+use futures::{Async, Future, IntoFuture, Poll, Sink, Stream};
 use log::debug;
 
 use crate::cell::Cell;
@@ -15,22 +15,23 @@ use crate::cell::Cell;
 type Request<U> = <U as Decoder>::Item;
 type Response<U> = <U as Encoder>::Item;
 
-pub struct FramedNewService<S, T, U> {
+pub struct FramedNewService<S, T, U, C> {
     factory: S,
-    _t: PhantomData<(T, U)>,
+    _t: PhantomData<(T, U, C)>,
 }
 
-impl<S, T, U> FramedNewService<S, T, U>
+impl<S, T, U, C> FramedNewService<S, T, U, C>
 where
-    S: NewService<Request = Request<U>, Response = Response<U>>,
+    C: Clone,
+    S: NewService<Request<U>, C, Response = Response<U>>,
     S::Error: 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request<U>>>::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: std::fmt::Debug,
 {
-    pub fn new<F1: IntoNewService<S>>(factory: F1) -> Self {
+    pub fn new<F1: IntoNewService<S, Request<U>, C>>(factory: F1) -> Self {
         Self {
             factory: factory.into_new_service(),
             _t: PhantomData,
@@ -38,7 +39,7 @@ where
     }
 }
 
-impl<S, T, U> Clone for FramedNewService<S, T, U>
+impl<S, T, U, C> Clone for FramedNewService<S, T, U, C>
 where
     S: Clone,
 {
@@ -50,62 +51,66 @@ where
     }
 }
 
-impl<S, T, U> NewService for FramedNewService<S, T, U>
+impl<S, T, U, C> NewService<Framed<T, U>, C> for FramedNewService<S, T, U, C>
 where
-    S: NewService<Request = Request<U>, Response = Response<U>> + Clone,
+    C: Clone,
+    S: NewService<Request<U>, C, Response = Response<U>> + Clone,
     S::Error: 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request<U>>>::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: std::fmt::Debug,
 {
-    type Request = Framed<T, U>;
     type Response = FramedTransport<S::Service, T, U>;
     type Error = S::InitError;
     type InitError = S::InitError;
-    type Service = FramedService<S, T, U>;
+    type Service = FramedService<S, T, U, C>;
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &C) -> Self::Future {
         ok(FramedService {
             factory: self.factory.clone(),
+            config: cfg.clone(),
             _t: PhantomData,
         })
     }
 }
 
-pub struct FramedService<S, T, U> {
+pub struct FramedService<S, T, U, C> {
     factory: S,
+    config: C,
     _t: PhantomData<(T, U)>,
 }
 
-impl<S, T, U> Clone for FramedService<S, T, U>
+impl<S, T, U, C> Clone for FramedService<S, T, U, C>
 where
     S: Clone,
+    C: Clone,
 {
     fn clone(&self) -> Self {
         Self {
             factory: self.factory.clone(),
+            config: self.config.clone(),
             _t: PhantomData,
         }
     }
 }
 
-impl<S, T, U> Service for FramedService<S, T, U>
+impl<S, T, U, C> Service<Framed<T, U>> for FramedService<S, T, U, C>
 where
-    S: NewService<Request = Request<U>, Response = Response<U>>,
+    S: NewService<Request<U>, C, Response = Response<U>>,
     S::Error: 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request<U>>>::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: std::fmt::Debug,
+    C: Clone,
 {
-    type Request = Framed<T, U>;
     type Response = FramedTransport<S::Service, T, U>;
     type Error = S::InitError;
-    type Future = FramedServiceResponseFuture<S, T, U>;
+    type Future = FramedServiceResponseFuture<S, T, U, C>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         Ok(Async::Ready(()))
@@ -113,33 +118,32 @@ where
 
     fn call(&mut self, req: Framed<T, U>) -> Self::Future {
         FramedServiceResponseFuture {
-            fut: self.factory.new_service(),
+            fut: self.factory.new_service(&self.config),
-
             framed: Some(req),
         }
     }
 }
 
 #[doc(hidden)]
-pub struct FramedServiceResponseFuture<S, T, U>
+pub struct FramedServiceResponseFuture<S, T, U, C>
 where
-    S: NewService<Request = Request<U>, Response = Response<U>>,
+    S: NewService<Request<U>, C, Response = Response<U>>,
     S::Error: 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request<U>>>::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: std::fmt::Debug,
 {
-    fut: S::Future,
+    fut: <S::Future as IntoFuture>::Future,
     framed: Option<Framed<T, U>>,
 }
 
-impl<S, T, U> Future for FramedServiceResponseFuture<S, T, U>
+impl<S, T, U, C> Future for FramedServiceResponseFuture<S, T, U, C>
 where
-    S: NewService<Request = Request<U>, Response = Response<U>>,
+    S: NewService<Request<U>, C, Response = Response<U>>,
     S::Error: 'static,
-    <S::Service as Service>::Future: 'static,
+    <S::Service as Service<Request<U>>>::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
     <U as Encoder>::Item: 'static,
@@ -176,7 +180,7 @@ impl<E, U: Encoder + Decoder> From<E> for FramedTransportError<E, U> {
 /// and pass then to the service.
 pub struct FramedTransport<S, T, U>
 where
-    S: Service<Request = Request<U>, Response = Response<U>>,
+    S: Service<Request<U>, Response = Response<U>>,
     S::Error: 'static,
     S::Future: 'static,
     T: AsyncRead + AsyncWrite,
@@ -190,7 +194,7 @@ where
     inner: Cell<FramedTransportInner<<U as Encoder>::Item, S::Error>>,
 }
 
-enum TransportState<S: Service, U: Encoder + Decoder> {
+enum TransportState<S: Service<Request<U>>, U: Encoder + Decoder> {
     Processing,
     Error(FramedTransportError<S::Error, U>),
     FramedError(FramedTransportError<S::Error, U>),
@@ -204,7 +208,7 @@ struct FramedTransportInner<I, E> {
 
 impl<S, T, U> FramedTransport<S, T, U>
 where
-    S: Service<Request = Request<U>, Response = Response<U>>,
+    S: Service<Request<U>, Response = Response<U>>,
     S::Error: 'static,
     S::Future: 'static,
     T: AsyncRead + AsyncWrite,
@@ -296,7 +300,7 @@ where
 
 impl<S, T, U> FramedTransport<S, T, U>
 where
-    S: Service<Request = Request<U>, Response = Response<U>>,
+    S: Service<Request<U>, Response = Response<U>>,
     S::Error: 'static,
     S::Future: 'static,
     T: AsyncRead + AsyncWrite,
@@ -304,7 +308,7 @@ where
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: std::fmt::Debug,
 {
-    pub fn new<F: IntoService<S>>(framed: Framed<T, U>, service: F) -> Self {
+    pub fn new<F: IntoService<S, Request<U>>>(framed: Framed<T, U>, service: F) -> Self {
         FramedTransport {
             framed,
             service: service.into_service(),
@@ -342,7 +346,7 @@ where
 
 impl<S, T, U> Future for FramedTransport<S, T, U>
 where
-    S: Service<Request = Request<U>, Response = Response<U>>,
+    S: Service<Request<U>, Response = Response<U>>,
     S::Error: 'static,
     S::Future: 'static,
     T: AsyncRead + AsyncWrite,
@@ -402,20 +406,19 @@ where
     }
 }
 
-impl<T, U, F> NewService for IntoFramed<T, U, F>
+impl<T, U, F> NewService<T, ()> for IntoFramed<T, U, F>
 where
     T: AsyncRead + AsyncWrite,
     F: Fn() -> U + Send + Clone + 'static,
     U: Encoder + Decoder,
 {
-    type Request = T;
     type Response = Framed<T, U>;
     type Error = ();
     type InitError = ();
     type Service = IntoFramedService<T, U, F>;
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, _: &()) -> Self::Future {
         ok(IntoFramedService {
             factory: self.factory.clone(),
             _t: PhantomData,
@@ -433,13 +436,12 @@ where
     _t: PhantomData<(T,)>,
 }
 
-impl<T, U, F> Service for IntoFramedService<T, U, F>
+impl<T, U, F> Service<T> for IntoFramedService<T, U, F>
 where
     T: AsyncRead + AsyncWrite,
     F: Fn() -> U + Send + Clone + 'static,
     U: Encoder + Decoder,
 {
-    type Request = T;
     type Response = Framed<T, U>;
     type Error = ();
     type Future = FutureResult<Self::Response, Self::Error>;

actix-utils/src/inflight.rs

@@ -1,5 +1,6 @@
-use actix_service::{IntoNewService, IntoService, NewService, Service};
+use actix_service::{Service, Transform, Void};
-use futures::{try_ready, Async, Future, Poll};
+use futures::future::{ok, FutureResult};
+use futures::{Async, Future, Poll};
 
 use super::counter::{Counter, CounterGuard};
 
@@ -7,116 +8,68 @@ use super::counter::{Counter, CounterGuard};
 /// async requests.
 ///
 /// Default number of in-flight requests is 15
-pub struct InFlight<T> {
+pub struct InFlight {
-    factory: T,
     max_inflight: usize,
 }
 
-impl<T> InFlight<T> {
+impl InFlight {
-    pub fn new<F>(factory: F) -> Self
+    pub fn new(max: usize) -> Self {
-    where
+        Self { max_inflight: max }
-        T: NewService,
-        F: IntoNewService<T>,
-    {
-        Self {
-            factory: factory.into_new_service(),
-            max_inflight: 15,
-        }
-    }
-
-    /// Set max number of in-flight requests.
-    ///
-    /// By default max in-flight requests is 15.
-    pub fn max_inflight(mut self, max: usize) -> Self {
-        self.max_inflight = max;
-        self
     }
 }
 
-impl<T> NewService for InFlight<T>
+impl Default for InFlight {
-where
+    fn default() -> Self {
-    T: NewService,
+        Self::new(15)
-{
-    type Request = T::Request;
-    type Response = T::Response;
-    type Error = T::Error;
-    type InitError = T::InitError;
-    type Service = InFlightService<T::Service>;
-    type Future = InFlightResponseFuture<T>;
-
-    fn new_service(&self) -> Self::Future {
-        InFlightResponseFuture {
-            fut: self.factory.new_service(),
-            max_inflight: self.max_inflight,
-        }
     }
 }
 
-pub struct InFlightResponseFuture<T: NewService> {
+impl<S: Service<R>, R> Transform<S, R> for InFlight {
-    fut: T::Future,
+    type Response = S::Response;
-    max_inflight: usize,
+    type Error = S::Error;
-}
+    type InitError = Void;
+    type Transform = InFlightService<S>;
+    type Future = FutureResult<Self::Transform, Self::InitError>;
 
-impl<T: NewService> Future for InFlightResponseFuture<T> {
+    fn new_transform(&self, service: S) -> Self::Future {
-    type Item = InFlightService<T::Service>;
+        ok(InFlightService::new(self.max_inflight, service))
-    type Error = T::InitError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        Ok(Async::Ready(InFlightService::with_max_inflight(
-            self.max_inflight,
-            try_ready!(self.fut.poll()),
-        )))
     }
 }
 
-pub struct InFlightService<T> {
+pub struct InFlightService<S> {
-    service: T,
     count: Counter,
+    service: S,
 }
 
-impl<T> InFlightService<T> {
+impl<S> InFlightService<S> {
-    pub fn new<F>(service: F) -> Self
+    pub fn new(max: usize, service: S) -> Self {
-    where
-        T: Service,
-        F: IntoService<T>,
-    {
         Self {
-            service: service.into_service(),
+            service,
-            count: Counter::new(15),
-        }
-    }
-
-    pub fn with_max_inflight<F>(max: usize, service: F) -> Self
-    where
-        T: Service,
-        F: IntoService<T>,
-    {
-        Self {
-            service: service.into_service(),
             count: Counter::new(max),
         }
     }
 }
 
-impl<T> Service for InFlightService<T>
+impl<T, R> Service<R> for InFlightService<T>
 where
-    T: Service,
+    T: Service<R>,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
-    type Future = InFlightServiceResponse<T>;
+    type Future = InFlightServiceResponse<T, R>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        let res = self.service.poll_ready()?;
+        self.service.poll_ready()?;
-        if res.is_ready() && !self.count.available() {
+
+        if !self.count.available() {
             log::trace!("InFlight limit exceeded");
-            return Ok(Async::NotReady);
+            Ok(Async::NotReady)
+        } else {
+            Ok(Async::Ready(()))
         }
-        Ok(res)
     }
 
-    fn call(&mut self, req: T::Request) -> Self::Future {
+    fn call(&mut self, req: R) -> Self::Future {
         InFlightServiceResponse {
             fut: self.service.call(req),
             _guard: self.count.get(),
@@ -125,12 +78,12 @@ where
 }
 
 #[doc(hidden)]
-pub struct InFlightServiceResponse<T: Service> {
+pub struct InFlightServiceResponse<T: Service<R>, R> {
     fut: T::Future,
     _guard: CounterGuard,
 }
 
-impl<T: Service> Future for InFlightServiceResponse<T> {
+impl<T: Service<R>, R> Future for InFlightServiceResponse<T, R> {
     type Item = T::Response;
     type Error = T::Error;
 
@@ -138,3 +91,74 @@ impl<T: Service> Future for InFlightServiceResponse<T> {
         self.fut.poll()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use futures::future::lazy;
+    use futures::{Async, Poll};
+
+    use std::time::Duration;
+
+    use super::*;
+    use actix_service::blank::{Blank, BlankNewService};
+    use actix_service::{NewService, Service, ServiceExt};
+
+    struct SleepService(Duration);
+
+    impl Service<()> for SleepService {
+        type Response = ();
+        type Error = ();
+        type Future = Box<Future<Item = (), Error = ()>>;
+
+        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+            Ok(Async::Ready(()))
+        }
+
+        fn call(&mut self, _: ()) -> Self::Future {
+            Box::new(tokio_timer::sleep(self.0).map_err(|_| ()))
+        }
+    }
+
+    #[test]
+    fn test_transform() {
+        let wait_time = Duration::from_millis(50);
+        let _ = actix_rt::System::new("test").block_on(lazy(|| {
+            let mut srv =
+                Blank::new().and_then(InFlightService::new(1, SleepService(wait_time)));
+            assert_eq!(srv.poll_ready(), Ok(Async::Ready(())));
+
+            let mut res = srv.call(());
+            let _ = res.poll();
+            assert_eq!(srv.poll_ready(), Ok(Async::NotReady));
+
+            drop(res);
+            assert_eq!(srv.poll_ready(), Ok(Async::Ready(())));
+
+            Ok::<_, ()>(())
+        }));
+    }
+
+    #[test]
+    fn test_newtransform() {
+        let wait_time = Duration::from_millis(50);
+        let _ = actix_rt::System::new("test").block_on(lazy(|| {
+            let srv =
+                BlankNewService::new().apply(InFlight::new(1), || Ok(SleepService(wait_time)));
+
+            if let Async::Ready(mut srv) = srv.new_service(&()).poll().unwrap() {
+                assert_eq!(srv.poll_ready(), Ok(Async::Ready(())));
+
+                let mut res = srv.call(());
+                let _ = res.poll();
+                assert_eq!(srv.poll_ready(), Ok(Async::NotReady));
+
+                drop(res);
+                assert_eq!(srv.poll_ready(), Ok(Async::Ready(())));
+            } else {
+                panic!()
+            }
+
+            Ok::<_, ()>(())
+        }));
+    }
+}

actix-utils/src/keepalive.rs

@@ -1,13 +1,12 @@
 use std::marker::PhantomData;
 use std::time::{Duration, Instant};
 
-use actix_service::{NewService, Service};
+use actix_service::{NewService, Service, Void};
 use futures::future::{ok, FutureResult};
 use futures::{Async, Future, Poll};
 use tokio_timer::Delay;
 
 use super::time::{LowResTime, LowResTimeService};
-use super::Never;
 
 pub struct KeepAlive<R, E, F> {
     f: F,
@@ -44,18 +43,17 @@ where
     }
 }
 
-impl<R, E, F> NewService for KeepAlive<R, E, F>
+impl<R, E, F> NewService<R, ()> for KeepAlive<R, E, F>
 where
     F: Fn() -> E + Clone,
 {
-    type Request = R;
     type Response = R;
     type Error = E;
-    type InitError = Never;
+    type InitError = Void;
     type Service = KeepAliveService<R, E, F>;
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, _: &()) -> Self::Future {
         ok(KeepAliveService::new(
             self.ka,
             self.time.timer(),
@@ -90,11 +88,10 @@ where
     }
 }
 
-impl<R, E, F> Service for KeepAliveService<R, E, F>
+impl<R, E, F> Service<R> for KeepAliveService<R, E, F>
 where
     F: Fn() -> E,
 {
-    type Request = R;
     type Response = R;
     type Error = E;
     type Future = FutureResult<R, E>;
@@ -112,7 +109,7 @@ where
                 }
             }
             Ok(Async::NotReady) => Ok(Async::Ready(())),
-            Err(_) => panic!(),
+            Err(_e) => panic!(),
         }
     }
 

actix-utils/src/lib.rs

@@ -6,9 +6,7 @@ pub mod either;
 pub mod framed;
 pub mod inflight;
 pub mod keepalive;
+pub mod order;
 pub mod stream;
 pub mod time;
 pub mod timeout;
-
-#[derive(Copy, Clone, Debug)]
-pub enum Never {}

actix-utils/src/order.rs

@@ -0,0 +1,264 @@
+use std::collections::VecDeque;
+use std::fmt;
+use std::marker::PhantomData;
+use std::rc::Rc;
+
+use actix_service::{Service, Transform, Void};
+use futures::future::{ok, FutureResult};
+use futures::task::AtomicTask;
+use futures::unsync::oneshot;
+use futures::{Async, Future, Poll};
+
+struct Record<I, E> {
+    rx: oneshot::Receiver<Result<I, E>>,
+    tx: oneshot::Sender<Result<I, E>>,
+}
+
+/// Timeout error
+pub enum InOrderError<E> {
+    /// Service error
+    Service(E),
+    /// Service call dropped
+    Disconnected,
+}
+
+impl<E> From<E> for InOrderError<E> {
+    fn from(err: E) -> Self {
+        InOrderError::Service(err)
+    }
+}
+
+impl<E: fmt::Debug> fmt::Debug for InOrderError<E> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            InOrderError::Service(e) => write!(f, "InOrderError::Service({:?})", e),
+            InOrderError::Disconnected => write!(f, "InOrderError::Disconnected"),
+        }
+    }
+}
+
+impl<E: fmt::Display> fmt::Display for InOrderError<E> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            InOrderError::Service(e) => e.fmt(f),
+            InOrderError::Disconnected => write!(f, "InOrder service disconnected"),
+        }
+    }
+}
+
+/// InOrder - The service will yield responses as they become available,
+/// in the order that their originating requests were submitted to the service.
+pub struct InOrder<S> {
+    _t: PhantomData<S>,
+}
+
+impl<S> InOrder<S> {
+    pub fn new<R>() -> Self
+    where
+        S: Service<R>,
+        S::Response: 'static,
+        S::Future: 'static,
+        S::Error: 'static,
+    {
+        Self { _t: PhantomData }
+    }
+
+    pub fn service<R>(service: S) -> InOrderService<S, R>
+    where
+        S: Service<R>,
+        S::Response: 'static,
+        S::Future: 'static,
+        S::Error: 'static,
+    {
+        InOrderService::new(service)
+    }
+}
+
+impl<S, R> Transform<S, R> for InOrder<S>
+where
+    S: Service<R>,
+    S::Response: 'static,
+    S::Future: 'static,
+    S::Error: 'static,
+{
+    type Response = S::Response;
+    type Error = InOrderError<S::Error>;
+    type InitError = Void;
+    type Transform = InOrderService<S, R>;
+    type Future = FutureResult<Self::Transform, Self::InitError>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        ok(InOrderService::new(service))
+    }
+}
+
+pub struct InOrderService<S: Service<R>, R> {
+    service: S,
+    task: Rc<AtomicTask>,
+    acks: VecDeque<Record<S::Response, S::Error>>,
+}
+
+impl<S, R> InOrderService<S, R>
+where
+    S: Service<R>,
+    S::Response: 'static,
+    S::Future: 'static,
+    S::Error: 'static,
+{
+    pub fn new(service: S) -> Self {
+        Self {
+            service,
+            acks: VecDeque::new(),
+            task: Rc::new(AtomicTask::new()),
+        }
+    }
+}
+
+impl<S, R> Service<R> for InOrderService<S, R>
+where
+    S: Service<R>,
+    S::Response: 'static,
+    S::Future: 'static,
+    S::Error: 'static,
+{
+    type Response = S::Response;
+    type Error = InOrderError<S::Error>;
+    type Future = InOrderServiceResponse<S, R>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        // poll_ready could be called from different task
+        self.task.register();
+
+        // check nested service
+        self.service.poll_ready().map_err(InOrderError::Service)?;
+
+        // check acks
+        while !self.acks.is_empty() {
+            let rec = self.acks.front_mut().unwrap();
+            match rec.rx.poll() {
+                Ok(Async::Ready(res)) => {
+                    let rec = self.acks.pop_front().unwrap();
+                    let _ = rec.tx.send(res);
+                }
+                Ok(Async::NotReady) => break,
+                Err(oneshot::Canceled) => return Err(InOrderError::Disconnected),
+            }
+        }
+
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, request: R) -> Self::Future {
+        let (tx1, rx1) = oneshot::channel();
+        let (tx2, rx2) = oneshot::channel();
+        self.acks.push_back(Record { rx: rx1, tx: tx2 });
+
+        let task = self.task.clone();
+        tokio_current_thread::spawn(self.service.call(request).then(move |res| {
+            task.notify();
+            let _ = tx1.send(res);
+            Ok(())
+        }));
+
+        InOrderServiceResponse { rx: rx2 }
+    }
+}
+
+#[doc(hidden)]
+pub struct InOrderServiceResponse<S: Service<R>, R> {
+    rx: oneshot::Receiver<Result<S::Response, S::Error>>,
+}
+
+impl<S: Service<R>, R> Future for InOrderServiceResponse<S, R> {
+    type Item = S::Response;
+    type Error = InOrderError<S::Error>;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self.rx.poll() {
+            Ok(Async::NotReady) => Ok(Async::NotReady),
+            Ok(Async::Ready(Ok(res))) => Ok(Async::Ready(res)),
+            Ok(Async::Ready(Err(e))) => Err(e.into()),
+            Err(oneshot::Canceled) => Err(InOrderError::Disconnected),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use futures::future::{lazy, Future};
+    use futures::{stream::futures_unordered, sync::oneshot, Async, Poll, Stream};
+
+    use std::time::Duration;
+
+    use super::*;
+    use actix_service::blank::Blank;
+    use actix_service::{Service, ServiceExt};
+
+    struct Srv;
+
+    impl Service<oneshot::Receiver<usize>> for Srv {
+        type Response = usize;
+        type Error = ();
+        type Future = Box<Future<Item = usize, Error = ()>>;
+
+        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+            Ok(Async::Ready(()))
+        }
+
+        fn call(&mut self, req: oneshot::Receiver<usize>) -> Self::Future {
+            Box::new(req.map_err(|_| ()))
+        }
+    }
+
+    struct SrvPoll<S: Service<oneshot::Receiver<usize>>> {
+        s: S,
+    }
+
+    impl<S: Service<oneshot::Receiver<usize>>> Future for SrvPoll<S> {
+        type Item = ();
+        type Error = ();
+
+        fn poll(&mut self) -> Poll<(), ()> {
+            let _ = self.s.poll_ready();
+            Ok(Async::NotReady)
+        }
+    }
+
+    #[test]
+    fn test_inorder() {
+        let (tx1, rx1) = oneshot::channel();
+        let (tx2, rx2) = oneshot::channel();
+        let (tx3, rx3) = oneshot::channel();
+        let (tx_stop, rx_stop) = oneshot::channel();
+
+        std::thread::spawn(move || {
+            let rx1 = rx1;
+            let rx2 = rx2;
+            let rx3 = rx3;
+            let tx_stop = tx_stop;
+            let _ = actix_rt::System::new("test").block_on(lazy(move || {
+                let mut srv = Blank::new().and_then(InOrderService::new(Srv));
+
+                let res1 = srv.call(rx1);
+                let res2 = srv.call(rx2);
+                let res3 = srv.call(rx3);
+                tokio_current_thread::spawn(SrvPoll { s: srv });
+
+                futures_unordered(vec![res1, res2, res3])
+                    .collect()
+                    .and_then(move |res: Vec<_>| {
+                        assert_eq!(res, vec![1, 2, 3]);
+                        let _ = tx_stop.send(());
+                        Ok(())
+                    })
+            }));
+        });
+
+        let _ = tx3.send(3);
+        std::thread::sleep(Duration::from_millis(50));
+        let _ = tx2.send(2);
+        let _ = tx1.send(1);
+
+        let _ = rx_stop.wait();
+    }
+}

actix-utils/src/stream.rs

@@ -29,20 +29,21 @@ where
     }
 }
 
-pub struct StreamNewService<S, T, E> {
+pub struct StreamNewService<S, T, E, C> {
     factory: Rc<T>,
-    _t: PhantomData<(S, E)>,
+    _t: PhantomData<(S, E, C)>,
 }
 
-impl<S, T, E> StreamNewService<S, T, E>
+impl<S, T, E, C> StreamNewService<S, T, E, C>
 where
+    C: Clone,
     S: IntoStream,
-    T: NewService<Request = Request<S>, Response = (), Error = E, InitError = E>,
+    T: NewService<Request<S>, C, Response = (), Error = E, InitError = E>,
     T::Future: 'static,
     T::Service: 'static,
-    <T::Service as Service>::Future: 'static,
+    <T::Service as Service<Request<S>>>::Future: 'static,
 {
-    pub fn new<F: IntoNewService<T>>(factory: F) -> Self {
+    pub fn new<F: IntoNewService<T, Request<S>, C>>(factory: F) -> Self {
         Self {
             factory: Rc::new(factory.into_new_service()),
             _t: PhantomData,
@@ -50,7 +51,7 @@ where
     }
 }
 
-impl<S, T, E> Clone for StreamNewService<S, T, E> {
+impl<S, T, E, C> Clone for StreamNewService<S, T, E, C> {
     fn clone(&self) -> Self {
         Self {
             factory: self.factory.clone(),
@@ -59,43 +60,45 @@ impl<S, T, E> Clone for StreamNewService<S, T, E> {
     }
 }
 
-impl<S, T, E> NewService for StreamNewService<S, T, E>
+impl<S, T, E, C> NewService<S, C> for StreamNewService<S, T, E, C>
 where
+    C: Clone,
     S: IntoStream + 'static,
-    T: NewService<Request = Request<S>, Response = (), Error = E, InitError = E>,
+    T: NewService<Request<S>, C, Response = (), Error = E, InitError = E>,
     T::Future: 'static,
     T::Service: 'static,
-    <T::Service as Service>::Future: 'static,
+    <T::Service as Service<Request<S>>>::Future: 'static,
 {
-    type Request = S;
     type Response = ();
     type Error = E;
     type InitError = E;
-    type Service = StreamService<S, T, E>;
+    type Service = StreamService<S, T, E, C>;
     type Future = FutureResult<Self::Service, E>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &C) -> Self::Future {
         ok(StreamService {
             factory: self.factory.clone(),
+            config: cfg.clone(),
             _t: PhantomData,
         })
     }
 }
 
-pub struct StreamService<S, T, E> {
+pub struct StreamService<S, T, E, C = ()> {
     factory: Rc<T>,
+    config: C,
     _t: PhantomData<(S, E)>,
 }
 
-impl<S, T, E> Service for StreamService<S, T, E>
+impl<S, T, E, C> Service<S> for StreamService<S, T, E, C>
 where
     S: IntoStream + 'static,
-    T: NewService<Request = Request<S>, Response = (), Error = E, InitError = E>,
+    T: NewService<Request<S>, C, Response = (), Error = E, InitError = E>,
     T::Future: 'static,
     T::Service: 'static,
-    <T::Service as Service>::Future: 'static,
+    <T::Service as Service<Request<S>>>::Future: 'static,
+    C: Clone,
 {
-    type Request = S;
     type Response = ();
     type Error = E;
     type Future = Box<Future<Item = (), Error = E>>;
@@ -107,7 +110,7 @@ where
     fn call(&mut self, req: S) -> Self::Future {
         Box::new(
             self.factory
-                .new_service()
+                .new_service(&self.config)
                 .and_then(move |srv| StreamDispatcher::new(req, srv)),
         )
     }
@@ -116,7 +119,7 @@ where
 pub struct StreamDispatcher<S, T>
 where
     S: IntoStream + 'static,
-    T: Service<Request = Request<S>, Response = ()> + 'static,
+    T: Service<Request<S>, Response = ()> + 'static,
     T::Future: 'static,
 {
     stream: S,
@@ -128,13 +131,13 @@ where
 impl<S, T> StreamDispatcher<S, T>
 where
     S: Stream,
-    T: Service<Request = Request<S>, Response = ()>,
+    T: Service<Request<S>, Response = ()>,
     T::Future: 'static,
 {
     pub fn new<F1, F2>(stream: F1, service: F2) -> Self
     where
         F1: IntoStream<Stream = S, Item = S::Item, Error = S::Error>,
-        F2: IntoService<T>,
+        F2: IntoService<T, Request<S>>,
     {
         let (err_tx, err_rx) = mpsc::unbounded();
         StreamDispatcher {
@@ -149,7 +152,7 @@ where
 impl<S, T> Future for StreamDispatcher<S, T>
 where
     S: Stream,
-    T: Service<Request = Request<S>, Response = ()>,
+    T: Service<Request<S>, Response = ()>,
     T::Future: 'static,
 {
     type Item = ();
@@ -227,15 +230,14 @@ impl<T> Clone for TakeItem<T> {
     }
 }
 
-impl<T: Stream> NewService for TakeItem<T> {
+impl<T: Stream> NewService<T, ()> for TakeItem<T> {
-    type Request = T;
     type Response = (Option<T::Item>, T);
     type Error = T::Error;
     type InitError = ();
     type Service = TakeItemService<T>;
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, _: &()) -> Self::Future {
         ok(TakeItemService { _t: PhantomData })
     }
 }
@@ -251,8 +253,7 @@ impl<T> Clone for TakeItemService<T> {
     }
 }
 
-impl<T: Stream> Service for TakeItemService<T> {
+impl<T: Stream> Service<T> for TakeItemService<T> {
-    type Request = T;
     type Response = (Option<T::Item>, T);
     type Error = T::Error;
     type Future = TakeItemServiceResponse<T>;

actix-utils/src/time.rs

@@ -1,12 +1,11 @@
 use std::time::{self, Duration, Instant};
 
-use actix_service::{NewService, Service};
+use actix_service::{NewService, Service, Void};
 use futures::future::{ok, FutureResult};
 use futures::{Async, Future, Poll};
 use tokio_timer::sleep;
 
 use super::cell::Cell;
-use super::Never;
 
 #[derive(Clone, Debug)]
 pub struct LowResTime(Cell<Inner>);
@@ -42,15 +41,14 @@ impl Default for LowResTime {
     }
 }
 
-impl NewService for LowResTime {
+impl NewService<()> for LowResTime {
-    type Request = ();
     type Response = Instant;
-    type Error = Never;
+    type Error = Void;
-    type InitError = Never;
+    type InitError = Void;
     type Service = LowResTimeService;
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, _: &()) -> Self::Future {
         ok(self.timer())
     }
 }
@@ -89,10 +87,9 @@ impl LowResTimeService {
     }
 }
 
-impl Service for LowResTimeService {
+impl Service<()> for LowResTimeService {
-    type Request = ();
     type Response = Instant;
-    type Error = Never;
+    type Error = Void;
     type Future = FutureResult<Self::Response, Self::Error>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
@@ -133,7 +130,7 @@ impl SystemTimeService {
     /// Get current time. This function has to be called from
     /// future's poll method, otherwise it panics.
     pub fn now(&self) -> time::SystemTime {
-        let cur = self.0.get_ref().current.clone();
+        let cur = self.0.get_ref().current;
         if let Some(cur) = cur {
             cur
         } else {

actix-utils/src/timeout.rs

@@ -3,18 +3,19 @@
 //! If the response does not complete within the specified timeout, the response
 //! will be aborted.
 use std::fmt;
+use std::marker::PhantomData;
 use std::time::Duration;
 
-use actix_service::{NewService, Service};
+use actix_service::{Service, Transform};
-use futures::try_ready;
+use futures::future::{ok, FutureResult};
 use futures::{Async, Future, Poll};
 use tokio_timer::{clock, Delay};
 
 /// Applies a timeout to requests.
 #[derive(Debug)]
-pub struct Timeout<T> {
+pub struct Timeout<E = ()> {
-    inner: T,
     timeout: Duration,
+    _t: PhantomData<E>,
 }
 
 /// Timeout error
@@ -25,6 +26,12 @@ pub enum TimeoutError<E> {
     Timeout,
 }
 
+impl<E> From<E> for TimeoutError<E> {
+    fn from(err: E) -> Self {
+        TimeoutError::Service(err)
+    }
+}
+
 impl<E: fmt::Debug> fmt::Debug for TimeoutError<E> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
@@ -34,107 +41,91 @@ impl<E: fmt::Debug> fmt::Debug for TimeoutError<E> {
     }
 }
 
-impl<T> Timeout<T> {
+impl<E: fmt::Display> fmt::Display for TimeoutError<E> {
-    pub fn new(timeout: Duration, inner: T) -> Self
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-    where
+        match self {
-        T: NewService + Clone,
+            TimeoutError::Service(e) => e.fmt(f),
-    {
+            TimeoutError::Timeout => write!(f, "Service call timeout"),
-        Timeout { inner, timeout }
+        }
     }
 }
 
-impl<T> Clone for Timeout<T>
+impl<E: PartialEq> PartialEq for TimeoutError<E> {
-where
+    fn eq(&self, other: &TimeoutError<E>) -> bool {
-    T: Clone,
+        match self {
-{
+            TimeoutError::Service(e1) => match other {
-    fn clone(&self) -> Self {
+                TimeoutError::Service(e2) => e1 == e2,
+                TimeoutError::Timeout => false,
+            },
+            TimeoutError::Timeout => match other {
+                TimeoutError::Service(_) => false,
+                TimeoutError::Timeout => true,
+            },
+        }
+    }
+}
+
+impl<E> Timeout<E> {
+    pub fn new(timeout: Duration) -> Self {
         Timeout {
-            inner: self.inner.clone(),
+            timeout,
-            timeout: self.timeout,
+            _t: PhantomData,
         }
     }
 }
 
-impl<T> NewService for Timeout<T>
+impl<E> Clone for Timeout<E> {
-where
+    fn clone(&self) -> Self {
-    T: NewService + Clone,
+        Timeout::new(self.timeout)
-{
-    type Request = T::Request;
-    type Response = T::Response;
-    type Error = TimeoutError<T::Error>;
-    type InitError = T::InitError;
-    type Service = TimeoutService<T::Service>;
-    type Future = TimeoutFut<T>;
-
-    fn new_service(&self) -> Self::Future {
-        TimeoutFut {
-            fut: self.inner.new_service(),
-            timeout: self.timeout,
-        }
     }
 }
 
-/// `Timeout` response future
+impl<S, R, E> Transform<S, R> for Timeout<E>
-#[derive(Debug)]
-pub struct TimeoutFut<T: NewService> {
-    fut: T::Future,
-    timeout: Duration,
-}
-
-impl<T> Future for TimeoutFut<T>
 where
-    T: NewService,
+    S: Service<R>,
 {
-    type Item = TimeoutService<T::Service>;
+    type Response = S::Response;
-    type Error = T::InitError;
+    type Error = TimeoutError<S::Error>;
+    type InitError = E;
+    type Transform = TimeoutService<S>;
+    type Future = FutureResult<Self::Transform, Self::InitError>;
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+    fn new_transform(&self, service: S) -> Self::Future {
-        let service = try_ready!(self.fut.poll());
+        ok(TimeoutService {
-        Ok(Async::Ready(TimeoutService::new(self.timeout, service)))
+            service,
+            timeout: self.timeout,
+        })
     }
 }
 
 /// Applies a timeout to requests.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
-pub struct TimeoutService<T> {
+pub struct TimeoutService<S> {
-    inner: T,
+    service: S,
     timeout: Duration,
 }
 
-impl<T> TimeoutService<T> {
+impl<S> TimeoutService<S> {
-    pub fn new(timeout: Duration, inner: T) -> Self
+    pub fn new(timeout: Duration, service: S) -> Self {
-    where
+        TimeoutService { service, timeout }
-        T: Service,
-    {
-        TimeoutService { inner, timeout }
     }
 }
 
-impl<T: Clone> Clone for TimeoutService<T> {
+impl<S, R> Service<R> for TimeoutService<S>
-    fn clone(&self) -> Self {
-        TimeoutService {
-            inner: self.inner.clone(),
-            timeout: self.timeout,
-        }
-    }
-}
-
-impl<T> Service for TimeoutService<T>
 where
-    T: Service,
+    S: Service<R>,
 {
-    type Request = T::Request;
+    type Response = S::Response;
-    type Response = T::Response;
+    type Error = TimeoutError<S::Error>;
-    type Error = TimeoutError<T::Error>;
+    type Future = TimeoutServiceResponse<S, R>;
-    type Future = TimeoutServiceResponse<T>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.inner.poll_ready().map_err(TimeoutError::Service)
+        self.service.poll_ready().map_err(TimeoutError::Service)
     }
 
-    fn call(&mut self, request: T::Request) -> Self::Future {
+    fn call(&mut self, request: R) -> Self::Future {
         TimeoutServiceResponse {
-            fut: self.inner.call(request),
+            fut: self.service.call(request),
             sleep: Delay::new(clock::now() + self.timeout),
         }
     }
@@ -142,14 +133,14 @@ where
 
 /// `TimeoutService` response future
 #[derive(Debug)]
-pub struct TimeoutServiceResponse<T: Service> {
+pub struct TimeoutServiceResponse<T: Service<R>, R> {
     fut: T::Future,
     sleep: Delay,
 }
 
-impl<T> Future for TimeoutServiceResponse<T>
+impl<T, R> Future for TimeoutServiceResponse<T, R>
 where
-    T: Service,
+    T: Service<R>,
 {
     type Item = T::Response;
     type Error = TimeoutError<T::Error>;
@@ -170,3 +161,74 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use futures::future::lazy;
+    use futures::{Async, Poll};
+
+    use std::time::Duration;
+
+    use super::*;
+    use actix_service::blank::{Blank, BlankNewService};
+    use actix_service::{NewService, Service, ServiceExt};
+
+    struct SleepService(Duration);
+
+    impl Service<()> for SleepService {
+        type Response = ();
+        type Error = ();
+        type Future = Box<Future<Item = (), Error = ()>>;
+
+        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+            Ok(Async::Ready(()))
+        }
+
+        fn call(&mut self, _: ()) -> Self::Future {
+            Box::new(tokio_timer::sleep(self.0).map_err(|_| ()))
+        }
+    }
+
+    #[test]
+    fn test_success() {
+        let resolution = Duration::from_millis(100);
+        let wait_time = Duration::from_millis(50);
+
+        let res = actix_rt::System::new("test").block_on(lazy(|| {
+            let mut timeout = Blank::default()
+                .and_then(TimeoutService::new(resolution, SleepService(wait_time)));
+            timeout.call(())
+        }));
+        assert_eq!(res, Ok(()));
+    }
+
+    #[test]
+    fn test_timeout() {
+        let resolution = Duration::from_millis(100);
+        let wait_time = Duration::from_millis(150);
+
+        let res = actix_rt::System::new("test").block_on(lazy(|| {
+            let mut timeout = Blank::default()
+                .and_then(TimeoutService::new(resolution, SleepService(wait_time)));
+            timeout.call(())
+        }));
+        assert_eq!(res, Err(TimeoutError::Timeout));
+    }
+
+    #[test]
+    fn test_timeout_newservice() {
+        let resolution = Duration::from_millis(100);
+        let wait_time = Duration::from_millis(150);
+
+        let res = actix_rt::System::new("test").block_on(lazy(|| {
+            let timeout = BlankNewService::<(), (), ()>::default()
+                .apply(Timeout::new(resolution), || Ok(SleepService(wait_time)));
+            if let Async::Ready(mut to) = timeout.new_service(&()).poll().unwrap() {
+                to.call(())
+            } else {
+                panic!()
+            }
+        }));
+        assert_eq!(res, Err(TimeoutError::Timeout));
+    }
+}

router/src/de.rs

@@ -2,7 +2,7 @@ use serde::de::{self, Deserializer, Error as DeError, Visitor};
 use serde::forward_to_deserialize_any;
 
 use crate::path::{Path, PathIter};
-use crate::RequestPath;
+use crate::ResourcePath;
 
 macro_rules! unsupported_type {
     ($trait_fn:ident, $name:expr) => {
@@ -33,17 +33,17 @@ macro_rules! parse_single_value {
     }
 }
 
-pub struct PathDeserializer<'de, T: RequestPath + 'de> {
+pub struct PathDeserializer<'de, T: ResourcePath + 'de> {
     path: &'de Path<T>,
 }
 
-impl<'de, T: RequestPath + 'de> PathDeserializer<'de, T> {
+impl<'de, T: ResourcePath + 'de> PathDeserializer<'de, T> {
     pub fn new(path: &'de Path<T>) -> Self {
         PathDeserializer { path }
     }
 }
 
-impl<'de, T: RequestPath + 'de> Deserializer<'de> for PathDeserializer<'de, T> {
+impl<'de, T: ResourcePath + 'de> Deserializer<'de> for PathDeserializer<'de, T> {
     type Error = de::value::Error;
 
     fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -206,12 +206,12 @@ impl<'de, T: RequestPath + 'de> Deserializer<'de> for PathDeserializer<'de, T> {
     parse_single_value!(deserialize_char, visit_char, "char");
 }
 
-struct ParamsDeserializer<'de, T: RequestPath> {
+struct ParamsDeserializer<'de, T: ResourcePath> {
     params: PathIter<'de, T>,
     current: Option<(&'de str, &'de str)>,
 }
 
-impl<'de, T: RequestPath> de::MapAccess<'de> for ParamsDeserializer<'de, T> {
+impl<'de, T: ResourcePath> de::MapAccess<'de> for ParamsDeserializer<'de, T> {
     type Error = de::value::Error;
 
     fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
@@ -406,11 +406,11 @@ impl<'de> Deserializer<'de> for Value<'de> {
     unsupported_type!(deserialize_identifier, "identifier");
 }
 
-struct ParamsSeq<'de, T: RequestPath> {
+struct ParamsSeq<'de, T: ResourcePath> {
     params: PathIter<'de, T>,
 }
 
-impl<'de, T: RequestPath> de::SeqAccess<'de> for ParamsSeq<'de, T> {
+impl<'de, T: ResourcePath> de::SeqAccess<'de> for ParamsSeq<'de, T> {
     type Error = de::value::Error;
 
     fn next_element_seed<U>(&mut self, seed: U) -> Result<Option<U::Value>, Self::Error>

router/src/lib.rs

@@ -1,31 +1,35 @@
 //! Resource path matching library.
 mod de;
 mod path;
-mod pattern;
+mod resource;
 mod router;
 
 pub use self::de::PathDeserializer;
 pub use self::path::Path;
-pub use self::pattern::Pattern;
+pub use self::resource::ResourceDef;
 pub use self::router::{ResourceInfo, Router, RouterBuilder};
 
-pub trait RequestPath {
+pub trait Resource<T: ResourcePath> {
+    fn resource_path(&mut self) -> &mut Path<T>;
+}
+
+pub trait ResourcePath {
     fn path(&self) -> &str;
 }
 
-impl RequestPath for String {
+impl ResourcePath for String {
     fn path(&self) -> &str {
         self.as_str()
     }
 }
 
-impl<'a> RequestPath for &'a str {
+impl<'a> ResourcePath for &'a str {
     fn path(&self) -> &str {
         self
     }
 }
 
-impl<T: AsRef<[u8]>> RequestPath for string::String<T> {
+impl<T: AsRef<[u8]>> ResourcePath for string::String<T> {
     fn path(&self) -> &str {
         &*self
     }
@@ -39,10 +43,10 @@ pub use self::url::Url;
 
 #[cfg(feature = "http")]
 mod http_support {
-    use super::RequestPath;
+    use super::ResourcePath;
     use http::Uri;
 
-    impl RequestPath for Uri {
+    impl ResourcePath for Uri {
         fn path(&self) -> &str {
             self.path()
         }

router/src/path.rs

@@ -4,7 +4,7 @@ use std::rc::Rc;
 use serde::de;
 
 use crate::de::PathDeserializer;
-use crate::RequestPath;
+use crate::{Resource, ResourcePath};
 
 #[derive(Debug, Clone, Copy)]
 pub(crate) enum PathItem {
@@ -42,7 +42,7 @@ impl<T: Clone> Clone for Path<T> {
     }
 }
 
-impl<T: RequestPath> Path<T> {
+impl<T: ResourcePath> Path<T> {
     pub fn new(path: T) -> Path<T> {
         Path {
             path,
@@ -165,7 +165,7 @@ pub struct PathIter<'a, T> {
     params: &'a Path<T>,
 }
 
-impl<'a, T: RequestPath> Iterator for PathIter<'a, T> {
+impl<'a, T: ResourcePath> Iterator for PathIter<'a, T> {
     type Item = (&'a str, &'a str);
 
     #[inline]
@@ -183,7 +183,7 @@ impl<'a, T: RequestPath> Iterator for PathIter<'a, T> {
     }
 }
 
-impl<'a, T: RequestPath> Index<&'a str> for Path<T> {
+impl<'a, T: ResourcePath> Index<&'a str> for Path<T> {
     type Output = str;
 
     fn index(&self, name: &'a str) -> &str {
@@ -192,7 +192,7 @@ impl<'a, T: RequestPath> Index<&'a str> for Path<T> {
     }
 }
 
-impl<T: RequestPath> Index<usize> for Path<T> {
+impl<T: ResourcePath> Index<usize> for Path<T> {
     type Output = str;
 
     fn index(&self, idx: usize) -> &str {
@@ -202,3 +202,9 @@ impl<T: RequestPath> Index<usize> for Path<T> {
         }
     }
 }
+
+impl<T: ResourcePath> Resource<T> for Path<T> {
+    fn resource_path(&mut self) -> &mut Self {
+        self
+    }
+}

router/src/resource.rs

@@ -5,20 +5,35 @@ use std::rc::Rc;
 use regex::{escape, Regex};
 
 use crate::path::{Path, PathItem};
-use crate::RequestPath;
+use crate::ResourcePath;
 
 const MAX_DYNAMIC_SEGMENTS: usize = 16;
 
-/// Resource type describes an entry in resources table
+/// ResourceDef describes an entry in resources table
 ///
-/// Resource pattern can contain only 16 dynamic segments
+/// Resource definition can contain only 16 dynamic segments
 #[derive(Clone, Debug)]
-pub struct Pattern {
+pub struct ResourceDef {
     tp: PatternType,
+    rtp: ResourceType,
+    name: String,
     pattern: String,
     elements: Vec<PatternElement>,
 }
 
+#[derive(Debug, Copy, Clone, PartialEq)]
+/// Resource type
+pub enum ResourceType {
+    /// Normal resource
+    Normal,
+    /// Resource for application default handler
+    Default,
+    /// External resource
+    External,
+    /// Unknown resource type
+    Unset,
+}
+
 #[derive(Debug, Clone, PartialEq)]
 enum PatternElement {
     Str(String),
@@ -32,12 +47,12 @@ enum PatternType {
     Dynamic(Regex, Vec<Rc<String>>, usize),
 }
 
-impl Pattern {
+impl ResourceDef {
     /// Parse path pattern and create new `Pattern` instance.
     ///
     /// Panics if path pattern is wrong.
     pub fn new(path: &str) -> Self {
-        Pattern::with_prefix(path, false)
+        ResourceDef::with_prefix(path, false)
     }
 
     /// Parse path pattern and create new `Pattern` instance.
@@ -46,13 +61,33 @@ impl Pattern {
     ///
     /// Panics if path regex pattern is wrong.
     pub fn prefix(path: &str) -> Self {
-        Pattern::with_prefix(path, true)
+        ResourceDef::with_prefix(path, true)
+    }
+
+    /// Parse path pattern and create new `Pattern` instance.
+    /// Inserts `/` to begging of the pattern.
+    ///
+    ///
+    /// Use `prefix` type instead of `static`.
+    ///
+    /// Panics if path regex pattern is wrong.
+    pub fn root_prefix(path: &str) -> Self {
+        ResourceDef::with_prefix(&insert_slash(path), true)
+    }
+
+    /// Construct external resource def
+    ///
+    /// Panics if path pattern is malformed.
+    pub fn external(path: &str) -> Self {
+        let mut resource = ResourceDef::with_prefix(path, false);
+        resource.rtp = ResourceType::External;
+        resource
     }
 
     /// Parse path pattern and create new `Pattern` instance with custom prefix
     fn with_prefix(path: &str, for_prefix: bool) -> Self {
         let path = path.to_owned();
-        let (pattern, elements, is_dynamic, len) = Pattern::parse(&path, for_prefix);
+        let (pattern, elements, is_dynamic, len) = ResourceDef::parse(&path, for_prefix);
 
         let tp = if is_dynamic {
             let re = match Regex::new(&pattern) {
@@ -71,9 +106,11 @@ impl Pattern {
             PatternType::Static(pattern.clone())
         };
 
-        Pattern {
+        ResourceDef {
             tp,
             elements,
+            name: String::new(),
+            rtp: ResourceType::Normal,
             pattern: path.to_owned(),
         }
     }
@@ -93,7 +130,7 @@ impl Pattern {
     }
 
     /// Is the given path and parameters a match against this pattern?
-    pub fn match_path<T: RequestPath>(&self, path: &mut Path<T>) -> bool {
+    pub fn match_path<T: ResourcePath>(&self, path: &mut Path<T>) -> bool {
         match self.tp {
             PatternType::Static(ref s) => {
                 if s == path.path() {
@@ -261,20 +298,40 @@ impl Pattern {
     }
 }
 
-impl PartialEq for Pattern {
+impl Eq for ResourceDef {}
-    fn eq(&self, other: &Pattern) -> bool {
+
+impl PartialEq for ResourceDef {
+    fn eq(&self, other: &ResourceDef) -> bool {
         self.pattern == other.pattern
     }
 }
 
-impl Eq for Pattern {}
+impl Hash for ResourceDef {
-
-impl Hash for Pattern {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.pattern.hash(state);
     }
 }
 
+impl<'a> From<&'a str> for ResourceDef {
+    fn from(path: &'a str) -> ResourceDef {
+        ResourceDef::new(path)
+    }
+}
+
+impl From<String> for ResourceDef {
+    fn from(path: String) -> ResourceDef {
+        ResourceDef::new(&path)
+    }
+}
+
+pub(crate) fn insert_slash(path: &str) -> String {
+    let mut path = path.to_owned();
+    if !path.is_empty() && !path.starts_with('/') {
+        path.insert(0, '/');
+    };
+    path
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -282,29 +339,29 @@ mod tests {
 
     #[test]
     fn test_parse_static() {
-        let re = Pattern::new("/");
+        let re = ResourceDef::new("/");
         assert!(re.is_match("/"));
         assert!(!re.is_match("/a"));
 
-        let re = Pattern::new("/name");
+        let re = ResourceDef::new("/name");
         assert!(re.is_match("/name"));
         assert!(!re.is_match("/name1"));
         assert!(!re.is_match("/name/"));
         assert!(!re.is_match("/name~"));
 
-        let re = Pattern::new("/name/");
+        let re = ResourceDef::new("/name/");
         assert!(re.is_match("/name/"));
         assert!(!re.is_match("/name"));
         assert!(!re.is_match("/name/gs"));
 
-        let re = Pattern::new("/user/profile");
+        let re = ResourceDef::new("/user/profile");
         assert!(re.is_match("/user/profile"));
         assert!(!re.is_match("/user/profile/profile"));
     }
 
     #[test]
     fn test_parse_param() {
-        let re = Pattern::new("/user/{id}");
+        let re = ResourceDef::new("/user/{id}");
         assert!(re.is_match("/user/profile"));
         assert!(re.is_match("/user/2345"));
         assert!(!re.is_match("/user/2345/"));
@@ -318,7 +375,7 @@ mod tests {
         assert!(re.match_path(&mut path));
         assert_eq!(path.get("id").unwrap(), "1245125");
 
-        let re = Pattern::new("/v{version}/resource/{id}");
+        let re = ResourceDef::new("/v{version}/resource/{id}");
         assert!(re.is_match("/v1/resource/320120"));
         assert!(!re.is_match("/v/resource/1"));
         assert!(!re.is_match("/resource"));
@@ -328,7 +385,7 @@ mod tests {
         assert_eq!(path.get("version").unwrap(), "151");
         assert_eq!(path.get("id").unwrap(), "adahg32");
 
-        let re = Pattern::new("/{id:[[:digit:]]{6}}");
+        let re = ResourceDef::new("/{id:[[:digit:]]{6}}");
         assert!(re.is_match("/012345"));
         assert!(!re.is_match("/012"));
         assert!(!re.is_match("/01234567"));
@@ -341,7 +398,7 @@ mod tests {
 
     #[test]
     fn test_parse_urlencoded_param() {
-        let re = Pattern::new("/user/{id}/test");
+        let re = ResourceDef::new("/user/{id}/test");
 
         let mut path = Path::new("/user/2345/test");
         assert!(re.match_path(&mut path));
@@ -359,14 +416,19 @@ mod tests {
 
     #[test]
     fn test_resource_prefix() {
-        let re = Pattern::prefix("/name");
+        let re = ResourceDef::prefix("/name");
         assert!(re.is_match("/name"));
         assert!(re.is_match("/name/"));
         assert!(re.is_match("/name/test/test"));
         assert!(re.is_match("/name1"));
         assert!(re.is_match("/name~"));
 
-        let re = Pattern::prefix("/name/");
+        let re = ResourceDef::prefix("/name/");
+        assert!(re.is_match("/name/"));
+        assert!(re.is_match("/name/gs"));
+        assert!(!re.is_match("/name"));
+
+        let re = ResourceDef::root_prefix("name/");
         assert!(re.is_match("/name/"));
         assert!(re.is_match("/name/gs"));
         assert!(!re.is_match("/name"));
@@ -374,7 +436,7 @@ mod tests {
 
     #[test]
     fn test_reousrce_prefix_dynamic() {
-        let re = Pattern::prefix("/{name}/");
+        let re = ResourceDef::prefix("/{name}/");
         assert!(re.is_match("/name/"));
         assert!(re.is_match("/name/gs"));
         assert!(!re.is_match("/name"));

router/src/router.rs

@@ -1,9 +1,8 @@
 use std::collections::HashMap;
 use std::rc::Rc;
 
-use crate::path::Path;
+use crate::resource::ResourceDef;
-use crate::pattern::Pattern;
+use crate::{Resource, ResourcePath};
-use crate::RequestPath;
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub(crate) enum ResourceId {
@@ -20,20 +19,20 @@ pub struct ResourceInfo {
 
 #[derive(Default, Debug)]
 pub(crate) struct ResourceMap {
-    root: Option<Pattern>,
+    root: Option<ResourceDef>,
-    named: HashMap<String, Pattern>,
+    named: HashMap<String, ResourceDef>,
-    patterns: Vec<Pattern>,
+    patterns: Vec<ResourceDef>,
 }
 
 /// Resource router.
-pub struct Router<T> {
+pub struct Router<T, U = ()> {
     rmap: Rc<ResourceMap>,
-    named: HashMap<String, Pattern>,
+    named: HashMap<String, ResourceDef>,
-    resources: Vec<T>,
+    resources: Vec<(T, Option<U>)>,
 }
 
-impl<T> Router<T> {
+impl<T, U> Router<T, U> {
-    pub fn build() -> RouterBuilder<T> {
+    pub fn build() -> RouterBuilder<T, U> {
         RouterBuilder {
             rmap: ResourceMap::default(),
             named: HashMap::new(),
@@ -41,52 +40,71 @@ impl<T> Router<T> {
         }
     }
 
-    pub fn recognize<U: RequestPath>(&self, path: &mut Path<U>) -> Option<(&T, ResourceInfo)> {
+    pub fn recognize<R: Resource<P>, P: ResourcePath>(
-        if !path.path().is_empty() {
+        &self,
-            for (idx, resource) in self.rmap.patterns.iter().enumerate() {
+        res: &mut R,
-                if resource.match_path(path) {
+    ) -> Option<(&T, ResourceInfo)> {
-                    let info = ResourceInfo {
+        for (idx, resource) in self.rmap.patterns.iter().enumerate() {
-                        rmap: self.rmap.clone(),
+            if resource.match_path(res.resource_path()) {
-                        resource: ResourceId::Normal(idx as u16),
+                let info = ResourceInfo {
-                    };
+                    rmap: self.rmap.clone(),
-                    return Some((&self.resources[idx], info));
+                    resource: ResourceId::Normal(idx as u16),
-                }
+                };
+                return Some((&self.resources[idx].0, info));
             }
         }
         None
     }
 
-    pub fn recognize_mut<U: RequestPath>(
+    pub fn recognize_mut<R: Resource<P>, P: ResourcePath>(
         &mut self,
-        path: &mut Path<U>,
+        res: &mut R,
     ) -> Option<(&mut T, ResourceInfo)> {
-        if !path.path().is_empty() {
+        for (idx, resource) in self.rmap.patterns.iter().enumerate() {
-            for (idx, resource) in self.rmap.patterns.iter().enumerate() {
+            if resource.match_path(res.resource_path()) {
-                if resource.match_path(path) {
+                let info = ResourceInfo {
-                    let info = ResourceInfo {
+                    rmap: self.rmap.clone(),
-                        rmap: self.rmap.clone(),
+                    resource: ResourceId::Normal(idx as u16),
-                        resource: ResourceId::Normal(idx as u16),
+                };
-                    };
+                return Some((&mut self.resources[idx].0, info));
-                    return Some((&mut self.resources[idx], info));
+            }
-                }
+        }
+        None
+    }
+
+    pub fn recognize_mut_checked<R: Resource<P>, P: ResourcePath, F>(
+        &mut self,
+        res: &mut R,
+        check: F,
+    ) -> Option<(&mut T, ResourceInfo)>
+    where
+        F: Fn(&R, &Option<U>) -> bool,
+    {
+        for (idx, resource) in self.rmap.patterns.iter().enumerate() {
+            if resource.match_path(res.resource_path()) && check(res, &self.resources[idx].1) {
+                let info = ResourceInfo {
+                    rmap: self.rmap.clone(),
+                    resource: ResourceId::Normal(idx as u16),
+                };
+                return Some((&mut self.resources[idx].0, info));
             }
         }
         None
     }
 }
 
-impl<'a, T> IntoIterator for &'a Router<T> {
+impl<'a, T, U> IntoIterator for &'a Router<T, U> {
-    type Item = &'a T;
+    type Item = &'a (T, Option<U>);
-    type IntoIter = std::slice::Iter<'a, T>;
+    type IntoIter = std::slice::Iter<'a, (T, Option<U>)>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.resources.iter()
     }
 }
 
-impl<'a, T> IntoIterator for &'a mut Router<T> {
+impl<'a, T, U> IntoIterator for &'a mut Router<T, U> {
-    type Item = &'a mut T;
+    type Item = &'a mut (T, Option<U>);
-    type IntoIter = std::slice::IterMut<'a, T>;
+    type IntoIter = std::slice::IterMut<'a, (T, Option<U>)>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.resources.iter_mut()
@@ -94,11 +112,11 @@ impl<'a, T> IntoIterator for &'a mut Router<T> {
 }
 
 impl ResourceMap {
-    fn register(&mut self, pattern: Pattern) {
+    fn register(&mut self, pattern: ResourceDef) {
         self.patterns.push(pattern);
     }
 
-    fn register_named(&mut self, name: String, pattern: Pattern) {
+    fn register_named(&mut self, name: String, pattern: ResourceDef) {
         self.patterns.push(pattern.clone());
         self.named.insert(name, pattern);
     }
@@ -108,24 +126,40 @@ impl ResourceMap {
     }
 }
 
-pub struct RouterBuilder<T> {
+pub struct RouterBuilder<T, U = ()> {
     rmap: ResourceMap,
-    named: HashMap<String, Pattern>,
+    named: HashMap<String, ResourceDef>,
-    resources: Vec<T>,
+    resources: Vec<(T, Option<U>)>,
 }
 
-impl<T> RouterBuilder<T> {
+impl<T, U> RouterBuilder<T, U> {
+    /// Register resource for specified path.
     pub fn path(&mut self, path: &str, resource: T) {
-        self.rmap.register(Pattern::new(path));
+        self.rmap.register(ResourceDef::new(path));
-        self.resources.push(resource);
+        self.resources.push((resource, None));
     }
 
+    /// Register resource for specified path prefix.
     pub fn prefix(&mut self, prefix: &str, resource: T) {
-        self.rmap.register(Pattern::prefix(prefix));
+        self.rmap.register(ResourceDef::prefix(prefix));
-        self.resources.push(resource);
+        self.resources.push((resource, None));
     }
 
-    pub fn finish(self) -> Router<T> {
+    /// Register resource for ResourceDef
+    pub fn rdef(&mut self, rdef: ResourceDef, resource: T) {
+        self.rmap.register(rdef);
+        self.resources.push((resource, None));
+    }
+
+    /// Method attachs user data to lastly added resource.
+    ///
+    /// This panics if no resources were added.
+    pub fn set_user_data(&mut self, userdata: Option<U>) {
+        self.resources.last_mut().unwrap().1 = userdata;
+    }
+
+    /// Finish configuration and create router instance.
+    pub fn finish(self) -> Router<T, U> {
         Router {
             rmap: Rc::new(self.rmap),
             named: self.named,

router/src/url.rs

@@ -1,6 +1,6 @@
 use std::rc::Rc;
 
-use crate::RequestPath;
+use crate::ResourcePath;
 
 #[allow(dead_code)]
 const GEN_DELIMS: &[u8] = b":/?#[]@";
@@ -67,7 +67,7 @@ impl Url {
     }
 }
 
-impl RequestPath for Url {
+impl ResourcePath for Url {
     fn path(&self) -> &str {
         self.path()
     }
@@ -190,11 +190,11 @@ mod tests {
     use http::{HttpTryFrom, Uri};
 
     use super::*;
-    use crate::{Path, Pattern};
+    use crate::{Path, ResourceDef};
 
     #[test]
     fn test_parse_url() {
-        let re = Pattern::new("/user/{id}/test");
+        let re = ResourceDef::new("/user/{id}/test");
 
         let url = Uri::try_from("/user/2345/test").unwrap();
         let mut path = Path::new(Url::new(url));