prepare actix-connector release

.travis.yml

@@ -39,6 +39,7 @@ script:
     cd actix-rt && cargo test && cd ..
     cd actix-connector && cargo test && cd ..
     cd actix-utils && cargo test && cd ..
+    cd router && cargo test && cd ..
     fi
   - |
     if [[ "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
@@ -52,4 +53,5 @@ script:
     cd actix-codec && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
     cd actix-server && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
     cd actix-utils && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
+    cd router && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
     fi

Cargo.toml

@@ -1,34 +1,11 @@
-[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",
   "actix-connector",
+  "actix-rt",
   "actix-service",
   "actix-server",
-  "actix-rt",
+  "actix-test-server",
   "actix-utils",
+  "router",
 ]
-
-[dev-dependencies]
-actix-service = "0.1.1"
-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-connector/CHANGES.md

@@ -1,5 +1,28 @@
 # Changes
 
+## [0.3.0] - 2019-03-02
+
+### 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 direct actix-rt dipendency
+
+
+## [0.1.1] - 2019-01-13
+
+* Upgrade trust-dns-proto
+
+
 ## [0.1.0] - 2018-12-09
 
 * Move server to separate crate

actix-connector/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-connector"
-version = "0.1.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,13 +27,12 @@ default = []
 ssl = ["openssl", "tokio-openssl"]
 
 [dependencies]
-actix-service = "0.1.1"
+actix-service = "0.3.0"
 actix-codec = "0.1.0"
-actix-rt = "0.1.0"
 futures = "0.1"
 tokio-tcp = "0.1"
-trust-dns-proto = "^0.5.0"
-trust-dns-resolver = "^0.10.0"
+tokio-current-thread = "0.1"
+trust-dns-resolver = { version="0.11.0-alpha.2", default-features = false }
 
 # openssl
 openssl = { version="0.10", optional = true }

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 futures::future::{ok, Either, FutureResult};
+use actix_service::{fn_factory, NewService, Service};
+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<Connect, Response = (Connect, TcpStream), Error = ConnectorError> + Clone
-    {
+    ) -> impl Service<Request = Connect, Response = (Connect, TcpStream), Error = ConnectorError>
+                 + Clone {
         Connector { resolver }
     }
 
@@ -177,12 +177,13 @@ impl Connector {
         cfg: ResolverConfig,
         opts: ResolverOpts,
     ) -> impl NewService<
-        Connect,
+        (),
+        Request = 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,7 +195,8 @@ impl Clone for Connector {
     }
 }
 
-impl Service<Connect> for Connector {
+impl Service for Connector {
+    type Request = Connect;
     type Response = (Connect, TcpStream);
     type Error = ConnectorError;
     type Future = Either<ConnectorFuture, ConnectorTcpFuture>;
@@ -271,7 +273,8 @@ impl<T: RequestPort> Default for TcpConnector<T> {
     }
 }
 
-impl<T: RequestPort> Service<(T, VecDeque<IpAddr>)> for TcpConnector<T> {
+impl<T: RequestPort> Service for TcpConnector<T> {
+    type Request = (T, VecDeque<IpAddr>);
     type Response = (T, TcpStream);
     type Error = io::Error;
     type Future = TcpConnectorResponse<T>;
@@ -317,7 +320,7 @@ impl<T: RequestPort> Future for TcpConnectorResponse<T> {
             if let Some(new) = self.stream.as_mut() {
                 match new.poll() {
                     Ok(Async::Ready(sock)) => {
-                        return Ok(Async::Ready((self.req.take().unwrap(), sock)))
+                        return Ok(Async::Ready((self.req.take().unwrap(), sock)));
                     }
                     Ok(Async::NotReady) => return Ok(Async::NotReady),
                     Err(err) => {
@@ -351,7 +354,8 @@ impl DefaultConnector {
     }
 }
 
-impl Service<Connect> for DefaultConnector {
+impl Service for DefaultConnector {
+    type Request = Connect;
     type Response = TcpStream;
     type Error = ConnectorError;
     type Future = DefaultConnectorFuture;

actix-connector/src/resolver.rs

@@ -42,7 +42,7 @@ impl<T: RequestHost> Resolver<T> {
     /// Create new resolver instance with custom configuration and options.
     pub fn new(cfg: ResolverConfig, opts: ResolverOpts) -> Self {
         let (resolver, bg) = AsyncResolver::new(cfg, opts);
-        actix_rt::Arbiter::spawn(bg);
+        tokio_current_thread::spawn(bg);
         Resolver {
             resolver,
             req: PhantomData,
@@ -67,7 +67,8 @@ impl<T> Clone for Resolver<T> {
     }
 }
 
-impl<T: RequestHost> Service<T> for Resolver<T> {
+impl<T: RequestHost> Service 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,7 +26,8 @@ impl<R, T, E> OpensslConnector<R, T, E> {
 impl<R: RequestHost, T: AsyncRead + AsyncWrite> OpensslConnector<R, T, ()> {
     pub fn service(
         connector: SslConnector,
-    ) -> impl Service<(R, T), Response = (R, SslStream<T>), Error = HandshakeError<T>> {
+    ) -> impl Service<Request = (R, T), Response = (R, SslStream<T>), Error = HandshakeError<T>>
+    {
         OpensslConnectorService {
             connector: connector,
             _t: PhantomData,
@@ -43,16 +44,17 @@ impl<R, T, E> Clone for OpensslConnector<R, T, E> {
     }
 }
 
-impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService<(R, T)>
+impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService<()>
     for OpensslConnector<R, T, E>
 {
+    type Request = (R, T);
     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,9 +67,8 @@ pub struct OpensslConnectorService<R, T> {
     _t: PhantomData<(R, T)>,
 }
 
-impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service<(R, T)>
-    for OpensslConnectorService<R, T>
-{
+impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service for OpensslConnectorService<R, T> {
+    type Request = (R, T);
     type Response = (R, SslStream<T>);
     type Error = HandshakeError<T>;
     type Future = ConnectAsyncExt<R, T>;

actix-server/CHANGES.md

@@ -1,5 +1,52 @@
 # Changes
 
+## [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
+
+* Updated rustls dependency
+
+
+## [0.1.3] - 2018-12-21
+
+### Fixed
+
+* Fix max concurrent connections handling
+
+
+## [0.1.2] - 2018-12-12
+
+### Changed
+
+* rename ServiceConfig::rt() to ServiceConfig::apply()
+
+
+### Fixed
+
+* Fix back-pressure for concurrent ssl handshakes
+
+
+## [0.1.1] - 2018-12-11
+
+* Fix signal handling on windows
+
+
 ## [0.1.0] - 2018-12-09
 
 * Move server to separate crate

actix-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-server"
-version = "0.1.0"
+version = "0.3.0"
 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,21 +33,19 @@ ssl = ["openssl", "tokio-openssl"]
 rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
 
 [dependencies]
-actix-service = "0.1.1"
+actix-service = "0.3.0"
 actix-rt = "0.1.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"
 tokio-tcp = "0.1"
-tokio-timer = "0.2"
+tokio-timer = "0.2.8"
 tokio-reactor = "0.1"
 tokio-signal = "0.2"
 
@@ -59,10 +57,11 @@ openssl = { version="0.10", optional = true }
 tokio-openssl = { version="0.3", optional = true }
 
 #rustls
-rustls = { version = "^0.14", optional = true }
-tokio-rustls = { version = "^0.8", optional = true }
-webpki = { version = "0.18", optional = true }
-webpki-roots = { version = "0.15", optional = true }
+rustls = { version = "^0.15", optional = true }
+tokio-rustls = { version = "^0.9", optional = true }
+webpki = { version = "0.19", optional = true }
+webpki-roots = { version = "0.16", optional = true }
 
 [dev-dependencies]
-env_logger = "0.5"
+env_logger = "0.6"
+actix-codec = "0.1.0"

actix-server/src/builder.rs

@@ -15,7 +15,6 @@ 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::{ServiceFactory, ServiceNewService};
 use crate::signals::{Signal, Signals};
 use crate::worker::{self, Worker, WorkerAvailability, WorkerClient};
 use crate::Token;
@@ -64,7 +63,7 @@ impl ServerBuilder {
 
     /// Set number of workers to start.
     ///
-    /// By default server uses number of available logical cpu as threads
+    /// By default server uses number of available logical cpu as workers
     /// count.
     pub fn workers(mut self, num: usize) -> Self {
         self.threads = num;
@@ -108,8 +107,8 @@ impl ServerBuilder {
         self
     }
 
-    /// Run external configuration as part of the server building
-    /// process
+    /// Execute external configuration as part of the server building
+    /// process.
     ///
     /// This function is useful for moving parts of configuration to a
     /// different module or even library.
@@ -117,17 +116,20 @@ impl ServerBuilder {
     where
         F: Fn(&mut ServiceConfig) -> io::Result<()>,
     {
-        let mut cfg = ServiceConfig::new();
+        let mut cfg = ServiceConfig::new(self.threads);
 
         f(&mut cfg)?;
 
-        let mut srv = ConfiguredService::new(cfg.rt);
-        for (name, lst) in cfg.services {
-            let token = self.token.next();
-            srv.stream(token, name);
-            self.sockets.push((token, lst));
+        if let Some(apply) = cfg.apply {
+            let mut srv = ConfiguredService::new(apply);
+            for (name, lst) in cfg.services {
+                let token = self.token.next();
+                srv.stream(token, name);
+                self.sockets.push((token, lst));
+            }
+            self.services.push(Box::new(srv));
         }
-        self.services.push(Box::new(srv));
+        self.threads = cfg.threads;
 
         Ok(self)
     }
@@ -173,26 +175,6 @@ impl ServerBuilder {
         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(
-            name.as_ref().to_string(),
-            token,
-            factory,
-        ));
-        self.sockets.push((token, lst));
-        self
-    }
-
     /// Spawn new thread and start listening for incoming connections.
     ///
     /// This method spawns new thread and starts new actix system. Other than
@@ -201,9 +183,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

@@ -15,18 +15,28 @@ use super::services::{
 use super::Token;
 
 pub struct ServiceConfig {
-    pub(super) services: Vec<(String, net::TcpListener)>,
-    pub(super) rt: Box<ServiceRuntimeConfiguration>,
+    pub(crate) services: Vec<(String, net::TcpListener)>,
+    pub(crate) apply: Option<Box<ServiceRuntimeConfiguration>>,
+    pub(crate) threads: usize,
 }
 
 impl ServiceConfig {
-    pub(super) fn new() -> ServiceConfig {
+    pub(super) fn new(threads: usize) -> ServiceConfig {
         ServiceConfig {
+            threads,
             services: Vec::new(),
-            rt: Box::new(not_configured),
+            apply: None,
         }
     }
 
+    /// Set number of workers to start.
+    ///
+    /// By default server uses number of available logical cpu as workers
+    /// count.
+    pub fn workers(&mut self, num: usize) {
+        self.threads = num;
+    }
+
     /// Add new service to server
     pub fn bind<U, N: AsRef<str>>(&mut self, name: N, addr: U) -> io::Result<&mut Self>
     where
@@ -43,16 +53,20 @@ impl ServiceConfig {
 
     /// Add new service to server
     pub fn listen<N: AsRef<str>>(&mut self, name: N, lst: net::TcpListener) -> &mut Self {
+        if self.apply.is_none() {
+            self.apply = Some(Box::new(not_configured));
+        }
         self.services.push((name.as_ref().to_string(), lst));
         self
     }
 
-    /// Register service configuration function
-    pub fn rt<F>(&mut self, f: F) -> io::Result<()>
+    /// Register service configuration function. This function get called
+    /// during worker runtime configuration. It get executed in worker thread.
+    pub fn apply<F>(&mut self, f: F) -> io::Result<()>
     where
         F: Fn(&mut ServiceRuntime) + Send + Clone + 'static,
     {
-        self.rt = Box::new(f);
+        self.apply = Some(Box::new(f));
         Ok(())
     }
 }
@@ -100,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| {
@@ -155,8 +169,8 @@ impl ServiceRuntime {
 
     pub fn service<T, F>(&mut self, name: &str, service: F)
     where
-        F: IntoNewService<T, TcpStream>,
-        T: NewService<TcpStream, Response = ()> + 'static,
+        F: IntoNewService<T>,
+        T: NewService<Request = TcpStream, Response = ()> + 'static,
         T::Future: 'static,
         T::Service: 'static,
         T::InitError: fmt::Debug,
@@ -177,7 +191,7 @@ impl ServiceRuntime {
 
 type BoxedNewService = Box<
     NewService<
-        (Option<CounterGuard>, ServerMessage),
+        Request = (Option<CounterGuard>, ServerMessage),
         Response = (),
         Error = (),
         InitError = (),
@@ -190,22 +204,23 @@ struct ServiceFactory<T> {
     inner: T,
 }
 
-impl<T> NewService<(Option<CounterGuard>, ServerMessage)> for ServiceFactory<T>
+impl<T> NewService for ServiceFactory<T>
 where
-    T: NewService<TcpStream, Response = ()>,
+    T: NewService<Request = 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 {
-        Box::new(self.inner.new_service().map_err(|_| ()).map(|s| {
+    fn new_service(&self, _: &()) -> Self::Future {
+        Box::new(self.inner.new_service(&()).map_err(|_| ()).map(|s| {
             let service: BoxedServerService = Box::new(StreamService::new(s));
             service
         }))

actix-server/src/counter.rs

@@ -9,6 +9,7 @@ use futures::task::AtomicTask;
 /// Counter could be cloned, total ncount is shared across all clones.
 pub struct Counter(Rc<CounterInner>);
 
+#[derive(Debug)]
 struct CounterInner {
     count: Cell<usize>,
     capacity: usize,
@@ -40,6 +41,7 @@ impl Counter {
     }
 }
 
+#[derive(Debug)]
 pub struct CounterGuard(Rc<CounterInner>);
 
 impl CounterGuard {
@@ -57,11 +59,7 @@ impl Drop for CounterGuard {
 
 impl CounterInner {
     fn inc(&self) {
-        let num = self.count.get() + 1;
-        self.count.set(num);
-        if num == self.capacity {
-            self.task.register();
-        }
+        self.count.set(self.count.get() + 1);
     }
 
     fn dec(&self) {
@@ -73,6 +71,10 @@ impl CounterInner {
     }
 
     fn available(&self) -> bool {
-        self.count.get() < self.capacity
+        let avail = self.count.get() < self.capacity;
+        if !avail {
+            self.task.register();
+        }
+        avail
     }
 }

actix-server/src/lib.rs

@@ -13,7 +13,7 @@ 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::StreamServiceFactory;
 
 /// Socket id token
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -28,6 +28,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
@@ -23,13 +23,7 @@ pub enum ServerMessage {
 }
 
 pub trait StreamServiceFactory: Send + Clone + 'static {
-    type NewService: NewService<TcpStream, Response = ()>;
-
-    fn create(&self) -> Self::NewService;
-}
-
-pub trait ServiceFactory: Send + Clone + 'static {
-    type NewService: NewService<ServerMessage, Response = ()>;
+    type NewService: NewService<Request = TcpStream>;
 
     fn create(&self) -> Self::NewService;
 }
@@ -44,7 +38,7 @@ pub(crate) trait InternalServiceFactory: Send {
 
 pub(crate) type BoxedServerService = Box<
     Service<
-        (Option<CounterGuard>, ServerMessage),
+        Request = (Option<CounterGuard>, ServerMessage),
         Response = (),
         Error = (),
         Future = FutureResult<(), ()>,
@@ -61,12 +55,13 @@ impl<T> StreamService<T> {
     }
 }
 
-impl<T> Service<(Option<CounterGuard>, ServerMessage)> for StreamService<T>
+impl<T> Service for StreamService<T>
 where
-    T: Service<TcpStream, Response = ()>,
+    T: Service<Request = TcpStream>,
     T::Future: 'static,
     T::Error: 'static,
 {
+    type Request = (Option<CounterGuard>, ServerMessage);
     type Response = ();
     type Error = ();
     type Future = FutureResult<(), ()>;
@@ -83,9 +78,9 @@ where
                 });
 
                 if let Ok(stream) = stream {
-                    spawn(self.service.call(stream).map_err(|_| ()).map(move |val| {
+                    spawn(self.service.call(stream).then(move |res| {
                         drop(guard);
-                        val
+                        res.map_err(|_| ()).map(|_| ())
                     }));
                     ok(())
                 } else {
@@ -97,85 +92,6 @@ where
     }
 }
 
-pub(crate) struct ServerService<T> {
-    service: T,
-}
-
-impl<T> ServerService<T> {
-    fn new(service: T) -> Self {
-        ServerService { service }
-    }
-}
-
-impl<T> Service<(Option<CounterGuard>, ServerMessage)> for ServerService<T>
-where
-    T: Service<ServerMessage, Response = ()>,
-    T::Future: 'static,
-    T::Error: 'static,
-{
-    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).map_err(|_| ()).map(move |val| {
-            drop(guard);
-            val
-        }));
-        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,
@@ -212,7 +128,7 @@ where
         Box::new(
             self.inner
                 .create()
-                .new_service()
+                .new_service(&())
                 .map_err(|_| ())
                 .map(move |inner| {
                     let service: BoxedServerService = Box::new(StreamService::new(inner));
@@ -236,22 +152,10 @@ impl InternalServiceFactory for Box<InternalServiceFactory> {
     }
 }
 
-impl<F, T> ServiceFactory for F
-where
-    F: Fn() -> T + Send + Clone + 'static,
-    T: NewService<ServerMessage, Response = ()>,
-{
-    type NewService = T;
-
-    fn create(&self) -> T {
-        (self)()
-    }
-}
-
 impl<F, T> StreamServiceFactory for F
 where
     F: Fn() -> T + Send + Clone + 'static,
-    T: NewService<TcpStream, Response = ()>,
+    T: NewService<Request = TcpStream>,
 {
     type NewService = T;
 

actix-server/src/signals.rs

@@ -34,10 +34,12 @@ impl Signals {
         let fut = {
             #[cfg(not(unix))]
             {
-                tokio_signal::ctrl_c().and_then(move |stream| Signals {
-                    srv,
-                    stream: Box::new(stream.map(|_| Signal::Int)),
-                })
+                tokio_signal::ctrl_c()
+                    .map_err(|_| ())
+                    .and_then(move |stream| Signals {
+                        srv,
+                        stream: Box::new(stream.map(|_| Signal::Int)),
+                    })
             }
 
             #[cfg(unix)]

actix-server/src/ssl/nativetls.rs

@@ -36,14 +36,15 @@ impl<T: AsyncRead + AsyncWrite> Clone for NativeTlsAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService<T> for NativeTlsAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite> NewService 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(),
@@ -60,7 +61,8 @@ pub struct NativeTlsAcceptorService<T> {
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service<T> for NativeTlsAcceptorService<T> {
+impl<T: AsyncRead + AsyncWrite> Service for NativeTlsAcceptorService<T> {
+    type Request = T;
     type Response = TlsStream<T>;
     type Error = Error;
     type Future = Accept<T>;

actix-server/src/ssl/openssl.rs

@@ -36,14 +36,15 @@ impl<T: AsyncRead + AsyncWrite> Clone for OpensslAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService<T> for OpensslAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite> NewService 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(),
@@ -60,7 +61,8 @@ pub struct OpensslAcceptorService<T> {
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service<T> for OpensslAcceptorService<T> {
+impl<T: AsyncRead + AsyncWrite> Service 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,14 +38,15 @@ impl<T> Clone for RustlsAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService<T> for RustlsAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite> NewService 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(),
@@ -62,7 +63,8 @@ pub struct RustlsAcceptorService<T> {
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service<T> for RustlsAcceptorService<T> {
+impl<T: AsyncRead + AsyncWrite> Service for RustlsAcceptorService<T> {
+    type Request = T;
     type Response = TlsStream<T, ServerSession>;
     type Error = io::Error;
     type Future = RustlsAcceptorServiceFut<T>;

actix-server/src/worker.rs

@@ -398,7 +398,7 @@ impl Future for Worker {
                                     let guard = self.conns.get();
                                     let _ = self.services[msg.token.0]
                                         .as_mut()
-                                        .expect("actix net bug")
+                                        .expect("actix-server bug")
                                         .1
                                         .call((Some(guard), ServerMessage::Connect(msg.io)));
                                     continue;

actix-service/CHANGES.md

@@ -1,5 +1,96 @@
 # Changes
 
+## [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
+
+* Use associated type instead of generic for Service definition.
+
+  * Before:
+
+    ```rust
+    impl Service<Request> for Client {
+        type Response = Response;
+        // ...
+    }
+    ```
+  * After:
+
+    ```rust
+    impl Service for Client {
+        type Request = Request;
+        type Response = Response;
+        // ...
+    }
+    ```
+
+
+## [0.1.6] - 2019-01-24
+
+### Changed
+
+* Use `FnMut` instead of `Fn` for .apply() and .map() combinators and `FnService` type
+
+* Change `.apply()` error semantic, new service's error is `From<Self::Error>`
+
+
+## [0.1.5] - 2019-01-13
+
+### Changed
+
+* Make `Out::Error` convertable from `T::Error` for apply combinator
+
+
+## [0.1.4] - 2019-01-11
+
+### Changed
+
+* Use `FnMut` instead of `Fn` for `FnService`
+
+
+## [0.1.3] - 2018-12-12
+
+### Changed
+
+* Split service combinators to separate trait
+
+
+## [0.1.2] - 2018-12-12
+
+### Fixed
+
+* Release future early for `.and_then()` and `.then()` combinators
+
+
 ## [0.1.1] - 2018-12-09
 
 ### Added

actix-service/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-service"
-version = "0.1.1"
+version = "0.3.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix Service"
 keywords = ["network", "framework", "async", "futures"]
@@ -11,11 +11,11 @@ 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" }
-# appveyor = { repository = "fafhrd91/actix-web-hdy9d" }
+appveyor = { repository = "actix/actix-net" }
 codecov = { repository = "actix/actix-service", branch = "master", service = "github" }
 
 [lib]
@@ -24,3 +24,4 @@ path = "src/lib.rs"
 
 [dependencies]
 futures = "0.1.24"
+void = "1.0.2"

actix-service/src/and_then.rs

@@ -1,3 +1,5 @@
+use std::marker::PhantomData;
+
 use futures::{try_ready, Async, Future, Poll};
 
 use super::{IntoNewService, NewService, Service};
@@ -14,10 +16,10 @@ pub struct AndThen<A, B> {
 
 impl<A, B> AndThen<A, B> {
     /// Create new `AndThen` combinator
-    pub fn new<Request>(a: A, b: B) -> Self
+    pub fn new(a: A, b: B) -> Self
     where
-        A: Service<Request>,
-        B: Service<A::Response, Error = A::Error>,
+        A: Service,
+        B: Service<Request = A::Response, Error = A::Error>,
     {
         Self { a, b: Cell::new(b) }
     }
@@ -35,53 +37,54 @@ where
     }
 }
 
-impl<A, B, Request> Service<Request> for AndThen<A, B>
+impl<A, B> Service for AndThen<A, B>
 where
-    A: Service<Request>,
-    B: Service<A::Response, Error = A::Error>,
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
 {
+    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
-    type Future = AndThenFuture<A, B, Request>;
+    type Future = AndThenFuture<A, B>;
 
     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: Request) -> Self::Future {
+    fn call(&mut self, req: A::Request) -> Self::Future {
         AndThenFuture::new(self.a.call(req), self.b.clone())
     }
 }
 
-pub struct AndThenFuture<A, B, Request>
+pub struct AndThenFuture<A, B>
 where
-    A: Service<Request>,
-    B: Service<A::Response, Error = A::Error>,
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
 {
     b: Cell<B>,
     fut_b: Option<B::Future>,
-    fut_a: A::Future,
+    fut_a: Option<A::Future>,
 }
 
-impl<A, B, Request> AndThenFuture<A, B, Request>
+impl<A, B> AndThenFuture<A, B>
 where
-    A: Service<Request>,
-    B: Service<A::Response, Error = A::Error>,
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
 {
-    fn new(fut_a: A::Future, b: Cell<B>) -> Self {
+    fn new(a: A::Future, b: Cell<B>) -> Self {
         AndThenFuture {
             b,
-            fut_a,
+            fut_a: Some(a),
             fut_b: None,
         }
     }
 }
 
-impl<A, B, Request> Future for AndThenFuture<A, B, Request>
+impl<A, B> Future for AndThenFuture<A, B>
 where
-    A: Service<Request>,
-    B: Service<A::Response, Error = A::Error>,
+    A: Service,
+    B: Service<Request = A::Response, Error = A::Error>,
 {
     type Item = B::Response;
     type Error = A::Error;
@@ -91,8 +94,9 @@ where
             return fut.poll();
         }
 
-        match self.fut_a.poll() {
+        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(self.b.get_mut().call(resp));
                 self.poll()
             }
@@ -103,43 +107,46 @@ where
 }
 
 /// `AndThenNewService` new service combinator
-pub struct AndThenNewService<A, B> {
+pub struct AndThenNewService<A, B, C> {
     a: A,
     b: B,
+    _t: PhantomData<C>,
 }
 
-impl<A, B> AndThenNewService<A, B> {
+impl<A, B, C> AndThenNewService<A, B, C> {
     /// Create new `AndThen` combinator
-    pub fn new<Request, F: IntoNewService<B, A::Response>>(a: A, f: F) -> Self
+    pub fn new<F: IntoNewService<B, C>>(a: A, f: F) -> Self
     where
-        A: NewService<Request>,
-        B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
+        A: NewService<C>,
+        B: NewService<C, Request = A::Response, Error = A::Error, InitError = A::InitError>,
     {
         Self {
             a,
             b: f.into_new_service(),
+            _t: PhantomData,
         }
     }
 }
 
-impl<A, B, Request> NewService<Request> for AndThenNewService<A, B>
+impl<A, B, C> NewService<C> for AndThenNewService<A, B, C>
 where
-    A: NewService<Request>,
-    B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
+    A: NewService<C>,
+    B: NewService<C, Request = A::Response, 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, Request>;
+    type Future = AndThenNewServiceFuture<A, B, C>;
 
-    fn new_service(&self) -> Self::Future {
-        AndThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        AndThenNewServiceFuture::new(self.a.new_service(cfg), self.b.new_service(cfg))
     }
 }
 
-impl<A, B> Clone for AndThenNewService<A, B>
+impl<A, B, C> Clone for AndThenNewService<A, B, C>
 where
     A: Clone,
     B: Clone,
@@ -148,14 +155,15 @@ where
         Self {
             a: self.a.clone(),
             b: self.b.clone(),
+            _t: PhantomData,
         }
     }
 }
 
-pub struct AndThenNewServiceFuture<A, B, Request>
+pub struct AndThenNewServiceFuture<A, B, C>
 where
-    A: NewService<Request>,
-    B: NewService<A::Response>,
+    A: NewService<C>,
+    B: NewService<C, Request = A::Response>,
 {
     fut_b: B::Future,
     fut_a: A::Future,
@@ -163,10 +171,10 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B, Request> AndThenNewServiceFuture<A, B, Request>
+impl<A, B, C> AndThenNewServiceFuture<A, B, C>
 where
-    A: NewService<Request>,
-    B: NewService<A::Response>,
+    A: NewService<C>,
+    B: NewService<C, Request = A::Response>,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
         AndThenNewServiceFuture {
@@ -178,10 +186,10 @@ where
     }
 }
 
-impl<A, B, Request> Future for AndThenNewServiceFuture<A, B, Request>
+impl<A, B, C> Future for AndThenNewServiceFuture<A, B, C>
 where
-    A: NewService<Request>,
-    B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
+    A: NewService<C>,
+    B: NewService<C, Request = A::Response, Error = A::Error, InitError = A::InitError>,
 {
     type Item = AndThen<A::Service, B::Service>;
     type Error = A::InitError;
@@ -218,10 +226,11 @@ mod tests {
     use std::rc::Rc;
 
     use super::*;
-    use crate::{NewService, Service};
+    use crate::{NewService, Service, ServiceExt};
 
     struct Srv1(Rc<Cell<usize>>);
-    impl Service<&'static str> for Srv1 {
+    impl Service for Srv1 {
+        type Request = &'static str;
         type Response = &'static str;
         type Error = ();
         type Future = FutureResult<Self::Response, ()>;
@@ -239,7 +248,8 @@ mod tests {
     #[derive(Clone)]
     struct Srv2(Rc<Cell<usize>>);
 
-    impl Service<&'static str> for Srv2 {
+    impl Service for Srv2 {
+        type Request = &'static str;
         type Response = (&'static str, &'static str);
         type Error = ();
         type Future = FutureResult<Self::Response, ()>;
@@ -281,7 +291,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

@@ -0,0 +1,306 @@
+use futures::{Async, Future, Poll};
+
+use super::{NewService, NewTransform, Service, Transform};
+use crate::cell::Cell;
+
+/// `Apply` service combinator
+pub struct AndThenTransform<T, A, B>
+where
+    A: Service,
+    B: Service<Error = A::Error>,
+    T: Transform<B, Request = A::Response>,
+    T::Error: From<A::Error>,
+{
+    a: A,
+    b: Cell<B>,
+    t: Cell<T>,
+}
+
+impl<T, A, B> AndThenTransform<T, A, B>
+where
+    A: Service,
+    B: Service<Error = A::Error>,
+    T: Transform<B, Request = A::Response>,
+    T::Error: From<A::Error>,
+{
+    /// Create new `Apply` combinator
+    pub fn new(t: T, a: A, b: B) -> Self {
+        Self {
+            a,
+            b: Cell::new(b),
+            t: Cell::new(t),
+        }
+    }
+}
+
+impl<T, A, B> Clone for AndThenTransform<T, A, B>
+where
+    A: Service + Clone,
+    B: Service<Error = A::Error>,
+    T: Transform<B, Request = A::Response>,
+    T::Error: From<A::Error>,
+{
+    fn clone(&self) -> Self {
+        AndThenTransform {
+            a: self.a.clone(),
+            b: self.b.clone(),
+            t: self.t.clone(),
+        }
+    }
+}
+
+impl<T, A, B> Service for AndThenTransform<T, A, B>
+where
+    A: Service,
+    B: Service<Error = A::Error>,
+    T: Transform<B, Request = A::Response>,
+    T::Error: From<A::Error>,
+{
+    type Request = A::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Future = AndThenTransformFuture<T, A, B>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        let notready = Async::NotReady == self.a.poll_ready()?;
+        let notready = Async::NotReady == self.b.get_mut().poll_ready()? || notready;
+        let notready = Async::NotReady == self.t.get_mut().poll_ready()? || notready;
+
+        if notready {
+            Ok(Async::NotReady)
+        } else {
+            Ok(Async::Ready(()))
+        }
+    }
+
+    fn call(&mut self, req: A::Request) -> Self::Future {
+        AndThenTransformFuture {
+            b: self.b.clone(),
+            t: self.t.clone(),
+            fut_t: None,
+            fut_a: Some(self.a.call(req)),
+        }
+    }
+}
+
+pub struct AndThenTransformFuture<T, A, B>
+where
+    A: Service,
+    B: Service<Error = A::Error>,
+    T: Transform<B, Request = A::Response>,
+    T::Error: From<A::Error>,
+{
+    b: Cell<B>,
+    t: Cell<T>,
+    fut_a: Option<A::Future>,
+    fut_t: Option<T::Future>,
+}
+
+impl<T, A, B> Future for AndThenTransformFuture<T, A, B>
+where
+    A: Service,
+    B: Service<Error = A::Error>,
+    T: Transform<B, Request = A::Response>,
+    T::Error: From<A::Error>,
+{
+    type Item = T::Response;
+    type Error = T::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if let Some(ref mut fut) = self.fut_t {
+            return fut.poll();
+        }
+
+        match self.fut_a.as_mut().expect("Bug in actix-service").poll() {
+            Ok(Async::Ready(resp)) => {
+                let _ = self.fut_a.take();
+                self.fut_t = Some(self.t.get_mut().call(resp, self.b.get_mut()));
+                self.poll()
+            }
+            Ok(Async::NotReady) => Ok(Async::NotReady),
+            Err(err) => Err(err.into()),
+        }
+    }
+}
+
+/// `Apply` new service combinator
+pub struct AndThenTransformNewService<T, A, B, C> {
+    a: A,
+    b: B,
+    t: T,
+    _t: std::marker::PhantomData<C>,
+}
+
+impl<T, A, B, C> AndThenTransformNewService<T, A, B, C>
+where
+    A: NewService<C>,
+    B: NewService<C, Error = A::Error, InitError = A::InitError>,
+    T: NewTransform<B::Service, Request = A::Response, InitError = A::InitError>,
+    T::Error: From<A::Error>,
+{
+    /// Create new `ApplyNewService` new service instance
+    pub fn new(t: T, a: A, b: B) -> Self {
+        Self {
+            a,
+            b,
+            t,
+            _t: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<T, A, B, C> Clone for AndThenTransformNewService<T, A, B, C>
+where
+    A: Clone,
+    B: Clone,
+    T: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            a: self.a.clone(),
+            b: self.b.clone(),
+            t: self.t.clone(),
+            _t: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<T, A, B, C> NewService<C> for AndThenTransformNewService<T, A, B, C>
+where
+    A: NewService<C>,
+    B: NewService<C, Error = A::Error, InitError = A::InitError>,
+    T: NewTransform<B::Service, C, Request = A::Response, InitError = A::InitError>,
+    T::Error: From<A::Error>,
+{
+    type Request = A::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+
+    type InitError = T::InitError;
+    type Service = AndThenTransform<T::Transform, A::Service, B::Service>;
+    type Future = AndThenTransformNewServiceFuture<T, A, B, C>;
+
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        AndThenTransformNewServiceFuture {
+            a: None,
+            b: None,
+            t: None,
+            fut_a: self.a.new_service(cfg),
+            fut_b: self.b.new_service(cfg),
+            fut_t: self.t.new_transform(cfg),
+        }
+    }
+}
+
+pub struct AndThenTransformNewServiceFuture<T, A, B, C>
+where
+    A: NewService<C>,
+    B: NewService<C, Error = A::Error, InitError = A::InitError>,
+    T: NewTransform<B::Service, C, Request = A::Response, InitError = A::InitError>,
+    T::Error: From<A::Error>,
+{
+    fut_b: B::Future,
+    fut_a: A::Future,
+    fut_t: T::Future,
+    a: Option<A::Service>,
+    b: Option<B::Service>,
+    t: Option<T::Transform>,
+}
+
+impl<T, A, B, C> Future for AndThenTransformNewServiceFuture<T, A, B, C>
+where
+    A: NewService<C>,
+    B: NewService<C, Error = A::Error, InitError = A::InitError>,
+    T: NewTransform<B::Service, C, Request = A::Response, InitError = A::InitError>,
+    T::Error: From<A::Error>,
+{
+    type Item = AndThenTransform<T::Transform, A::Service, B::Service>;
+    type Error = T::InitError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if self.t.is_none() {
+            if let Async::Ready(transform) = self.fut_t.poll()? {
+                self.t = Some(transform);
+            }
+        }
+
+        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() && self.t.is_some() {
+            Ok(Async::Ready(AndThenTransform {
+                a: self.a.take().unwrap(),
+                t: Cell::new(self.t.take().unwrap()),
+                b: Cell::new(self.b.take().unwrap()),
+            }))
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use futures::future::{ok, FutureResult};
+    use futures::{Async, Future, Poll};
+
+    use crate::{IntoNewService, IntoService, NewService, Service, ServiceExt};
+
+    #[derive(Clone)]
+    struct Srv;
+    impl Service for Srv {
+        type Request = ();
+        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_apply() {
+        let blank = |req| Ok(req);
+
+        let mut srv = blank.into_service().apply(
+            |req: &'static str, srv: &mut Srv| srv.call(()).map(move |res| (req, res)),
+            Srv,
+        );
+        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 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),
+        );
+        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/and_then_apply_fn.rs

@@ -0,0 +1,307 @@
+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>
+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()
+    }
+
+    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),
+        }
+    }
+}
+
+/// `ApplyNewService` new service combinator
+pub struct AndThenApplyNewService<A, B, F, Out, Cfg> {
+    a: A,
+    b: B,
+    f: Cell<F>,
+    r: PhantomData<(Out, Cfg)>,
+}
+
+impl<A, B, F, Out, Cfg> AndThenApplyNewService<A, B, F, Out, Cfg>
+where
+    A: NewService<Cfg>,
+    B: NewService<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, Cfg>, B1: IntoNewService<B, 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, Cfg> Clone for AndThenApplyNewService<A, B, F, Out, 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, Cfg> NewService<Cfg> for AndThenApplyNewService<A, B, F, Out, Cfg>
+where
+    A: NewService<Cfg>,
+    B: NewService<Cfg, Error = A::Error, InitError = A::InitError>,
+    F: FnMut(A::Response, &mut B::Service) -> Out,
+    Out: IntoFuture,
+    Out::Error: Into<A::Error>,
+{
+    type Request = A::Request;
+    type Response = Out::Item;
+    type Error = A::Error;
+    type Service = AndThenApply<A::Service, B::Service, F, Out>;
+
+    type InitError = A::InitError;
+    type Future = AndThenApplyNewServiceFuture<A, B, F, Out, 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),
+            fut_b: self.b.new_service(cfg),
+        }
+    }
+}
+
+pub struct AndThenApplyNewServiceFuture<A, B, F, Out, Cfg>
+where
+    A: NewService<Cfg>,
+    B: NewService<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, Cfg> Future for AndThenApplyNewServiceFuture<A, B, F, Out, Cfg>
+where
+    A: NewService<Cfg>,
+    B: NewService<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>;
+    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 Request = ();
+        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

@@ -1,165 +1,218 @@
-use std::marker::PhantomData;
+use futures::{try_ready, Async, Future, IntoFuture, Poll};
 
-use futures::{Async, Future, IntoFuture, Poll};
-
-use super::{IntoNewService, IntoService, NewService, Service};
+use super::{FnNewTransform, FnTransform};
+use super::{
+    IntoNewService, IntoNewTransform, IntoService, IntoTransform, NewService, NewTransform,
+    Service, Transform,
+};
 
 /// `Apply` service combinator
-pub struct Apply<T, F, In, Out, Request>
+pub struct Apply<T, S>
 where
-    T: Service<Request>,
+    T: Transform<S>,
+    T::Error: From<S::Error>,
+    S: Service,
 {
-    service: T,
-    f: F,
-    r: PhantomData<(In, Out, Request)>,
+    transform: T,
+    service: S,
 }
 
-impl<T, F, In, Out, Request> Apply<T, F, In, Out, Request>
+impl<T, S> Apply<T, S>
 where
-    T: Service<Request>,
-    F: Fn(In, &mut T) -> Out,
-    Out: IntoFuture,
+    T: Transform<S>,
+    T::Error: From<S::Error>,
+    S: Service,
 {
     /// Create new `Apply` combinator
-    pub fn new<I: IntoService<T, Request>>(service: I, f: F) -> Self {
+    pub fn new<T1: IntoTransform<T, S>, S1: IntoService<S>>(
+        transform: T1,
+        service: S1,
+    ) -> Self {
         Self {
+            transform: transform.into_transform(),
             service: service.into_service(),
-            f,
-            r: PhantomData,
         }
     }
 }
 
-impl<T, F, In, Out, Request> Clone for Apply<T, F, In, Out, Request>
+impl<F, S, Req, Out> Apply<FnTransform<F, S, Req, Out>, S>
 where
-    T: Service<Request> + Clone,
-    F: Clone,
+    F: FnMut(Req, &mut S) -> Out,
+    Out: IntoFuture,
+    Out::Error: From<S::Error>,
+    S: Service,
+{
+    /// Create new `Apply` combinator
+    pub fn new_fn<S1: IntoService<S>>(service: S1, transform: F) -> Self {
+        Self {
+            service: service.into_service(),
+            transform: transform.into_transform(),
+        }
+    }
+}
+
+impl<T, S> Clone for Apply<T, S>
+where
+    S: Service + Clone,
+    T::Error: From<S::Error>,
+    T: Transform<S> + Clone,
 {
     fn clone(&self) -> Self {
         Apply {
             service: self.service.clone(),
-            f: self.f.clone(),
-            r: PhantomData,
+            transform: self.transform.clone(),
         }
     }
 }
 
-impl<T, F, In, Out, Request> Service<In> for Apply<T, F, In, Out, Request>
+impl<T, S> Service for Apply<T, S>
 where
-    T: Service<Request, Error = Out::Error>,
-    F: Fn(In, &mut T) -> Out,
-    Out: IntoFuture,
+    T: Transform<S>,
+    T::Error: From<S::Error>,
+    S: Service,
 {
-    type Response = Out::Item;
-    type Error = Out::Error;
-    type Future = Out::Future;
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Future = T::Future;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready()
+        try_ready!(self.service.poll_ready());
+        self.transform.poll_ready()
     }
 
-    fn call(&mut self, req: In) -> Self::Future {
-        (self.f)(req, &mut self.service).into_future()
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        self.transform.call(req, &mut self.service).into_future()
     }
 }
 
 /// `ApplyNewService` new service combinator
-pub struct ApplyNewService<T, F, In, Out, Request>
+pub struct ApplyNewService<T, S, C>
 where
-    T: NewService<Request>,
+    T: NewTransform<S::Service, C, InitError = S::InitError>,
+    T::Error: From<S::Error>,
+    S: NewService<C>,
 {
-    service: T,
-    f: F,
-    r: PhantomData<(In, Out, Request)>,
+    transform: T,
+    service: S,
+    _t: std::marker::PhantomData<C>,
 }
 
-impl<T, F, In, Out, Request> ApplyNewService<T, F, In, Out, Request>
+impl<T, S, C> ApplyNewService<T, S, C>
 where
-    T: NewService<Request>,
-    F: Fn(In, &mut T::Service) -> Out,
-    Out: IntoFuture,
+    T: NewTransform<S::Service, C, InitError = S::InitError>,
+    T::Error: From<S::Error>,
+    S: NewService<C>,
 {
     /// Create new `ApplyNewService` new service instance
-    pub fn new<F1: IntoNewService<T, Request>>(service: F1, f: F) -> Self {
+    pub fn new<T1: IntoNewTransform<T, S::Service, C>, S1: IntoNewService<S, C>>(
+        transform: T1,
+        service: S1,
+    ) -> Self {
         Self {
-            f,
+            transform: transform.into_new_transform(),
             service: service.into_new_service(),
-            r: PhantomData,
+            _t: std::marker::PhantomData,
         }
     }
 }
 
-impl<T, F, In, Out, Request> Clone for ApplyNewService<T, F, In, Out, Request>
+impl<F, S, In, Out, Cfg>
+    ApplyNewService<FnNewTransform<F, S::Service, In, Out, S::InitError, Cfg>, S, Cfg>
 where
-    T: NewService<Request> + Clone,
-    F: Fn(Out, &mut T::Service) -> Out + Clone,
+    F: FnMut(In, &mut S::Service) -> Out + Clone,
     Out: IntoFuture,
+    Out::Error: From<S::Error>,
+    S: NewService<Cfg>,
+{
+    /// Create new `Apply` combinator factory
+    pub fn new_fn<S1: IntoNewService<S, Cfg>>(service: S1, transform: F) -> Self {
+        Self {
+            service: service.into_new_service(),
+            transform: FnNewTransform::new(transform),
+            _t: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<T, S, C> Clone for ApplyNewService<T, S, C>
+where
+    T: NewTransform<S::Service, C, InitError = S::InitError> + Clone,
+    T::Error: From<S::Error>,
+    S: NewService<C> + Clone,
 {
     fn clone(&self) -> Self {
         Self {
             service: self.service.clone(),
-            f: self.f.clone(),
-            r: PhantomData,
+            transform: self.transform.clone(),
+            _t: std::marker::PhantomData,
         }
     }
 }
 
-impl<T, F, In, Out, Request> NewService<In> for ApplyNewService<T, F, In, Out, Request>
+impl<T, S, C> NewService<C> for ApplyNewService<T, S, C>
 where
-    T: NewService<Request, Error = Out::Error>,
-    F: Fn(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
+    T: NewTransform<S::Service, C, InitError = S::InitError>,
+    T::Error: From<S::Error>,
+    S: NewService<C>,
 {
-    type Response = Out::Item;
-    type Error = Out::Error;
-    type Service = Apply<T::Service, F, In, Out, Request>;
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Service = Apply<T::Transform, S::Service>;
 
     type InitError = T::InitError;
-    type Future = ApplyNewServiceFuture<T, F, In, Out, Request>;
+    type Future = ApplyNewServiceFuture<T, S, C>;
 
-    fn new_service(&self) -> Self::Future {
-        ApplyNewServiceFuture::new(self.service.new_service(), self.f.clone())
-    }
-}
-
-pub struct ApplyNewServiceFuture<T, F, In, Out, Request>
-where
-    T: NewService<Request>,
-    F: Fn(In, &mut T::Service) -> Out,
-    Out: IntoFuture,
-{
-    fut: T::Future,
-    f: Option<F>,
-    r: PhantomData<(In, Out)>,
-}
-
-impl<T, F, In, Out, Request> ApplyNewServiceFuture<T, F, In, Out, Request>
-where
-    T: NewService<Request>,
-    F: Fn(In, &mut T::Service) -> Out,
-    Out: IntoFuture,
-{
-    fn new(fut: T::Future, f: F) -> Self {
+    fn new_service(&self, cfg: &C) -> Self::Future {
         ApplyNewServiceFuture {
-            f: Some(f),
-            fut,
-            r: PhantomData,
+            fut_t: self.transform.new_transform(cfg),
+            fut_s: self.service.new_service(cfg),
+            service: None,
+            transform: None,
         }
     }
 }
 
-impl<T, F, In, Out, Request> Future for ApplyNewServiceFuture<T, F, In, Out, Request>
+pub struct ApplyNewServiceFuture<T, S, C>
 where
-    T: NewService<Request>,
-    F: Fn(In, &mut T::Service) -> Out,
-    Out: IntoFuture,
+    T: NewTransform<S::Service, C, InitError = S::InitError>,
+    T::Error: From<S::Error>,
+    S: NewService<C>,
 {
-    type Item = Apply<T::Service, F, In, Out, Request>;
+    fut_s: S::Future,
+    fut_t: T::Future,
+    service: Option<S::Service>,
+    transform: Option<T::Transform>,
+}
+
+impl<T, S, C> Future for ApplyNewServiceFuture<T, S, C>
+where
+    T: NewTransform<S::Service, C, InitError = S::InitError>,
+    T::Error: From<S::Error>,
+    S: NewService<C>,
+{
+    type Item = Apply<T::Transform, S::Service>;
     type Error = T::InitError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Async::Ready(service) = self.fut.poll()? {
-            Ok(Async::Ready(Apply::new(service, self.f.take().unwrap())))
+        if self.transform.is_none() {
+            if let Async::Ready(transform) = self.fut_t.poll()? {
+                self.transform = Some(transform);
+            }
+        }
+
+        if self.service.is_none() {
+            if let Async::Ready(service) = self.fut_s.poll()? {
+                self.service = Some(service);
+            }
+        }
+
+        if self.transform.is_some() && self.service.is_some() {
+            Ok(Async::Ready(Apply {
+                service: self.service.take().unwrap(),
+                transform: self.transform.take().unwrap(),
+            }))
         } else {
             Ok(Async::NotReady)
         }
@@ -171,11 +224,13 @@ mod tests {
     use futures::future::{ok, FutureResult};
     use futures::{Async, Future, Poll};
 
-    use crate::{IntoNewService, IntoService, NewService, Service};
+    use super::*;
+    use crate::{NewService, Service};
 
     #[derive(Clone)]
     struct Srv;
-    impl Service<()> for Srv {
+    impl Service for Srv {
+        type Request = ();
         type Response = ();
         type Error = ();
         type Future = FutureResult<(), ()>;
@@ -190,10 +245,8 @@ mod tests {
     }
 
     #[test]
-    fn test_call() {
-        let blank = |req| Ok(req);
-
-        let mut srv = blank.into_service().apply(Srv, |req: &'static str, srv| {
+    fn test_apply() {
+        let mut srv = Apply::new_fn(Srv, |req: &'static str, srv| {
             srv.call(()).map(move |res| (req, res))
         });
         assert!(srv.poll_ready().is_ok());
@@ -204,13 +257,27 @@ mod tests {
 
     #[test]
     fn test_new_service() {
-        let blank = || Ok::<_, ()>((|req| Ok(req)).into_service());
+        let new_srv = ApplyNewService::new(
+            |req: &'static str, srv: &mut Srv| srv.call(()).map(move |res| (req, res)),
+            || Ok::<_, ()>(Srv),
+        );
+        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!()
+        }
+    }
 
-        let new_srv = blank.into_new_service().apply(
-            || Ok(Srv),
+    #[test]
+    fn test_new_service_fn() {
+        let new_srv = ApplyNewService::new_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() {
+        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,83 @@
+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 for Blank<R, E> {
+    type Request = R;
+    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<()> for BlankNewService<R, E1, E2> {
+    type Request = R;
+    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,136 @@
+use crate::{NewService, Service};
+use futures::{Future, Poll};
+
+pub type BoxedService<Req, Res, Err> = Box<
+    Service<
+        Request = Req,
+        Response = Res,
+        Error = Err,
+        Future = Box<Future<Item = Res, Error = Err>>,
+    >,
+>;
+
+/// Create boxed new service
+pub fn new_service<T, C>(
+    service: T,
+) -> BoxedNewService<C, T::Request, T::Response, T::Error, T::InitError>
+where
+    C: 'static,
+    T: NewService<C> + 'static,
+    T::Request: 'static,
+    T::Response: 'static,
+    T::Service: 'static,
+    T::Future: 'static,
+    T::Error: 'static,
+    T::InitError: 'static,
+{
+    BoxedNewService(Box::new(NewServiceWrapper {
+        service,
+        _t: std::marker::PhantomData,
+    }))
+}
+
+/// Create boxed service
+pub fn service<T>(service: T) -> BoxedService<T::Request, T::Response, T::Error>
+where
+    T: Service + 'static,
+    T::Future: 'static,
+{
+    Box::new(ServiceWrapper(service))
+}
+
+type Inner<C, Req, Res, Err, InitErr> = Box<
+    NewService<
+        C,
+        Request = Req,
+        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<C> for BoxedNewService<C, Req, Res, Err, InitErr>
+where
+    Req: 'static,
+    Res: 'static,
+    Err: 'static,
+    InitErr: 'static,
+{
+    type Request = Req;
+    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<C, T: NewService<C>> {
+    service: T,
+    _t: std::marker::PhantomData<C>,
+}
+
+impl<C, T, Req, Res, Err, InitErr> NewService<C> for NewServiceWrapper<C, T>
+where
+    Req: 'static,
+    Res: 'static,
+    Err: 'static,
+    InitErr: 'static,
+    T: NewService<C, Request = Req, Response = Res, Error = Err, InitError = InitErr>,
+    T::Future: 'static,
+    T::Service: 'static,
+    <T::Service as Service>::Future: 'static,
+{
+    type Request = Req;
+    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)
+                .map(|service| ServiceWrapper::boxed(service)),
+        )
+    }
+}
+
+struct ServiceWrapper<T: Service>(T);
+
+impl<T> ServiceWrapper<T>
+where
+    T: Service + 'static,
+    T::Future: 'static,
+{
+    fn boxed(service: T) -> BoxedService<T::Request, T::Response, T::Error> {
+        Box::new(ServiceWrapper(service))
+    }
+}
+
+impl<T, Req, Res, Err> Service for ServiceWrapper<T>
+where
+    T: Service<Request = Req, Response = Res, Error = Err>,
+    T::Future: 'static,
+{
+    type Request = Req;
+    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.0.poll_ready()
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        Box::new(self.0.call(req))
+    }
+}

actix-service/src/fn_service.rs

@@ -1,55 +1,80 @@
-use std::marker;
+use std::marker::PhantomData;
 
-use futures::{
-    future::{ok, FutureResult},
-    Async, IntoFuture, Poll,
-};
+use futures::future::{ok, FutureResult};
+use futures::{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: Fn(Req) -> Fut,
-    Fut: IntoFuture<Item = Resp, Error = E>,
+    F: FnMut(Req) -> Out + Clone,
+    Out: IntoFuture,
 {
-    f: F,
-    _t: marker::PhantomData<(Req, Resp, E)>,
+    FnNewService::new(f)
 }
 
-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>(f: F) -> FnNewServiceNoConfig<F, R, S, E>
 where
-    F: Fn(Req) -> Fut,
-    Fut: IntoFuture<Item = Resp, Error = E>,
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    FnNewServiceNoConfig::new(f)
+}
+
+/// Create `NewService` for function that can produce services with configuration
+pub fn fn_cfg_factory<F, C, R, S, E>(f: F) -> FnNewServiceConfig<F, C, R, S, E>
+where
+    F: Fn(&C) -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    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 {
-            f,
-            _t: marker::PhantomData,
-        }
+        FnService { f, _t: 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: Fn(Req) -> Fut + Clone,
-    Fut: IntoFuture<Item = Resp, Error = E>,
+    F: FnMut(Req) -> Out + Clone,
+    Out: IntoFuture,
 {
     fn clone(&self) -> Self {
         FnService {
             f: self.f.clone(),
-            _t: marker::PhantomData,
+            _t: PhantomData,
         }
     }
 }
 
-impl<F, Req, Resp, E, Fut> Service<Req> for FnService<F, Req, Resp, E, Fut>
+impl<F, Req, Out> Service for FnService<F, Req, Out>
 where
-    F: Fn(Req) -> Fut,
-    Fut: IntoFuture<Item = Resp, Error = E>,
+    F: FnMut(Req) -> Out,
+    Out: IntoFuture,
 {
-    type Response = Resp;
-    type Error = E;
-    type Future = Fut::Future;
+    type Request = Req;
+    type Response = Out::Item;
+    type Error = Out::Error;
+    type Future = Out::Future;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         Ok(Async::Ready(()))
@@ -60,70 +85,194 @@ where
     }
 }
 
-impl<F, Req, Resp, Err, Fut> IntoService<FnService<F, Req, Resp, Err, Fut>, Req> for F
+impl<F, Req, Out> IntoService<FnService<F, Req, Out>> for F
 where
-    F: Fn(Req) -> Fut + 'static,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    F: FnMut(Req) -> Out + 'static,
+    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: Fn(Req) -> Fut,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    F: FnMut(Req) -> Out,
+    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: Fn(Req) -> Fut + Clone,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    F: FnMut(Req) -> Out + Clone,
+    Out: IntoFuture,
 {
     pub fn new(f: F) -> Self {
-        FnNewService {
-            f,
-            _t: marker::PhantomData,
-        }
+        FnNewService { f, _t: PhantomData }
     }
 }
 
-impl<F, Req, Resp, Err, Fut> NewService<Req> for FnNewService<F, Req, Resp, Err, Fut>
+impl<F, Req, Out, Cfg> NewService<Cfg> for FnNewService<F, Req, Out, Cfg>
 where
-    F: Fn(Req) -> Fut + Clone,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    F: FnMut(Req) -> Out + Clone,
+    Out: IntoFuture,
 {
-    type Response = Resp;
-    type Error = Err;
-    type Service = FnService<F, Req, Resp, Err, Fut>;
+    type Request = Req;
+    type Response = Out::Item;
+    type Error = Out::Error;
+    type Service = FnService<F, Req, Out>;
+
     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>, Req> for F
+impl<F, Req, Out, Cfg> Clone for FnNewService<F, Req, Out, Cfg>
 where
-    F: Fn(Req) -> Fut + Clone + 'static,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
-{
-    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: Fn(Req) -> Fut + Clone,
-    Fut: IntoFuture<Item = Resp, Error = Err>,
+    F: FnMut(Req) -> Out + Clone,
+    Out: IntoFuture,
 {
     fn clone(&self) -> Self {
         Self::new(self.f.clone())
     }
 }
+
+impl<F, Req, Out, Cfg> IntoNewService<FnNewService<F, Req, Out, Cfg>, 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>
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    f: F,
+}
+
+impl<F, R, S, E> FnNewServiceNoConfig<F, R, S, E>
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    pub fn new(f: F) -> Self {
+        FnNewServiceNoConfig { f }
+    }
+}
+
+impl<F, R, S, E> NewService<()> for FnNewServiceNoConfig<F, R, S, E>
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    type Request = S::Request;
+    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> Clone for FnNewServiceNoConfig<F, R, S, E>
+where
+    F: Fn() -> R + Clone,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    fn clone(&self) -> Self {
+        Self::new(self.f.clone())
+    }
+}
+
+impl<F, R, S, E> IntoNewService<FnNewServiceNoConfig<F, R, S, E>, ()> for F
+where
+    F: Fn() -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    fn into_new_service(self) -> FnNewServiceNoConfig<F, R, S, E> {
+        FnNewServiceNoConfig::new(self)
+    }
+}
+
+/// Convert `Fn(&Config) -> Future<Service>` fn to NewService
+pub struct FnNewServiceConfig<F, C, R, S, E>
+where
+    F: Fn(&C) -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    f: F,
+    _t: PhantomData<(C, R, S, E)>,
+}
+
+impl<F, C, R, S, E> FnNewServiceConfig<F, C, R, S, E>
+where
+    F: Fn(&C) -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    pub fn new(f: F) -> Self {
+        FnNewServiceConfig { f, _t: PhantomData }
+    }
+}
+
+impl<F, C, R, S, E> NewService<C> for FnNewServiceConfig<F, C, R, S, E>
+where
+    F: Fn(&C) -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    type Request = S::Request;
+    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> Clone for FnNewServiceConfig<F, C, R, S, E>
+where
+    F: Fn(&C) -> R + Clone,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    fn clone(&self) -> Self {
+        Self::new(self.f.clone())
+    }
+}
+
+impl<F, C, R, S, E> IntoConfigurableNewService<FnNewServiceConfig<F, C, R, S, E>, C> for F
+where
+    F: Fn(&C) -> R,
+    R: IntoFuture<Item = S, Error = E>,
+    S: Service,
+{
+    fn into_new_service(self) -> FnNewServiceConfig<F, C, R, S, E> {
+        FnNewServiceConfig::new(self)
+    }
+}

actix-service/src/fn_transform.rs

@@ -0,0 +1,124 @@
+use std::marker::PhantomData;
+
+use futures::future::{ok, FutureResult};
+use futures::{Async, IntoFuture, Poll};
+
+use crate::{IntoNewTransform, IntoTransform, NewTransform, Transform};
+
+pub struct FnTransform<F, S, Req, Res>
+where
+    F: FnMut(Req, &mut S) -> Res,
+    Res: IntoFuture,
+{
+    f: F,
+    _t: PhantomData<(S, Req, Res)>,
+}
+
+impl<F, S, Req, Res> FnTransform<F, S, Req, Res>
+where
+    F: FnMut(Req, &mut S) -> Res,
+    Res: IntoFuture,
+{
+    pub fn new(f: F) -> Self {
+        FnTransform { f, _t: PhantomData }
+    }
+}
+
+impl<F, S, Req, Res> Clone for FnTransform<F, S, Req, Res>
+where
+    F: FnMut(Req, &mut S) -> Res + Clone,
+    Res: IntoFuture,
+{
+    fn clone(&self) -> Self {
+        FnTransform {
+            f: self.f.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<F, S, Req, Res> Transform<S> for FnTransform<F, S, Req, Res>
+where
+    F: FnMut(Req, &mut S) -> Res,
+    Res: IntoFuture,
+{
+    type Request = Req;
+    type Response = Res::Item;
+    type Error = Res::Error;
+    type Future = Res::Future;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, request: Req, service: &mut S) -> Self::Future {
+        (self.f)(request, service).into_future()
+    }
+}
+
+impl<F, S, Req, Res> IntoTransform<FnTransform<F, S, Req, Res>, S> for F
+where
+    F: FnMut(Req, &mut S) -> Res,
+    Res: IntoFuture,
+{
+    fn into_transform(self) -> FnTransform<F, S, Req, Res> {
+        FnTransform::new(self)
+    }
+}
+
+pub struct FnNewTransform<F, S, Req, Out, Err, Cfg>
+where
+    F: FnMut(Req, &mut S) -> Out + Clone,
+    Out: IntoFuture,
+{
+    f: F,
+    _t: PhantomData<(S, Req, Out, Err, Cfg)>,
+}
+
+impl<F, S, Req, Res, Err, Cfg> FnNewTransform<F, S, Req, Res, Err, Cfg>
+where
+    F: FnMut(Req, &mut S) -> Res + Clone,
+    Res: IntoFuture,
+{
+    pub fn new(f: F) -> Self {
+        FnNewTransform { f, _t: PhantomData }
+    }
+}
+
+impl<F, S, Req, Res, Err, Cfg> NewTransform<S, Cfg> for FnNewTransform<F, S, Req, Res, Err, Cfg>
+where
+    F: FnMut(Req, &mut S) -> Res + Clone,
+    Res: IntoFuture,
+{
+    type Request = Req;
+    type Response = Res::Item;
+    type Error = Res::Error;
+    type Transform = FnTransform<F, S, Req, Res>;
+    type InitError = Err;
+    type Future = FutureResult<Self::Transform, Self::InitError>;
+
+    fn new_transform(&self, _: &Cfg) -> Self::Future {
+        ok(FnTransform::new(self.f.clone()))
+    }
+}
+
+impl<F, S, Req, Res, Err, Cfg>
+    IntoNewTransform<FnNewTransform<F, S, Req, Res, Err, Cfg>, S, Cfg> for F
+where
+    F: FnMut(Req, &mut S) -> Res + Clone,
+    Res: IntoFuture,
+{
+    fn into_new_transform(self) -> FnNewTransform<F, S, Req, Res, Err, Cfg> {
+        FnNewTransform::new(self)
+    }
+}
+
+impl<F, S, Req, Res, Err, Cfg> Clone for FnNewTransform<F, S, Req, Res, Err, Cfg>
+where
+    F: FnMut(Req, &mut S) -> Res + Clone,
+    Res: IntoFuture,
+{
+    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<Request>(service: A) -> Self
+    pub(crate) fn new(service: A) -> Self
     where
-        A: Service<Request>,
+        A: Service,
         E: From<A::Error>,
     {
         FromErr {
@@ -37,20 +37,21 @@ where
     }
 }
 
-impl<A, E, Request> Service<Request> for FromErr<A, E>
+impl<A, E> Service for FromErr<A, E>
 where
-    A: Service<Request>,
+    A: Service,
     E: From<A::Error>,
 {
+    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
-    type Future = FromErrFuture<A, E, Request>;
+    type Future = FromErrFuture<A, E>;
 
     fn poll_ready(&mut self) -> Poll<(), E> {
-        Ok(self.service.poll_ready().map_err(E::from)?)
+        self.service.poll_ready().map_err(E::from)
     }
 
-    fn call(&mut self, req: Request) -> Self::Future {
+    fn call(&mut self, req: A::Request) -> Self::Future {
         FromErrFuture {
             fut: self.service.call(req),
             f: PhantomData,
@@ -58,14 +59,14 @@ where
     }
 }
 
-pub struct FromErrFuture<A: Service<Request>, E, Request> {
+pub struct FromErrFuture<A: Service, E> {
     fut: A::Future,
     f: PhantomData<E>,
 }
 
-impl<A, E, Request> Future for FromErrFuture<A, E, Request>
+impl<A, E> Future for FromErrFuture<A, E>
 where
-    A: Service<Request>,
+    A: Service,
     E: From<A::Error>,
 {
     type Item = A::Response;
@@ -80,23 +81,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<Request>(a: A) -> Self
+    pub fn new(a: A) -> Self
     where
-        A: NewService<Request>,
+        A: NewService<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,
 {
@@ -108,38 +109,39 @@ where
     }
 }
 
-impl<A, E, Request> NewService<Request> for FromErrNewService<A, E>
+impl<A, E, C> NewService<C> for FromErrNewService<A, E, C>
 where
-    A: NewService<Request>,
+    A: NewService<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, Request>;
+    type Future = FromErrNewServiceFuture<A, E, C>;
 
-    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, Request>
+pub struct FromErrNewServiceFuture<A, E, C>
 where
-    A: NewService<Request>,
+    A: NewService<C>,
     E: From<A::Error>,
 {
     fut: A::Future,
     e: PhantomData<E>,
 }
 
-impl<A, E, Request> Future for FromErrNewServiceFuture<A, E, Request>
+impl<A, E, C> Future for FromErrNewServiceFuture<A, E, C>
 where
-    A: NewService<Request>,
+    A: NewService<C>,
     E: From<A::Error>,
 {
     type Item = FromErr<A::Service, E>;
@@ -159,10 +161,11 @@ mod tests {
     use futures::future::{err, FutureResult};
 
     use super::*;
-    use crate::{IntoNewService, NewService, Service};
+    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<(), ()>;
@@ -205,7 +208,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,25 +1,46 @@
+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_err;
+mod transform_map_init_err;
 
 pub use self::and_then::{AndThen, AndThenNewService};
+use self::and_then_apply::{AndThenTransform, AndThenTransformNewService};
+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::{FnNewTransform, 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::{IntoNewTransform, IntoTransform, NewTransform, Transform};
 
 /// An asynchronous function from `Request` to a `Response`.
-pub trait Service<Request> {
+pub trait Service {
+    /// Requests handled by the service.
+    type Request;
+
     /// Responses given by the service.
     type Response;
 
@@ -49,23 +70,38 @@ pub trait Service<Request> {
     ///
     /// Calling `call` without calling `poll_ready` is permitted. The
     /// implementation must be resilient to this fact.
-    fn call(&mut self, req: Request) -> Self::Future;
+    fn call(&mut self, req: Self::Request) -> Self::Future;
+}
+
+/// An extension trait for `Service`s that provides a variety of convenient
+/// adapters
+pub trait ServiceExt: Service {
+    /// Apply tranformation to specified service and use it as a next service in
+    /// chain.
+    fn apply<T, T1, B, B1>(self, transform: T1, service: B1) -> AndThenTransform<T, Self, B>
+    where
+        Self: Sized,
+        T: Transform<B, Request = Self::Response>,
+        T::Error: From<Self::Error>,
+        T1: IntoTransform<T, B>,
+        B: Service<Error = Self::Error>,
+        B1: IntoService<B>,
+    {
+        AndThenTransform::new(transform.into_transform(), self, service.into_service())
+    }
 
     /// Apply function to specified service and use it as a next service in
     /// chain.
-    fn apply<T, I, F, Out, Req>(
-        self,
-        service: I,
-        f: F,
-    ) -> AndThen<Self, Apply<T, F, Self::Response, Out, Req>>
+    fn apply_fn<F, B, B1, Out>(self, service: B1, f: F) -> AndThenApply<Self, B, F, Out>
     where
         Self: Sized,
-        T: Service<Req, Error = Self::Error>,
-        I: IntoService<T, Req>,
-        F: Fn(Self::Response, &mut T) -> Out,
-        Out: IntoFuture<Error = Self::Error>,
+        F: FnMut(Self::Response, &mut B) -> Out,
+        Out: IntoFuture,
+        Out::Error: Into<Self::Error>,
+        B: Service<Error = Self::Error>,
+        B1: IntoService<B>,
     {
-        self.and_then(Apply::new(service.into_service(), f))
+        AndThenApply::new(self, service, f)
     }
 
     /// Call another service after call to this one has resolved successfully.
@@ -80,8 +116,8 @@ pub trait Service<Request> {
     fn and_then<F, B>(self, service: F) -> AndThen<Self, B>
     where
         Self: Sized,
-        F: IntoService<B, Self::Response>,
-        B: Service<Self::Response, Error = Self::Error>,
+        F: IntoService<B>,
+        B: Service<Request = Self::Response, Error = Self::Error>,
     {
         AndThen::new(self, service.into_service())
     }
@@ -107,7 +143,7 @@ pub trait Service<Request> {
     fn then<B>(self, service: B) -> Then<Self, B>
     where
         Self: Sized,
-        B: Service<Result<Self::Response, Self::Error>, Error = Self::Error>,
+        B: Service<Request = Result<Self::Response, Self::Error>, Error = Self::Error>,
     {
         Then::new(self, service)
     }
@@ -124,7 +160,7 @@ pub trait Service<Request> {
     fn map<F, R>(self, f: F) -> Map<Self, F, R>
     where
         Self: Sized,
-        F: Fn(Self::Response) -> R,
+        F: FnMut(Self::Response) -> R,
     {
         Map::new(self, f)
     }
@@ -146,6 +182,8 @@ pub trait Service<Request> {
     }
 }
 
+impl<T: ?Sized> ServiceExt for T where T: Service {}
+
 /// Creates new `Service` values.
 ///
 /// Acts as a service factory. This is useful for cases where new `Service`
@@ -154,8 +192,11 @@ pub trait Service<Request> {
 /// `NewService` trait, and uses that new `Service` value to process inbound
 /// requests on that new TCP stream.
 ///
-/// Request - request handled by the service
-pub trait NewService<Request> {
+/// `Config` is a service factory configuration type.
+pub trait NewService<Config = ()> {
+    /// Requests handled by the service.
+    type Request;
+
     /// Responses given by the service
     type Response;
 
@@ -163,7 +204,11 @@ pub trait NewService<Request> {
     type Error;
 
     /// The `Service` value created by this factory
-    type Service: Service<Request, Response = Self::Response, Error = Self::Error>;
+    type Service: Service<
+        Request = Self::Request,
+        Response = Self::Response,
+        Error = Self::Error,
+    >;
 
     /// Errors produced while building a service.
     type InitError;
@@ -172,31 +217,59 @@ pub trait NewService<Request> {
     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<T, I, F, Out, Req>(
+    fn apply<T, T1, B, B1>(
+        self,
+        transform: T1,
+        service: B1,
+    ) -> AndThenTransformNewService<T, Self, B, Config>
+    where
+        Self: Sized,
+        T: NewTransform<B::Service, Request = Self::Response, InitError = Self::InitError>,
+        T::Error: From<Self::Error>,
+        T1: IntoNewTransform<T, B::Service>,
+        B: NewService<Config, Error = Self::Error, InitError = Self::InitError>,
+        B1: IntoNewService<B, Config>,
+    {
+        AndThenTransformNewService::new(
+            transform.into_new_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>(
         self,
         service: I,
         f: F,
-    ) -> AndThenNewService<Self, ApplyNewService<T, F, Self::Response, Out, Req>>
+    ) -> AndThenApplyNewService<Self, B, F, Out, Config>
     where
         Self: Sized,
-        T: NewService<Req, InitError = Self::InitError, Error = Self::Error>,
-        I: IntoNewService<T, Req>,
-        F: Fn(Self::Response, &mut T::Service) -> Out + Clone,
-        Out: IntoFuture<Error = Self::Error>,
+        B: NewService<Config, Error = Self::Error, InitError = Self::InitError>,
+        I: IntoNewService<B, Config>,
+        F: FnMut(Self::Response, &mut B::Service) -> Out,
+        Out: IntoFuture,
+        Out::Error: Into<Self::Error>,
     {
-        self.and_then(ApplyNewService::new(service, f))
+        AndThenApplyNewService::new(self, service, f)
     }
 
     /// Call another service after call to this one has resolved successfully.
-    fn and_then<F, B>(self, new_service: F) -> AndThenNewService<Self, B>
+    fn and_then<F, B>(self, new_service: F) -> AndThenNewService<Self, B, Config>
     where
         Self: Sized,
-        F: IntoNewService<B, Self::Response>,
-        B: NewService<Self::Response, Error = Self::Error, InitError = Self::InitError>,
+        F: IntoNewService<B, Config>,
+        B: NewService<
+            Config,
+            Request = Self::Response,
+            Error = Self::Error,
+            InitError = Self::InitError,
+        >,
     {
         AndThenNewService::new(self, new_service)
     }
@@ -207,7 +280,7 @@ pub trait NewService<Request> {
     ///
     /// 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>,
@@ -221,12 +294,13 @@ pub trait NewService<Request> {
     ///
     /// 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, Result<Self::Response, Self::Error>>,
+        F: IntoNewService<B, Config>,
         B: NewService<
-            Result<Self::Response, Self::Error>,
+            Config,
+            Request = Result<Self::Response, Self::Error>,
             Error = Self::Error,
             InitError = Self::InitError,
         >,
@@ -236,16 +310,16 @@ pub trait NewService<Request> {
 
     /// 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: Fn(Self::Response) -> R,
+        F: FnMut(Self::Response) -> R,
     {
         MapNewService::new(self, f)
     }
 
     /// 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,
@@ -254,7 +328,7 @@ pub trait NewService<Request> {
     }
 
     /// 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,
@@ -263,10 +337,11 @@ pub trait NewService<Request> {
     }
 }
 
-impl<'a, S, Request> Service<Request> for &'a mut S
+impl<'a, S> Service for &'a mut S
 where
-    S: Service<Request> + 'a,
+    S: Service + 'a,
 {
+    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -275,15 +350,16 @@ where
         (**self).poll_ready()
     }
 
-    fn call(&mut self, request: Request) -> S::Future {
+    fn call(&mut self, request: Self::Request) -> S::Future {
         (**self).call(request)
     }
 }
 
-impl<S, Request> Service<Request> for Box<S>
+impl<S> Service for Box<S>
 where
-    S: Service<Request> + ?Sized,
+    S: Service + ?Sized,
 {
+    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -292,58 +368,91 @@ where
         (**self).poll_ready()
     }
 
-    fn call(&mut self, request: Request) -> S::Future {
+    fn call(&mut self, request: Self::Request) -> S::Future {
         (**self).call(request)
     }
 }
 
-impl<F, R, E, S, Request> NewService<Request> for F
+impl<S, C> NewService<C> for Rc<S>
 where
-    F: Fn() -> R,
-    R: IntoFuture<Item = S, Error = E>,
-    S: Service<Request>,
+    S: NewService<C>,
 {
+    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
-    type Service = S;
-    type InitError = E;
-    type Future = R::Future;
+    type Service = S::Service;
+    type InitError = S::InitError;
+    type Future = S::Future;
 
-    fn new_service(&self) -> Self::Future {
-        (*self)().into_future()
+    fn new_service(&self, cfg: &C) -> S::Future {
+        self.as_ref().new_service(cfg)
+    }
+}
+
+impl<S, C> NewService<C> for Arc<S>
+where
+    S: NewService<C>,
+{
+    type Request = S::Request;
+    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, Request>
+pub trait IntoService<T>
 where
-    T: Service<Request>,
+    T: Service,
 {
     /// Convert to a `Service`
     fn into_service(self) -> T;
 }
 
-/// Trait for types that can be converted to a Service
-pub trait IntoNewService<T, Request>
+/// Trait for types that can be converted to a `NewService`
+pub trait IntoNewService<T, C = ()>
 where
-    T: NewService<Request>,
+    T: NewService<C>,
 {
     /// Convert to an `NewService`
     fn into_new_service(self) -> T;
 }
 
-impl<T, Request> IntoService<T, Request> for T
+impl<T> IntoService<T> for T
 where
-    T: Service<Request>,
+    T: Service,
 {
     fn into_service(self) -> T {
         self
     }
 }
 
-impl<T, Request> IntoNewService<T, Request> for T
+impl<T, C> IntoNewService<T, C> for T
 where
-    T: NewService<Request>,
+    T: NewService<C>,
+{
+    fn into_new_service(self) -> T {
+        self
+    }
+}
+
+/// Trait for types that can be converted to a configurable `NewService`
+pub trait IntoConfigurableNewService<T, C>
+where
+    T: NewService<C>,
+{
+    /// Convert to an `NewService`
+    fn into_new_service(self) -> T;
+}
+
+impl<T, C> IntoConfigurableNewService<T, C> for T
+where
+    T: NewService<C>,
 {
     fn into_new_service(self) -> T {
         self

actix-service/src/map.rs

@@ -15,10 +15,10 @@ pub struct Map<A, F, Response> {
 
 impl<A, F, Response> Map<A, F, Response> {
     /// Create new `Map` combinator
-    pub fn new<Request>(service: A, f: F) -> Self
+    pub fn new(service: A, f: F) -> Self
     where
-        A: Service<Request>,
-        F: Fn(A::Response) -> Response,
+        A: Service,
+        F: FnMut(A::Response) -> Response,
     {
         Self {
             service,
@@ -42,47 +42,48 @@ where
     }
 }
 
-impl<A, F, Request, Response> Service<Request> for Map<A, F, Response>
+impl<A, F, Response> Service for Map<A, F, Response>
 where
-    A: Service<Request>,
-    F: Fn(A::Response) -> Response + Clone,
+    A: Service,
+    F: FnMut(A::Response) -> Response + Clone,
 {
+    type Request = A::Request;
     type Response = Response;
     type Error = A::Error;
-    type Future = MapFuture<A, F, Request, Response>;
+    type Future = MapFuture<A, F, Response>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready()
     }
 
-    fn call(&mut self, req: Request) -> Self::Future {
+    fn call(&mut self, req: A::Request) -> Self::Future {
         MapFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
-pub struct MapFuture<A, F, Request, Response>
+pub struct MapFuture<A, F, Response>
 where
-    A: Service<Request>,
-    F: Fn(A::Response) -> Response,
+    A: Service,
+    F: FnMut(A::Response) -> Response,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, Request, Response> MapFuture<A, F, Request, Response>
+impl<A, F, Response> MapFuture<A, F, Response>
 where
-    A: Service<Request>,
-    F: Fn(A::Response) -> Response,
+    A: Service,
+    F: FnMut(A::Response) -> Response,
 {
     fn new(fut: A::Future, f: F) -> Self {
         MapFuture { f, fut }
     }
 }
 
-impl<A, F, Request, Response> Future for MapFuture<A, F, Request, Response>
+impl<A, F, Response> Future for MapFuture<A, F, Response>
 where
-    A: Service<Request>,
-    F: Fn(A::Response) -> Response,
+    A: Service,
+    F: FnMut(A::Response) -> Response,
 {
     type Item = Response;
     type Error = A::Error;
@@ -96,18 +97,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<Request>(a: A, f: F) -> Self
+    pub fn new(a: A, f: F) -> Self
     where
-        A: NewService<Request>,
-        F: Fn(A::Response) -> Response,
+        A: NewService<Cfg>,
+        F: FnMut(A::Response) -> Res,
     {
         Self {
             a,
@@ -117,7 +118,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,
@@ -131,48 +132,49 @@ where
     }
 }
 
-impl<A, F, Request, Response> NewService<Request> for MapNewService<A, F, Response>
+impl<A, F, Res, Cfg> NewService<Cfg> for MapNewService<A, F, Res, Cfg>
 where
-    A: NewService<Request>,
-    F: Fn(A::Response) -> Response + Clone,
+    A: NewService<Cfg>,
+    F: FnMut(A::Response) -> Res + Clone,
 {
-    type Response = Response;
+    type Request = A::Request;
+    type Response = Res;
     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, Request, Response>;
+    type Future = MapNewServiceFuture<A, F, Res, Cfg>;
 
-    fn new_service(&self) -> Self::Future {
-        MapNewServiceFuture::new(self.a.new_service(), self.f.clone())
+    fn new_service(&self, cfg: &Cfg) -> Self::Future {
+        MapNewServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-pub struct MapNewServiceFuture<A, F, Request, Response>
+pub struct MapNewServiceFuture<A, F, Res, Cfg>
 where
-    A: NewService<Request>,
-    F: Fn(A::Response) -> Response,
+    A: NewService<Cfg>,
+    F: FnMut(A::Response) -> Res,
 {
     fut: A::Future,
     f: Option<F>,
 }
 
-impl<A, F, Request, Response> MapNewServiceFuture<A, F, Request, Response>
+impl<A, F, Res, Cfg> MapNewServiceFuture<A, F, Res, Cfg>
 where
-    A: NewService<Request>,
-    F: Fn(A::Response) -> Response,
+    A: NewService<Cfg>,
+    F: FnMut(A::Response) -> Res,
 {
     fn new(fut: A::Future, f: F) -> Self {
         MapNewServiceFuture { f: Some(f), fut }
     }
 }
 
-impl<A, F, Request, Response> Future for MapNewServiceFuture<A, F, Request, Response>
+impl<A, F, Res, Cfg> Future for MapNewServiceFuture<A, F, Res, Cfg>
 where
-    A: NewService<Request>,
-    F: Fn(A::Response) -> Response,
+    A: NewService<Cfg>,
+    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> {
@@ -189,10 +191,11 @@ mod tests {
     use futures::future::{ok, FutureResult};
 
     use super::*;
-    use crate::{IntoNewService, Service};
+    use crate::{IntoNewService, Service, ServiceExt};
 
     struct Srv;
-    impl Service<()> for Srv {
+    impl Service for Srv {
+        type Request = ();
         type Response = ();
         type Error = ();
         type Future = FutureResult<(), ()>;
@@ -226,7 +229,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<Request>(service: A, f: F) -> Self
+    pub fn new(service: A, f: F) -> Self
     where
-        A: Service<Request>,
+        A: Service,
         F: Fn(A::Error) -> E,
     {
         Self {
@@ -43,36 +43,37 @@ where
     }
 }
 
-impl<A, F, E, Request> Service<Request> for MapErr<A, F, E>
+impl<A, F, E> Service for MapErr<A, F, E>
 where
-    A: Service<Request>,
+    A: Service,
     F: Fn(A::Error) -> E + Clone,
 {
+    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
-    type Future = MapErrFuture<A, F, E, Request>;
+    type Future = MapErrFuture<A, F, E>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         self.service.poll_ready().map_err(&self.f)
     }
 
-    fn call(&mut self, req: Request) -> Self::Future {
+    fn call(&mut self, req: A::Request) -> Self::Future {
         MapErrFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
-pub struct MapErrFuture<A, F, E, Request>
+pub struct MapErrFuture<A, F, E>
 where
-    A: Service<Request>,
+    A: Service,
     F: Fn(A::Error) -> E,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, E, Request> MapErrFuture<A, F, E, Request>
+impl<A, F, E> MapErrFuture<A, F, E>
 where
-    A: Service<Request>,
+    A: Service,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -80,9 +81,9 @@ where
     }
 }
 
-impl<A, F, E, Request> Future for MapErrFuture<A, F, E, Request>
+impl<A, F, E> Future for MapErrFuture<A, F, E>
 where
-    A: Service<Request>,
+    A: Service,
     F: Fn(A::Error) -> E,
 {
     type Item = A::Response;
@@ -97,17 +98,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<Request>(a: A, f: F) -> Self
+    pub fn new(a: A, f: F) -> Self
     where
-        A: NewService<Request>,
+        A: NewService<C>,
         F: Fn(A::Error) -> E,
     {
         Self {
@@ -118,7 +119,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,
@@ -132,35 +133,36 @@ where
     }
 }
 
-impl<A, F, E, Request> NewService<Request> for MapErrNewService<A, F, E>
+impl<A, F, E, C> NewService<C> for MapErrNewService<A, F, E, C>
 where
-    A: NewService<Request>,
+    A: NewService<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, Request>;
+    type Future = MapErrNewServiceFuture<A, F, E, C>;
 
-    fn new_service(&self) -> Self::Future {
-        MapErrNewServiceFuture::new(self.a.new_service(), self.f.clone())
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        MapErrNewServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-pub struct MapErrNewServiceFuture<A, F, E, Request>
+pub struct MapErrNewServiceFuture<A, F, E, C>
 where
-    A: NewService<Request>,
+    A: NewService<C>,
     F: Fn(A::Error) -> E,
 {
     fut: A::Future,
     f: F,
 }
 
-impl<A, F, E, Request> MapErrNewServiceFuture<A, F, E, Request>
+impl<A, F, E, C> MapErrNewServiceFuture<A, F, E, C>
 where
-    A: NewService<Request>,
+    A: NewService<C>,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -168,9 +170,9 @@ where
     }
 }
 
-impl<A, F, E, Request> Future for MapErrNewServiceFuture<A, F, E, Request>
+impl<A, F, E, C> Future for MapErrNewServiceFuture<A, F, E, C>
 where
-    A: NewService<Request>,
+    A: NewService<C>,
     F: Fn(A::Error) -> E + Clone,
 {
     type Item = MapErr<A::Service, F, E>;
@@ -190,11 +192,12 @@ mod tests {
     use futures::future::{err, FutureResult};
 
     use super::*;
-    use crate::{IntoNewService, NewService, Service};
+    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<(), ()>;
@@ -228,7 +231,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<Request>(a: A, f: F) -> Self
+    pub fn new(a: A, f: F) -> Self
     where
-        A: NewService<Request>,
+        A: NewService<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,35 +40,36 @@ where
     }
 }
 
-impl<A, F, E, Request> NewService<Request> for MapInitErr<A, F, E>
+impl<A, F, E, C> NewService<C> for MapInitErr<A, F, E, C>
 where
-    A: NewService<Request>,
+    A: NewService<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, Request>;
+    type Future = MapInitErrFuture<A, F, E, C>;
 
-    fn new_service(&self) -> Self::Future {
-        MapInitErrFuture::new(self.a.new_service(), self.f.clone())
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        MapInitErrFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-pub struct MapInitErrFuture<A, F, E, Request>
+pub struct MapInitErrFuture<A, F, E, C>
 where
-    A: NewService<Request>,
+    A: NewService<C>,
     F: Fn(A::InitError) -> E,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, E, Request> MapInitErrFuture<A, F, E, Request>
+impl<A, F, E, C> MapInitErrFuture<A, F, E, C>
 where
-    A: NewService<Request>,
+    A: NewService<C>,
     F: Fn(A::InitError) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -76,9 +77,9 @@ where
     }
 }
 
-impl<A, F, E, Request> Future for MapInitErrFuture<A, F, E, Request>
+impl<A, F, E, C> Future for MapInitErrFuture<A, F, E, C>
 where
-    A: NewService<Request>,
+    A: NewService<C>,
     F: Fn(A::InitError) -> E,
 {
     type Item = A::Service;

actix-service/src/then.rs

@@ -1,3 +1,5 @@
+use std::marker::PhantomData;
+
 use futures::{try_ready, Async, Future, Poll};
 
 use super::{IntoNewService, NewService, Service};
@@ -14,10 +16,10 @@ pub struct Then<A, B> {
 
 impl<A, B> Then<A, B> {
     /// Create new `Then` combinator
-    pub fn new<Request>(a: A, b: B) -> Then<A, B>
+    pub fn new(a: A, b: B) -> Then<A, B>
     where
-        A: Service<Request>,
-        B: Service<Result<A::Response, A::Error>, Error = A::Error>,
+        A: Service,
+        B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
     {
         Then { a, b: Cell::new(b) }
     }
@@ -35,53 +37,54 @@ where
     }
 }
 
-impl<A, B, Request> Service<Request> for Then<A, B>
+impl<A, B> Service for Then<A, B>
 where
-    A: Service<Request>,
-    B: Service<Result<A::Response, A::Error>, Error = A::Error>,
+    A: Service,
+    B: Service<Request = 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, Request>;
+    type Future = ThenFuture<A, B>;
 
     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: Request) -> Self::Future {
+    fn call(&mut self, req: A::Request) -> Self::Future {
         ThenFuture::new(self.a.call(req), self.b.clone())
     }
 }
 
-pub struct ThenFuture<A, B, Request>
+pub struct ThenFuture<A, B>
 where
-    A: Service<Request>,
-    B: Service<Result<A::Response, A::Error>>,
+    A: Service,
+    B: Service<Request = Result<A::Response, A::Error>>,
 {
     b: Cell<B>,
     fut_b: Option<B::Future>,
-    fut_a: A::Future,
+    fut_a: Option<A::Future>,
 }
 
-impl<A, B, Request> ThenFuture<A, B, Request>
+impl<A, B> ThenFuture<A, B>
 where
-    A: Service<Request>,
-    B: Service<Result<A::Response, A::Error>>,
+    A: Service,
+    B: Service<Request = Result<A::Response, A::Error>>,
 {
-    fn new(fut_a: A::Future, b: Cell<B>) -> Self {
+    fn new(a: A::Future, b: Cell<B>) -> Self {
         ThenFuture {
             b,
-            fut_a,
+            fut_a: Some(a),
             fut_b: None,
         }
     }
 }
 
-impl<A, B, Request> Future for ThenFuture<A, B, Request>
+impl<A, B> Future for ThenFuture<A, B>
 where
-    A: Service<Request>,
-    B: Service<Result<A::Response, A::Error>>,
+    A: Service,
+    B: Service<Request = Result<A::Response, A::Error>>,
 {
     type Item = B::Response;
     type Error = B::Error;
@@ -91,12 +94,14 @@ where
             return fut.poll();
         }
 
-        match self.fut_a.poll() {
+        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(self.b.get_mut().call(Ok(resp)));
                 self.poll()
             }
             Err(err) => {
+                let _ = self.fut_a.take();
                 self.fut_b = Some(self.b.get_mut().call(Err(err)));
                 self.poll()
             }
@@ -106,48 +111,57 @@ 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, Request>(a: A, f: F) -> Self
+    pub fn new<F>(a: A, f: F) -> Self
     where
-        A: NewService<Request>,
+        A: NewService<C>,
         B: NewService<
-            Result<A::Response, A::Error>,
+            C,
+            Request = Result<A::Response, A::Error>,
             Error = A::Error,
             InitError = A::InitError,
         >,
-        F: IntoNewService<B, Result<A::Response, A::Error>>,
+        F: IntoNewService<B, C>,
     {
         Self {
             a,
             b: f.into_new_service(),
+            _t: PhantomData,
         }
     }
 }
 
-impl<A, B, Request> NewService<Request> for ThenNewService<A, B>
+impl<A, B, C> NewService<C> for ThenNewService<A, B, C>
 where
-    A: NewService<Request>,
-    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
+    A: NewService<C>,
+    B: NewService<
+        C,
+        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, Request>;
+    type Future = ThenNewServiceFuture<A, B, C>;
 
-    fn new_service(&self) -> Self::Future {
-        ThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        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,
@@ -156,14 +170,20 @@ where
         Self {
             a: self.a.clone(),
             b: self.b.clone(),
+            _t: PhantomData,
         }
     }
 }
 
-pub struct ThenNewServiceFuture<A, B, Request>
+pub struct ThenNewServiceFuture<A, B, C>
 where
-    A: NewService<Request>,
-    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
+    A: NewService<C>,
+    B: NewService<
+        C,
+        Request = Result<A::Response, A::Error>,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
     fut_b: B::Future,
     fut_a: A::Future,
@@ -171,10 +191,15 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B, Request> ThenNewServiceFuture<A, B, Request>
+impl<A, B, C> ThenNewServiceFuture<A, B, C>
 where
-    A: NewService<Request>,
-    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
+    A: NewService<C>,
+    B: NewService<
+        C,
+        Request = Result<A::Response, A::Error>,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
         ThenNewServiceFuture {
@@ -186,10 +211,15 @@ where
     }
 }
 
-impl<A, B, Request> Future for ThenNewServiceFuture<A, B, Request>
+impl<A, B, C> Future for ThenNewServiceFuture<A, B, C>
 where
-    A: NewService<Request>,
-    B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
+    A: NewService<C>,
+    B: NewService<
+        C,
+        Request = Result<A::Response, A::Error>,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
     type Item = Then<A::Service, B::Service>;
     type Error = A::InitError;
@@ -221,15 +251,16 @@ where
 #[cfg(test)]
 mod tests {
     use futures::future::{err, ok, FutureResult};
-    use futures::{Async, Poll};
+    use futures::{Async, Future, Poll};
     use std::cell::Cell;
     use std::rc::Rc;
 
-    use super::*;
+    use crate::{IntoNewService, NewService, Service, ServiceExt};
 
     #[derive(Clone)]
     struct Srv1(Rc<Cell<usize>>);
-    impl Service<Result<&'static str, &'static str>> for Srv1 {
+    impl Service for Srv1 {
+        type Request = Result<&'static str, &'static str>;
         type Response = &'static str;
         type Error = ();
         type Future = FutureResult<Self::Response, Self::Error>;
@@ -249,7 +280,8 @@ mod tests {
 
     struct Srv2(Rc<Cell<usize>>);
 
-    impl Service<Result<&'static str, ()>> for Srv2 {
+    impl Service for Srv2 {
+        type Request = Result<&'static str, ()>;
         type Response = (&'static str, &'static str);
         type Error = ();
         type Future = FutureResult<Self::Response, ()>;
@@ -297,7 +329,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,205 @@
+use std::rc::Rc;
+use std::sync::Arc;
+
+use futures::{Future, Poll};
+
+use crate::transform_map_err::{TransformMapErr, TransformMapErrNewTransform};
+use crate::transform_map_init_err::TransformMapInitErr;
+use crate::Service;
+
+/// An asynchronous function for transforming service call result.
+pub trait Transform<Service> {
+    /// Requests handled by the service.
+    type Request;
+
+    /// Responses given by the service.
+    type Response;
+
+    /// Errors produced by the service.
+    type Error;
+
+    /// The future response value.
+    type Future: Future<Item = Self::Response, Error = Self::Error>;
+
+    /// Returns `Ready` when the service is able to process requests.
+    ///
+    /// This method is similar to `Service::poll_ready` method.
+    fn poll_ready(&mut self) -> Poll<(), Self::Error>;
+
+    /// Process the request and apply it to provided service,
+    /// return the response asynchronously.
+    fn call(&mut self, request: Self::Request, service: &mut Service) -> Self::Future;
+
+    /// Map this transform's error to a different error, returning a new transform.
+    ///
+    /// This function is similar to the `Result::map_err` where it will change
+    /// the error type of the underlying transform. This is useful for example to
+    /// ensure that services and transforms have the same error type.
+    ///
+    /// Note that this function consumes the receiving transform and returns a
+    /// wrapped version of it.
+    fn map_err<F, E>(self, f: F) -> TransformMapErr<Self, Service, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::Error) -> E,
+    {
+        TransformMapErr::new(self, f)
+    }
+}
+
+/// `Transform` service factory
+///
+/// `Config` is a service factory configuration type.
+pub trait NewTransform<Service, Config = ()> {
+    /// Requests handled by the service.
+    type Request;
+
+    /// Responses given by the service.
+    type Response;
+
+    /// Errors produced by the service.
+    type Error;
+
+    /// The `TransformService` value created by this factory
+    type Transform: Transform<
+        Service,
+        Request = Self::Request,
+        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, cfg: &Config) -> Self::Future;
+
+    /// Map this transforms's output to a different type, returning a new transform
+    /// of the resulting type.
+    fn map_err<F, E>(self, f: F) -> TransformMapErrNewTransform<Self, Service, Config, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::Error) -> E,
+    {
+        TransformMapErrNewTransform::new(self, f)
+    }
+
+    /// 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, Service, Config, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::InitError) -> E,
+    {
+        TransformMapInitErr::new(self, f)
+    }
+}
+
+impl<'a, T, S> Transform<S> for &'a mut T
+where
+    T: Transform<S> + 'a,
+    S: Service<Error = T::Error>,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Future = T::Future;
+
+    fn poll_ready(&mut self) -> Poll<(), T::Error> {
+        (**self).poll_ready()
+    }
+
+    fn call(&mut self, request: Self::Request, service: &mut S) -> T::Future {
+        (**self).call(request, service)
+    }
+}
+
+impl<T, S> Transform<S> for Box<T>
+where
+    T: Transform<S> + ?Sized,
+    S: Service<Error = T::Error>,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Future = T::Future;
+
+    fn poll_ready(&mut self) -> Poll<(), S::Error> {
+        (**self).poll_ready()
+    }
+
+    fn call(&mut self, request: Self::Request, service: &mut S) -> T::Future {
+        (**self).call(request, service)
+    }
+}
+
+impl<S, C, T> NewTransform<S, C> for Rc<T>
+where
+    T: NewTransform<S, C>,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Transform = T::Transform;
+    type InitError = T::InitError;
+    type Future = T::Future;
+
+    fn new_transform(&self, cfg: &C) -> T::Future {
+        self.as_ref().new_transform(cfg)
+    }
+}
+
+impl<S, C, T> NewTransform<S, C> for Arc<T>
+where
+    T: NewTransform<S, C>,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Transform = T::Transform;
+    type InitError = T::InitError;
+    type Future = T::Future;
+
+    fn new_transform(&self, cfg: &C) -> T::Future {
+        self.as_ref().new_transform(cfg)
+    }
+}
+
+/// Trait for types that can be converted to a `TransformService`
+pub trait IntoTransform<T, S>
+where
+    T: Transform<S>,
+{
+    /// Convert to a `TransformService`
+    fn into_transform(self) -> T;
+}
+
+/// Trait for types that can be converted to a TransfromNewService
+pub trait IntoNewTransform<T, S, C = ()>
+where
+    T: NewTransform<S, C>,
+{
+    /// Convert to an `TranformNewService`
+    fn into_new_transform(self) -> T;
+}
+
+impl<T, S> IntoTransform<T, S> for T
+where
+    T: Transform<S>,
+{
+    fn into_transform(self) -> T {
+        self
+    }
+}
+
+impl<T, S, C> IntoNewTransform<T, S, C> for T
+where
+    T: NewTransform<S, C>,
+{
+    fn into_new_transform(self) -> T {
+        self
+    }
+}

actix-service/src/transform_map_err.rs

@@ -0,0 +1,188 @@
+use std::marker::PhantomData;
+
+use futures::{Async, Future, Poll};
+
+use super::{NewTransform, Transform};
+
+/// Service for the `map_err` combinator, changing the type of a transform's
+/// error.
+///
+/// This is created by the `Transform::map_err` method.
+pub struct TransformMapErr<T, S, F, E> {
+    transform: T,
+    f: F,
+    _t: PhantomData<(S, E)>,
+}
+
+impl<T, S, F, E> TransformMapErr<T, S, F, E> {
+    /// Create new `MapErr` combinator
+    pub fn new(transform: T, f: F) -> Self
+    where
+        T: Transform<S>,
+        F: Fn(T::Error) -> E,
+    {
+        Self {
+            transform,
+            f,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, S, F, E> Clone for TransformMapErr<T, S, F, E>
+where
+    T: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        TransformMapErr {
+            transform: self.transform.clone(),
+            f: self.f.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, S, F, E> Transform<S> for TransformMapErr<T, S, F, E>
+where
+    T: Transform<S>,
+    F: Fn(T::Error) -> E + Clone,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = E;
+    type Future = TransformMapErrFuture<T, S, F, E>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.transform.poll_ready().map_err(&self.f)
+    }
+
+    fn call(&mut self, req: T::Request, service: &mut S) -> Self::Future {
+        TransformMapErrFuture::new(self.transform.call(req, service), self.f.clone())
+    }
+}
+
+pub struct TransformMapErrFuture<T, S, F, E>
+where
+    T: Transform<S>,
+    F: Fn(T::Error) -> E,
+{
+    f: F,
+    fut: T::Future,
+}
+
+impl<T, S, F, E> TransformMapErrFuture<T, S, F, E>
+where
+    T: Transform<S>,
+    F: Fn(T::Error) -> E,
+{
+    fn new(fut: T::Future, f: F) -> Self {
+        TransformMapErrFuture { f, fut }
+    }
+}
+
+impl<T, S, F, E> Future for TransformMapErrFuture<T, S, F, E>
+where
+    T: Transform<S>,
+    F: Fn(T::Error) -> E,
+{
+    type Item = T::Response;
+    type Error = E;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        self.fut.poll().map_err(&self.f)
+    }
+}
+
+/// NewTransform for the `map_err` combinator, changing the type of a new
+/// transform's error.
+///
+/// This is created by the `NewTransform::map_err` method.
+pub struct TransformMapErrNewTransform<T, S, C, F, E> {
+    t: T,
+    f: F,
+    e: PhantomData<(S, C, E)>,
+}
+
+impl<T, S, C, F, E> TransformMapErrNewTransform<T, S, C, F, E> {
+    /// Create new `MapErr` new service instance
+    pub fn new(t: T, f: F) -> Self
+    where
+        T: NewTransform<S, C>,
+        F: Fn(T::Error) -> E,
+    {
+        Self {
+            t,
+            f,
+            e: PhantomData,
+        }
+    }
+}
+
+impl<T, S, C, F, E> Clone for TransformMapErrNewTransform<T, S, C, F, E>
+where
+    T: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            t: self.t.clone(),
+            f: self.f.clone(),
+            e: PhantomData,
+        }
+    }
+}
+
+impl<T, S, C, F, E> NewTransform<S, C> for TransformMapErrNewTransform<T, S, C, F, E>
+where
+    T: NewTransform<S, C>,
+    F: Fn(T::Error) -> E + Clone,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = E;
+    type Transform = TransformMapErr<T::Transform, S, F, E>;
+
+    type InitError = T::InitError;
+    type Future = TransformMapErrNewTransformFuture<T, S, C, F, E>;
+
+    fn new_transform(&self, cfg: &C) -> Self::Future {
+        TransformMapErrNewTransformFuture::new(self.t.new_transform(cfg), self.f.clone())
+    }
+}
+
+pub struct TransformMapErrNewTransformFuture<T, S, C, F, E>
+where
+    T: NewTransform<S, C>,
+    F: Fn(T::Error) -> E,
+{
+    fut: T::Future,
+    f: F,
+}
+
+impl<T, S, C, F, E> TransformMapErrNewTransformFuture<T, S, C, F, E>
+where
+    T: NewTransform<S, C>,
+    F: Fn(T::Error) -> E,
+{
+    fn new(fut: T::Future, f: F) -> Self {
+        TransformMapErrNewTransformFuture { f, fut }
+    }
+}
+
+impl<T, S, C, F, E> Future for TransformMapErrNewTransformFuture<T, S, C, F, E>
+where
+    T: NewTransform<S, C>,
+    F: Fn(T::Error) -> E + Clone,
+{
+    type Item = TransformMapErr<T::Transform, S, F, E>;
+    type Error = T::InitError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if let Async::Ready(tr) = self.fut.poll()? {
+            Ok(Async::Ready(TransformMapErr::new(tr, self.f.clone())))
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+}

actix-service/src/transform_map_init_err.rs

@@ -0,0 +1,94 @@
+use std::marker::PhantomData;
+
+use futures::{Future, Poll};
+
+use super::NewTransform;
+
+/// 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, C, F, E> {
+    t: T,
+    f: F,
+    e: PhantomData<(S, C, E)>,
+}
+
+impl<T, S, C, F, E> TransformMapInitErr<T, S, C, F, E> {
+    /// Create new `MapInitErr` new transform instance
+    pub fn new(t: T, f: F) -> Self
+    where
+        T: NewTransform<S, C>,
+        F: Fn(T::InitError) -> E,
+    {
+        Self {
+            t,
+            f,
+            e: PhantomData,
+        }
+    }
+}
+
+impl<T, S, C, F, E> Clone for TransformMapInitErr<T, S, C, F, E>
+where
+    T: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            t: self.t.clone(),
+            f: self.f.clone(),
+            e: PhantomData,
+        }
+    }
+}
+
+impl<T, S, C, F, E> NewTransform<S, C> for TransformMapInitErr<T, S, C, F, E>
+where
+    T: NewTransform<S, C>,
+    F: Fn(T::InitError) -> E + Clone,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Transform = T::Transform;
+
+    type InitError = E;
+    type Future = TransformMapInitErrFuture<T, S, C, F, E>;
+
+    fn new_transform(&self, cfg: &C) -> Self::Future {
+        TransformMapInitErrFuture::new(self.t.new_transform(cfg), self.f.clone())
+    }
+}
+
+pub struct TransformMapInitErrFuture<T, S, C, F, E>
+where
+    T: NewTransform<S, C>,
+    F: Fn(T::InitError) -> E,
+{
+    fut: T::Future,
+    f: F,
+}
+
+impl<T, S, C, F, E> TransformMapInitErrFuture<T, S, C, F, E>
+where
+    T: NewTransform<S, C>,
+    F: Fn(T::InitError) -> E,
+{
+    fn new(fut: T::Future, f: F) -> Self {
+        TransformMapInitErrFuture { f, fut }
+    }
+}
+
+impl<T, S, C, F, E> Future for TransformMapInitErrFuture<T, S, C, F, E>
+where
+    T: NewTransform<S, C>,
+    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(|e| (self.f)(e))
+    }
+}

actix-test-server/Cargo.toml

@@ -0,0 +1,58 @@
+[package]
+name = "actix-test-server"
+version = "0.1.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix test server"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-test-server/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+edition = "2018"
+workspace = "../"
+
+[package.metadata.docs.rs]
+features = ["ssl", "tls", "rust-tls"]
+
+[lib]
+name = "actix_test_server"
+path = "src/lib.rs"
+
+[features]
+default = []
+
+# tls
+tls = ["native-tls", "actix-server/tls"]
+
+# openssl
+ssl = ["openssl", "actix-server/ssl"]
+
+# rustls
+rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
+
+[dependencies]
+actix-rt = "0.1.0"
+#actix-server = "0.2.0"
+actix-server = { path="../actix-server" }
+
+log = "0.4"
+
+# io
+net2 = "0.2"
+futures = "0.1"
+tokio-tcp = "0.1"
+tokio-reactor = "0.1"
+
+# native-tls
+native-tls = { version="0.2", optional = true }
+
+# openssl
+openssl = { version="0.10", optional = true }
+
+#rustls
+rustls = { version = "^0.15", optional = true }
+tokio-rustls = { version = "^0.9", optional = true }
+webpki = { version = "0.19", optional = true }
+webpki-roots = { version = "0.16", optional = true }

actix-test-server/src/lib.rs

@@ -0,0 +1,142 @@
+//! Various helpers for Actix applications to use during testing.
+use std::sync::mpsc;
+use std::{net, thread};
+
+use actix_rt::{Runtime, System};
+use actix_server::{Server, StreamServiceFactory};
+
+use futures::Future;
+use net2::TcpBuilder;
+use tokio_reactor::Handle;
+use tokio_tcp::TcpStream;
+
+/// The `TestServer` type.
+///
+/// `TestServer` is very simple test server that simplify process of writing
+/// integration tests cases for actix applications.
+///
+/// # Examples
+///
+/// ```rust
+/// # extern crate actix_test_server;
+/// # use actix_web::*;
+/// #
+/// # fn my_handler(req: &HttpRequest) -> HttpResponse {
+/// #     HttpResponse::Ok().into()
+/// # }
+/// #
+/// # fn main() {
+/// use actix_test_server::TestServer;
+///
+/// let mut srv = TestServer::new(|app| app.handler(my_handler));
+///
+/// let req = srv.get().finish().unwrap();
+/// let response = srv.execute(req.send()).unwrap();
+/// assert!(response.status().is_success());
+/// # }
+/// ```
+pub struct TestServer;
+
+/// Test server runstime
+pub struct TestServerRuntime {
+    addr: net::SocketAddr,
+    host: String,
+    port: u16,
+    rt: Runtime,
+}
+
+impl TestServer {
+    /// Start new test server with application factory
+    pub fn with<F: StreamServiceFactory>(factory: F) -> TestServerRuntime {
+        let (tx, rx) = mpsc::channel();
+
+        // run server in separate thread
+        thread::spawn(move || {
+            let sys = System::new("actix-test-server");
+            let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
+            let local_addr = tcp.local_addr().unwrap();
+
+            Server::build()
+                .listen("test", tcp, factory)
+                .workers(1)
+                .disable_signals()
+                .start();
+
+            tx.send((System::current(), local_addr)).unwrap();
+            sys.run();
+        });
+
+        let (system, addr) = rx.recv().unwrap();
+        System::set_current(system);
+
+        let rt = Runtime::new().unwrap();
+        let host = format!("{}", addr.ip());
+        let port = addr.port();
+
+        TestServerRuntime {
+            addr,
+            rt,
+            host,
+            port,
+        }
+    }
+
+    /// Get firat available unused local address
+    pub fn unused_addr() -> net::SocketAddr {
+        let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
+        let socket = TcpBuilder::new_v4().unwrap();
+        socket.bind(&addr).unwrap();
+        socket.reuse_address(true).unwrap();
+        let tcp = socket.to_tcp_listener().unwrap();
+        tcp.local_addr().unwrap()
+    }
+}
+
+impl TestServerRuntime {
+    /// Execute future on current runtime
+    pub fn block_on<F, I, E>(&mut self, fut: F) -> Result<I, E>
+    where
+        F: Future<Item = I, Error = E>,
+    {
+        self.rt.block_on(fut)
+    }
+
+    /// Spawn future to the current runtime
+    pub fn spawn<F>(&mut self, fut: F)
+    where
+        F: Future<Item = (), Error = ()> + 'static,
+    {
+        self.rt.spawn(fut);
+    }
+
+    /// Test server host
+    pub fn host(&self) -> &str {
+        &self.host
+    }
+
+    /// Test server port
+    pub fn port(&self) -> u16 {
+        self.port
+    }
+
+    /// Get test server address
+    pub fn addr(&self) -> net::SocketAddr {
+        self.addr
+    }
+
+    /// Stop http server
+    fn stop(&mut self) {
+        System::current().stop();
+    }
+
+    /// Connect to server, return tokio TcpStream
+    pub fn connect(&self) -> std::io::Result<TcpStream> {
+        TcpStream::from_std(net::TcpStream::connect(self.addr)?, &Handle::default())
+    }
+}
+
+impl Drop for TestServerRuntime {
+    fn drop(&mut self) {
+        self.stop()
+    }
+}

actix-utils/CHANGES.md

@@ -1,5 +1,62 @@
 # Changes
 
+## [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
+
+* Added Clone impl for Either service
+
+* Added Clone impl for Timeout service factory
+
+* Added Service and NewService for Stream dispatcher
+
+* Switch to actix-service 0.2
+
+
 ## [0.1.0] - 2018-12-09
 
 * Move utils services to separate crate

actix-utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-utils"
-version = "0.1.0"
+version = "0.3.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix utils - various actix net related services"
 keywords = ["network", "framework", "async", "futures"]
@@ -11,18 +11,20 @@ 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.1"
+actix-service = "0.3.0"
 actix-codec = "0.1.0"
-actix-rt = "0.1.0"
-
-# io
 bytes = "0.4"
-futures = "0.1"
+futures = "0.1.24"
 tokio-timer = "0.2.8"
+tokio-current-thread = "0.1.4"
+log = "0.4"
+
+[dev-dependencies]
+actix-rt = "0.1"

actix-utils/src/cell.rs

@@ -1,17 +1,11 @@
 //! Custom cell impl
 
-#[cfg(feature = "cell")]
 use std::cell::UnsafeCell;
-#[cfg(not(feature = "cell"))]
-use std::cell::{Ref, RefCell, RefMut};
 use std::fmt;
 use std::rc::Rc;
 
 pub(crate) struct Cell<T> {
-    #[cfg(feature = "cell")]
     inner: Rc<UnsafeCell<T>>,
-    #[cfg(not(feature = "cell"))]
-    inner: Rc<RefCell<T>>,
 }
 
 impl<T> Clone for Cell<T> {
@@ -28,7 +22,6 @@ impl<T: fmt::Debug> fmt::Debug for Cell<T> {
     }
 }
 
-#[cfg(feature = "cell")]
 impl<T> Cell<T> {
     pub fn new(inner: T) -> Self {
         Self {
@@ -36,28 +29,11 @@ impl<T> Cell<T> {
         }
     }
 
-    pub fn borrow(&self) -> &T {
+    pub fn get_ref(&self) -> &T {
         unsafe { &*self.inner.as_ref().get() }
     }
 
-    pub fn borrow_mut(&self) -> &mut T {
+    pub fn get_mut(&mut self) -> &mut T {
         unsafe { &mut *self.inner.as_ref().get() }
     }
 }
-
-#[cfg(not(feature = "cell"))]
-impl<T> Cell<T> {
-    pub fn new(inner: T) -> Self {
-        Self {
-            inner: Rc::new(RefCell::new(inner)),
-        }
-    }
-
-    pub fn borrow(&self) -> Ref<T> {
-        self.inner.borrow()
-    }
-
-    pub fn borrow_mut(&self) -> RefMut<T> {
-        self.inner.borrow_mut()
-    }
-}

actix-utils/src/cloneable.rs

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

actix-utils/src/either.rs

@@ -12,11 +12,21 @@ pub enum EitherService<A, B> {
     B(B),
 }
 
-impl<A, B, Request> Service<Request> for EitherService<A, B>
+impl<A: Clone, B: Clone> Clone for EitherService<A, B> {
+    fn clone(&self) -> Self {
+        match self {
+            EitherService::A(srv) => EitherService::A(srv.clone()),
+            EitherService::B(srv) => EitherService::B(srv.clone()),
+        }
+    }
+}
+
+impl<A, B> Service for EitherService<A, B>
 where
-    A: Service<Request>,
-    B: Service<Request, Response = A::Response, Error = A::Error>,
+    A: Service,
+    B: Service<Request = A::Request, 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>;
@@ -28,7 +38,7 @@ where
         }
     }
 
-    fn call(&mut self, req: Request) -> Self::Future {
+    fn call(&mut self, req: A::Request) -> 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)),
@@ -42,35 +52,87 @@ pub enum Either<A, B> {
     B(B),
 }
 
-impl<A, B, Request> NewService<Request> for Either<A, B>
+impl<A, B> Either<A, B> {
+    pub fn new_a<C>(srv: A) -> Self
+    where
+        A: NewService<C>,
+        B: NewService<
+            C,
+            Request = A::Request,
+            Response = A::Response,
+            Error = A::Error,
+            InitError = A::InitError,
+        >,
+    {
+        Either::A(srv)
+    }
+
+    pub fn new_b<C>(srv: B) -> Self
+    where
+        A: NewService<C>,
+        B: NewService<
+            C,
+            Request = A::Request,
+            Response = A::Response,
+            Error = A::Error,
+            InitError = A::InitError,
+        >,
+    {
+        Either::B(srv)
+    }
+}
+
+impl<A, B, C> NewService<C> for Either<A, B>
 where
-    A: NewService<Request>,
-    B: NewService<Request, Response = A::Response, Error = A::Error, InitError = A::InitError>,
+    A: NewService<C>,
+    B: NewService<
+        C,
+        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, Request>;
+    type Future = EitherNewService<A, B, 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::B(ref inner) => EitherNewService::B(inner.new_service()),
+            Either::A(ref inner) => EitherNewService::A(inner.new_service(cfg)),
+            Either::B(ref inner) => EitherNewService::B(inner.new_service(cfg)),
+        }
+    }
+}
+
+impl<A: Clone, B: Clone> Clone for Either<A, B> {
+    fn clone(&self) -> Self {
+        match self {
+            Either::A(srv) => Either::A(srv.clone()),
+            Either::B(srv) => Either::B(srv.clone()),
         }
     }
 }
 
 #[doc(hidden)]
-pub enum EitherNewService<A: NewService<R>, B: NewService<R>, R> {
+pub enum EitherNewService<A: NewService<C>, B: NewService<C>, C> {
     A(A::Future),
     B(B::Future),
 }
 
-impl<A, B, Request> Future for EitherNewService<A, B, Request>
+impl<A, B, C> Future for EitherNewService<A, B, C>
 where
-    A: NewService<Request>,
-    B: NewService<Request, Response = A::Response, Error = A::Error, InitError = A::InitError>,
+    A: NewService<C>,
+    B: NewService<
+        C,
+        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

@@ -1,33 +1,37 @@
 //! Framed dispatcher service and related utilities
+use std::collections::VecDeque;
 use std::marker::PhantomData;
 use std::mem;
 
 use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
-use actix_rt::Arbiter;
 use actix_service::{IntoNewService, IntoService, NewService, Service};
 use futures::future::{ok, FutureResult};
-use futures::unsync::mpsc;
-use futures::{Async, AsyncSink, Future, Poll, Sink, Stream};
+use futures::task::AtomicTask;
+use futures::{Async, Future, Poll, Sink, Stream};
+use log::debug;
+
+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
+    C: Clone,
+    S: NewService<C, Request = Request<U>, Response = Response<U>>,
+    S::Error: 'static,
+    <S::Service as Service>::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request<U>, Response = Response<U>>,
-    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
-    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
-    <U as Encoder>::Error: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
 {
-    pub fn new<F1: IntoNewService<S, Request<U>>>(factory: F1) -> Self {
+    pub fn new<F1: IntoNewService<S, C>>(factory: F1) -> Self {
         Self {
             factory: factory.into_new_service(),
             _t: PhantomData,
@@ -35,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,
 {
@@ -47,60 +51,68 @@ where
     }
 }
 
-impl<S, T, U> NewService<Framed<T, U>> for FramedNewService<S, T, U>
+impl<S, T, U, C> NewService<C> for FramedNewService<S, T, U, C>
 where
+    C: Clone,
+    S: NewService<C, Request = Request<U>, Response = Response<U>> + Clone,
+    S::Error: 'static,
+    <S::Service as Service>::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request<U>, Response = Response<U>> + Clone,
-    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
-    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
-    <U as Encoder>::Error: '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<Framed<T, U>> for FramedService<S, T, U>
+impl<S, T, U, C> Service for FramedService<S, T, U, C>
 where
+    S: NewService<C, Request = Request<U>, Response = Response<U>>,
+    S::Error: 'static,
+    <S::Service as Service>::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request<U>, Response = Response<U>>,
-    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
-    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
-    <U as Encoder>::Error: '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(()))
@@ -108,37 +120,36 @@ 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<C, Request = Request<U>, Response = Response<U>>,
+    S::Error: 'static,
+    <S::Service as Service>::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request<U>, Response = Response<U>>,
-    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
-    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
-    <U as Encoder>::Error: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
 {
     fut: S::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<C, Request = Request<U>, Response = Response<U>>,
+    S::Error: 'static,
+    <S::Service as Service>::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: NewService<Request<U>, Response = Response<U>>,
-    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
-    <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
     <U as Encoder>::Item: 'static,
-    <U as Encoder>::Error: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
 {
     type Item = FramedTransport<S::Service, T, U>;
     type Error = S::InitError;
@@ -171,47 +182,143 @@ 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<U>, Response = Response<U>>,
+    S: Service<Request = Request<U>, Response = Response<U>>,
+    S::Error: 'static,
+    S::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Encoder + Decoder,
+    <U as Encoder>::Item: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
 {
     service: S,
     state: TransportState<S, U>,
     framed: Framed<T, U>,
-    request: Option<Request<U>>,
-    response: Option<Response<U>>,
-    write_rx: mpsc::Receiver<Result<Response<U>, S::Error>>,
-    write_tx: mpsc::Sender<Result<Response<U>, S::Error>>,
-    flushed: bool,
+    inner: Cell<FramedTransportInner<<U as Encoder>::Item, S::Error>>,
 }
 
-enum TransportState<S: Service<Request<U>>, U: Encoder + Decoder> {
+enum TransportState<S: Service, U: Encoder + Decoder> {
     Processing,
     Error(FramedTransportError<S::Error, U>),
-    EncoderError(FramedTransportError<S::Error, U>),
+    FramedError(FramedTransportError<S::Error, U>),
     Stopping,
 }
 
+struct FramedTransportInner<I, E> {
+    buf: VecDeque<Result<I, E>>,
+    task: AtomicTask,
+}
+
 impl<S, T, U> FramedTransport<S, T, U>
 where
+    S: Service<Request = Request<U>, Response = Response<U>>,
+    S::Error: 'static,
+    S::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: Service<Request<U>, Response = Response<U>>,
-    S::Future: 'static,
-    S::Error: 'static,
-    <U as Encoder>::Error: 'static,
+    <U as Encoder>::Item: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
 {
-    pub fn new<F: IntoService<S, Request<U>>>(framed: Framed<T, U>, service: F) -> Self {
-        let (write_tx, write_rx) = mpsc::channel(16);
+    fn poll_read(&mut self) -> bool {
+        loop {
+            match self.service.poll_ready() {
+                Ok(Async::Ready(_)) => loop {
+                    let item = match self.framed.poll() {
+                        Ok(Async::Ready(Some(el))) => el,
+                        Err(err) => {
+                            self.state =
+                                TransportState::FramedError(FramedTransportError::Decoder(err));
+                            return true;
+                        }
+                        Ok(Async::NotReady) => return false,
+                        Ok(Async::Ready(None)) => {
+                            self.state = TransportState::Stopping;
+                            return true;
+                        }
+                    };
+
+                    let mut cell = self.inner.clone();
+                    cell.get_mut().task.register();
+                    tokio_current_thread::spawn(self.service.call(item).then(move |item| {
+                        let inner = cell.get_mut();
+                        inner.buf.push_back(item);
+                        inner.task.notify();
+                        Ok(())
+                    }));
+                },
+                Ok(Async::NotReady) => return false,
+                Err(err) => {
+                    self.state = TransportState::Error(FramedTransportError::Service(err));
+                    return true;
+                }
+            }
+        }
+    }
+
+    /// write to framed object
+    fn poll_write(&mut self) -> bool {
+        let inner = self.inner.get_mut();
+        loop {
+            while !self.framed.is_write_buf_full() {
+                if let Some(msg) = inner.buf.pop_front() {
+                    match msg {
+                        Ok(msg) => {
+                            if let Err(err) = self.framed.force_send(msg) {
+                                self.state = TransportState::FramedError(
+                                    FramedTransportError::Encoder(err),
+                                );
+                                return true;
+                            }
+                        }
+                        Err(err) => {
+                            self.state =
+                                TransportState::Error(FramedTransportError::Service(err));
+                            return true;
+                        }
+                    }
+                } else {
+                    break;
+                }
+            }
+
+            if !self.framed.is_write_buf_empty() {
+                match self.framed.poll_complete() {
+                    Ok(Async::NotReady) => break,
+                    Err(err) => {
+                        debug!("Error sending data: {:?}", err);
+                        self.state =
+                            TransportState::FramedError(FramedTransportError::Encoder(err));
+                        return true;
+                    }
+                    Ok(Async::Ready(_)) => (),
+                }
+            } else {
+                break;
+            }
+        }
+
+        false
+    }
+}
+
+impl<S, T, U> FramedTransport<S, T, U>
+where
+    S: Service<Request = Request<U>, Response = Response<U>>,
+    S::Error: 'static,
+    S::Future: 'static,
+    T: AsyncRead + AsyncWrite,
+    U: Decoder + Encoder,
+    <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 {
         FramedTransport {
             framed,
-            write_rx,
-            write_tx,
             service: service.into_service(),
             state: TransportState::Processing,
-            request: None,
-            response: None,
-            flushed: true,
+            inner: Cell::new(FramedTransportInner {
+                buf: VecDeque::new(),
+                task: AtomicTask::new(),
+            }),
         }
     }
 
@@ -239,144 +346,15 @@ where
     }
 }
 
-impl<S, T, U> FramedTransport<S, T, U>
-where
-    T: AsyncRead + AsyncWrite,
-    U: Decoder + Encoder,
-    S: Service<Request<U>, Response = Response<U>>,
-    S::Future: 'static,
-    S::Error: 'static,
-    <U as Encoder>::Item: 'static,
-    <U as Encoder>::Error: 'static,
-{
-    fn poll_service(&mut self) -> bool {
-        match self.service.poll_ready() {
-            Ok(Async::Ready(_)) => {
-                if let Some(item) = self.request.take() {
-                    let sender = self.write_tx.clone();
-                    Arbiter::spawn(
-                        self.service
-                            .call(item)
-                            .then(|item| sender.send(item).map(|_| ()).map_err(|_| ())),
-                    );
-                }
-
-                loop {
-                    let item = match self.framed.poll() {
-                        Ok(Async::Ready(Some(el))) => el,
-                        Err(err) => {
-                            self.state =
-                                TransportState::Error(FramedTransportError::Decoder(err));
-                            return true;
-                        }
-                        Ok(Async::NotReady) => return false,
-                        Ok(Async::Ready(None)) => {
-                            self.state = TransportState::Stopping;
-                            return true;
-                        }
-                    };
-
-                    match self.service.poll_ready() {
-                        Ok(Async::Ready(_)) => {
-                            let sender = self.write_tx.clone();
-                            Arbiter::spawn(
-                                self.service
-                                    .call(item)
-                                    .then(|item| sender.send(item).map(|_| ()).map_err(|_| ())),
-                            );
-                        }
-                        Ok(Async::NotReady) => {
-                            self.request = Some(item);
-                            return false;
-                        }
-                        Err(err) => {
-                            self.state =
-                                TransportState::Error(FramedTransportError::Service(err));
-                            return true;
-                        }
-                    }
-                }
-            }
-            Ok(Async::NotReady) => false,
-            Err(err) => {
-                self.state = TransportState::Error(FramedTransportError::Service(err));
-                true
-            }
-        }
-    }
-
-    /// write to sink
-    fn poll_response(&mut self) -> bool {
-        let mut item = self.response.take();
-        loop {
-            item = if let Some(msg) = item {
-                self.flushed = false;
-                match self.framed.start_send(msg) {
-                    Ok(AsyncSink::Ready) => None,
-                    Ok(AsyncSink::NotReady(item)) => Some(item),
-                    Err(err) => {
-                        self.state =
-                            TransportState::EncoderError(FramedTransportError::Encoder(err));
-                        return true;
-                    }
-                }
-            } else {
-                None
-            };
-
-            // flush sink
-            if !self.flushed {
-                match self.framed.poll_complete() {
-                    Ok(Async::Ready(_)) => {
-                        self.flushed = true;
-                    }
-                    Ok(Async::NotReady) => break,
-                    Err(err) => {
-                        self.state =
-                            TransportState::EncoderError(FramedTransportError::Encoder(err));
-                        return true;
-                    }
-                }
-            }
-
-            // check channel
-            if self.flushed {
-                if item.is_none() {
-                    match self.write_rx.poll() {
-                        Ok(Async::Ready(Some(msg))) => match msg {
-                            Ok(msg) => item = Some(msg),
-                            Err(err) => {
-                                self.state =
-                                    TransportState::Error(FramedTransportError::Service(err));
-                                return true;
-                            }
-                        },
-                        Ok(Async::NotReady) => break,
-                        Err(_) => panic!("Bug in gw code"),
-                        Ok(Async::Ready(None)) => panic!("Bug in gw code"),
-                    }
-                } else {
-                    continue;
-                }
-            } else {
-                self.response = item;
-                break;
-            }
-        }
-
-        false
-    }
-}
-
 impl<S, T, U> Future for FramedTransport<S, T, U>
 where
+    S: Service<Request = Request<U>, Response = Response<U>>,
+    S::Error: 'static,
+    S::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
-    S: Service<Request<U>, Response = Response<U>>,
-    S::Future: 'static,
-    S::Error: 'static,
     <U as Encoder>::Item: 'static,
-    <U as Encoder>::Error: 'static,
+    <U as Encoder>::Error: std::fmt::Debug,
 {
     type Item = ();
     type Error = FramedTransportError<S::Error, U>;
@@ -384,21 +362,23 @@ where
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
         match mem::replace(&mut self.state, TransportState::Processing) {
             TransportState::Processing => {
-                if self.poll_service() || self.poll_response() {
+                if self.poll_read() || self.poll_write() {
                     self.poll()
                 } else {
                     Ok(Async::NotReady)
                 }
             }
             TransportState::Error(err) => {
-                if self.poll_response() || self.flushed {
+                if self.framed.is_write_buf_empty()
+                    || (self.poll_write() || self.framed.is_write_buf_empty())
+                {
                     Err(err)
                 } else {
                     self.state = TransportState::Error(err);
                     Ok(Async::NotReady)
                 }
             }
-            TransportState::EncoderError(err) => Err(err),
+            TransportState::FramedError(err) => Err(err),
             TransportState::Stopping => Ok(Async::Ready(())),
         }
     }
@@ -428,19 +408,20 @@ where
     }
 }
 
-impl<T, U, F> NewService<T> for IntoFramed<T, U, F>
+impl<T, U, F> NewService<()> 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,
@@ -458,12 +439,13 @@ where
     _t: PhantomData<(T,)>,
 }
 
-impl<T, U, F> Service<T> for IntoFramedService<T, U, F>
+impl<T, U, F> Service 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 futures::{try_ready, Async, Future, Poll};
+use actix_service::{NewTransform, Service, Transform, Void};
+use futures::future::{ok, FutureResult};
+use futures::{Async, Future, Poll};
 
 use super::counter::{Counter, CounterGuard};
 
@@ -7,127 +8,80 @@ use super::counter::{Counter, CounterGuard};
 /// async requests.
 ///
 /// Default number of in-flight requests is 15
-pub struct InFlight<T> {
-    factory: T,
+pub struct InFlight {
     max_inflight: usize,
 }
 
-impl<T> InFlight<T> {
-    pub fn new<F, Request>(factory: F) -> Self
-    where
-        T: NewService<Request>,
-        F: IntoNewService<T, Request>,
-    {
-        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 InFlight {
+    pub fn new(max: usize) -> Self {
+        Self { max_inflight: max }
     }
 }
 
-impl<T, Request> NewService<Request> for InFlight<T>
-where
-    T: NewService<Request>,
-{
+impl Default for InFlight {
+    fn default() -> Self {
+        Self::new(15)
+    }
+}
+
+impl<T: Service, C> NewTransform<T, C> for InFlight {
+    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, Request>;
+    type InitError = Void;
+    type Transform = InFlightService;
+    type Future = FutureResult<Self::Transform, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
-        InFlightResponseFuture {
-            fut: self.factory.new_service(),
-            max_inflight: self.max_inflight,
-        }
+    fn new_transform(&self, _: &C) -> Self::Future {
+        ok(InFlightService::new(self.max_inflight))
     }
 }
 
-pub struct InFlightResponseFuture<T: NewService<Request>, Request> {
-    fut: T::Future,
-    max_inflight: usize,
-}
-
-impl<T: NewService<Request>, Request> Future for InFlightResponseFuture<T, Request> {
-    type Item = InFlightService<T::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> {
-    service: T,
+pub struct InFlightService {
     count: Counter,
 }
 
-impl<T> InFlightService<T> {
-    pub fn new<F, Request>(service: F) -> Self
-    where
-        T: Service<Request>,
-        F: IntoService<T, Request>,
-    {
+impl InFlightService {
+    pub fn new(max: usize) -> Self {
         Self {
-            service: service.into_service(),
-            count: Counter::new(15),
-        }
-    }
-
-    pub fn with_max_inflight<F, Request>(max: usize, service: F) -> Self
-    where
-        T: Service<Request>,
-        F: IntoService<T, Request>,
-    {
-        Self {
-            service: service.into_service(),
             count: Counter::new(max),
         }
     }
 }
 
-impl<T, Request> Service<Request> for InFlightService<T>
+impl<T> Transform<T> for InFlightService
 where
-    T: Service<Request>,
+    T: Service,
 {
+    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
-    type Future = InFlightServiceResponse<T, Request>;
+    type Future = InFlightServiceResponse<T>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        let res = self.service.poll_ready();
-        if res.is_ok() && !self.count.available() {
-            return Ok(Async::NotReady);
+        if !self.count.available() {
+            log::trace!("InFlight limit exceeded");
+            Ok(Async::NotReady)
+        } else {
+            Ok(Async::Ready(()))
         }
-        res
     }
 
-    fn call(&mut self, req: Request) -> Self::Future {
+    fn call(&mut self, req: T::Request, service: &mut T) -> Self::Future {
         InFlightServiceResponse {
-            fut: self.service.call(req),
+            fut: service.call(req),
             _guard: self.count.get(),
         }
     }
 }
 
 #[doc(hidden)]
-pub struct InFlightServiceResponse<T: Service<Request>, Request> {
+pub struct InFlightServiceResponse<T: Service> {
     fut: T::Future,
     _guard: CounterGuard,
 }
 
-impl<T: Service<Request>, Request> Future for InFlightServiceResponse<T, Request> {
+impl<T: Service> Future for InFlightServiceResponse<T> {
     type Item = T::Response;
     type Error = T::Error;
 
@@ -135,3 +89,74 @@ impl<T: Service<Request>, Request> Future for InFlightServiceResponse<T, Request
         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 Request = ();
+        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().apply(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,17 +43,18 @@ where
     }
 }
 
-impl<R, E, F> NewService<R> for KeepAlive<R, E, F>
+impl<R, E, F> NewService<()> 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(),
@@ -89,10 +89,11 @@ where
     }
 }
 
-impl<R, E, F> Service<R> for KeepAliveService<R, E, F>
+impl<R, E, F> Service for KeepAliveService<R, E, F>
 where
     F: Fn() -> E,
 {
+    type Request = R;
     type Response = R;
     type Error = E;
     type Future = FutureResult<R, E>;
@@ -110,7 +111,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,284 @@
+use std::collections::VecDeque;
+use std::fmt;
+use std::marker::PhantomData;
+use std::rc::Rc;
+
+use actix_service::{NewTransform, 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>
+where
+    S: Service,
+    S::Response: 'static,
+    S::Future: 'static,
+    S::Error: 'static,
+{
+    pub fn new() -> Self {
+        Self { _t: PhantomData }
+    }
+
+    pub fn service() -> impl Transform<
+        S,
+        Request = S::Request,
+        Response = S::Response,
+        Error = InOrderError<S::Error>,
+    > {
+        InOrderService::new()
+    }
+}
+
+impl<S> Default for InOrder<S>
+where
+    S: Service,
+    S::Response: 'static,
+    S::Future: 'static,
+    S::Error: 'static,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<S, C> NewTransform<S, C> for InOrder<S>
+where
+    S: Service,
+    S::Response: 'static,
+    S::Future: 'static,
+    S::Error: 'static,
+{
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = InOrderError<S::Error>;
+    type InitError = Void;
+    type Transform = InOrderService<S>;
+    type Future = FutureResult<Self::Transform, Self::InitError>;
+
+    fn new_transform(&self, _: &C) -> Self::Future {
+        ok(InOrderService::new())
+    }
+}
+
+pub struct InOrderService<S: Service> {
+    task: Rc<AtomicTask>,
+    acks: VecDeque<Record<S::Response, S::Error>>,
+}
+
+impl<S> InOrderService<S>
+where
+    S: Service,
+    S::Response: 'static,
+    S::Future: 'static,
+    S::Error: 'static,
+{
+    pub fn new() -> Self {
+        Self {
+            acks: VecDeque::new(),
+            task: Rc::new(AtomicTask::new()),
+        }
+    }
+}
+
+impl<S> Default for InOrderService<S>
+where
+    S: Service,
+    S::Response: 'static,
+    S::Future: 'static,
+    S::Error: 'static,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<S> Transform<S> for InOrderService<S>
+where
+    S: Service,
+    S::Response: 'static,
+    S::Future: 'static,
+    S::Error: 'static,
+{
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = InOrderError<S::Error>;
+    type Future = InOrderServiceResponse<S>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.task.register();
+
+        // 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: S::Request, service: &mut S) -> 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(service.call(request).then(move |res| {
+            task.notify();
+            let _ = tx1.send(res);
+            Ok(())
+        }));
+
+        InOrderServiceResponse { rx: rx2 }
+    }
+}
+
+#[doc(hidden)]
+pub struct InOrderServiceResponse<S: Service> {
+    rx: oneshot::Receiver<Result<S::Response, S::Error>>,
+}
+
+impl<S: Service> Future for InOrderServiceResponse<S> {
+    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 for Srv {
+        type Request = oneshot::Receiver<usize>;
+        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> {
+        s: S,
+    }
+
+    impl<S: Service> 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().apply(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

@@ -1,35 +1,152 @@
 use std::marker::PhantomData;
+use std::rc::Rc;
 
-use actix_rt::spawn;
-use actix_service::{IntoService, NewService, Service};
+use actix_service::{IntoNewService, IntoService, NewService, Service};
+use futures::future::{ok, Future, FutureResult};
 use futures::unsync::mpsc;
-use futures::{future, Async, Future, Poll, Stream};
+use futures::{Async, Poll, Stream};
 
-pub struct StreamDispatcher<S: Stream, T> {
+type Request<T> = Result<<T as IntoStream>::Item, <T as IntoStream>::Error>;
+
+pub trait IntoStream {
+    type Item;
+    type Error;
+    type Stream: Stream<Item = Self::Item, Error = Self::Error>;
+
+    fn into_stream(self) -> Self::Stream;
+}
+
+impl<T> IntoStream for T
+where
+    T: Stream,
+{
+    type Item = T::Item;
+    type Error = T::Error;
+    type Stream = T;
+
+    fn into_stream(self) -> Self::Stream {
+        self
+    }
+}
+
+pub struct StreamNewService<S, T, E, C> {
+    factory: Rc<T>,
+    _t: PhantomData<(S, E, C)>,
+}
+
+impl<S, T, E, C> StreamNewService<S, T, E, C>
+where
+    C: Clone,
+    S: IntoStream,
+    T: NewService<C, Request = Request<S>, Response = (), Error = E, InitError = E>,
+    T::Future: 'static,
+    T::Service: 'static,
+    <T::Service as Service>::Future: 'static,
+{
+    pub fn new<F: IntoNewService<T, C>>(factory: F) -> Self {
+        Self {
+            factory: Rc::new(factory.into_new_service()),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<S, T, E, C> Clone for StreamNewService<S, T, E, C> {
+    fn clone(&self) -> Self {
+        Self {
+            factory: self.factory.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<S, T, E, C> NewService<C> for StreamNewService<S, T, E, C>
+where
+    C: Clone,
+    S: IntoStream + 'static,
+    T: NewService<C, Request = Request<S>, Response = (), Error = E, InitError = E>,
+    T::Future: 'static,
+    T::Service: 'static,
+    <T::Service as Service>::Future: 'static,
+{
+    type Request = S;
+    type Response = ();
+    type Error = E;
+    type InitError = E;
+    type Service = StreamService<S, T, E, C>;
+    type Future = FutureResult<Self::Service, E>;
+
+    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, C = ()> {
+    factory: Rc<T>,
+    config: C,
+    _t: PhantomData<(S, E)>,
+}
+
+impl<S, T, E, C> Service for StreamService<S, T, E, C>
+where
+    S: IntoStream + 'static,
+    T: NewService<C, Request = Request<S>, Response = (), Error = E, InitError = E>,
+    T::Future: 'static,
+    T::Service: 'static,
+    <T::Service as Service>::Future: 'static,
+    C: Clone,
+{
+    type Request = S;
+    type Response = ();
+    type Error = E;
+    type Future = Box<Future<Item = (), Error = E>>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, req: S) -> Self::Future {
+        Box::new(
+            self.factory
+                .new_service(&self.config)
+                .and_then(move |srv| StreamDispatcher::new(req, srv)),
+        )
+    }
+}
+
+pub struct StreamDispatcher<S, T>
+where
+    S: IntoStream + 'static,
+    T: Service<Request = Request<S>, Response = ()> + 'static,
+    T::Future: 'static,
+{
     stream: S,
     service: T,
-    item: Option<Result<S::Item, S::Error>>,
-    stop_rx: mpsc::UnboundedReceiver<()>,
-    stop_tx: mpsc::UnboundedSender<()>,
+    err_rx: mpsc::UnboundedReceiver<T::Error>,
+    err_tx: mpsc::UnboundedSender<T::Error>,
 }
 
 impl<S, T> StreamDispatcher<S, T>
 where
     S: Stream,
-    T: Service<Result<S::Item, S::Error>, Response = (), Error = ()>,
+    T: Service<Request = Request<S>, Response = ()>,
     T::Future: 'static,
 {
-    pub fn new<F>(stream: S, service: F) -> Self
+    pub fn new<F1, F2>(stream: F1, service: F2) -> Self
     where
-        F: IntoService<T, Result<S::Item, S::Error>>,
+        F1: IntoStream<Stream = S, Item = S::Item, Error = S::Error>,
+        F2: IntoService<T>,
     {
-        let (stop_tx, stop_rx) = mpsc::unbounded();
+        let (err_tx, err_rx) = mpsc::unbounded();
         StreamDispatcher {
-            stream,
-            item: None,
+            err_rx,
+            err_tx,
+            stream: stream.into_stream(),
             service: service.into_service(),
-            stop_rx,
-            stop_tx,
         }
     }
 }
@@ -37,36 +154,34 @@ where
 impl<S, T> Future for StreamDispatcher<S, T>
 where
     S: Stream,
-    T: Service<Result<S::Item, S::Error>, Response = (), Error = ()>,
+    T: Service<Request = Request<S>, Response = ()>,
     T::Future: 'static,
 {
     type Item = ();
-    type Error = ();
+    type Error = T::Error;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Ok(Async::Ready(Some(_))) = self.stop_rx.poll() {
-            return Ok(Async::Ready(()));
+        if let Ok(Async::Ready(Some(e))) = self.err_rx.poll() {
+            return Err(e);
         }
 
-        let mut item = self.item.take();
         loop {
-            if item.is_some() {
-                match self.service.poll_ready()? {
-                    Async::Ready(_) => spawn(StreamDispatcherService {
-                        fut: self.service.call(item.take().unwrap()),
-                        stop: self.stop_tx.clone(),
-                    }),
-                    Async::NotReady => {
-                        self.item = item;
-                        return Ok(Async::NotReady);
+            match self.service.poll_ready()? {
+                Async::Ready(_) => match self.stream.poll() {
+                    Ok(Async::Ready(Some(item))) => {
+                        tokio_current_thread::spawn(StreamDispatcherService {
+                            fut: self.service.call(Ok(item)),
+                            stop: self.err_tx.clone(),
+                        })
                     }
-                }
-            }
-            match self.stream.poll() {
-                Ok(Async::Ready(Some(el))) => item = Some(Ok(el)),
-                Err(err) => item = Some(Err(err)),
-                Ok(Async::NotReady) => return Ok(Async::NotReady),
-                Ok(Async::Ready(None)) => return Ok(Async::Ready(())),
+                    Err(err) => tokio_current_thread::spawn(StreamDispatcherService {
+                        fut: self.service.call(Err(err)),
+                        stop: self.err_tx.clone(),
+                    }),
+                    Ok(Async::NotReady) => return Ok(Async::NotReady),
+                    Ok(Async::Ready(None)) => return Ok(Async::Ready(())),
+                },
+                Async::NotReady => return Ok(Async::NotReady),
             }
         }
     }
@@ -74,7 +189,7 @@ where
 
 struct StreamDispatcherService<F: Future> {
     fut: F,
-    stop: mpsc::UnboundedSender<()>,
+    stop: mpsc::UnboundedSender<F::Error>,
 }
 
 impl<F: Future> Future for StreamDispatcherService<F> {
@@ -85,8 +200,8 @@ impl<F: Future> Future for StreamDispatcherService<F> {
         match self.fut.poll() {
             Ok(Async::Ready(_)) => Ok(Async::Ready(())),
             Ok(Async::NotReady) => Ok(Async::NotReady),
-            Err(_) => {
-                let _ = self.stop.unbounded_send(());
+            Err(e) => {
+                let _ = self.stop.unbounded_send(e);
                 Ok(Async::Ready(()))
             }
         }
@@ -117,15 +232,16 @@ impl<T> Clone for TakeItem<T> {
     }
 }
 
-impl<T: Stream> NewService<T> for TakeItem<T> {
+impl<T: Stream> NewService<()> for TakeItem<T> {
+    type Request = T;
     type Response = (Option<T::Item>, T);
     type Error = T::Error;
     type InitError = ();
     type Service = TakeItemService<T>;
-    type Future = future::FutureResult<Self::Service, Self::InitError>;
+    type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
-        future::ok(TakeItemService { _t: PhantomData })
+    fn new_service(&self, _: &()) -> Self::Future {
+        ok(TakeItemService { _t: PhantomData })
     }
 }
 
@@ -140,7 +256,8 @@ impl<T> Clone for TakeItemService<T> {
     }
 }
 
-impl<T: Stream> Service<T> for TakeItemService<T> {
+impl<T: Stream> Service 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,13 +1,11 @@
-use std::time::{Duration, Instant};
+use std::time::{self, Duration, Instant};
 
-use actix_rt::spawn;
-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>);
@@ -44,13 +42,14 @@ impl Default for LowResTime {
 }
 
 impl NewService<()> for LowResTime {
+    type Request = ();
     type Response = Instant;
-    type Error = Never;
-    type InitError = Never;
+    type Error = Void;
+    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())
     }
 }
@@ -66,30 +65,33 @@ impl LowResTimeService {
     /// Get current time. This function has to be called from
     /// future's poll method, otherwise it panics.
     pub fn now(&self) -> Instant {
-        let cur = self.0.borrow().current;
+        let cur = self.0.get_ref().current;
         if let Some(cur) = cur {
             cur
         } else {
             let now = Instant::now();
-            let inner = self.0.clone();
+            let mut inner = self.0.clone();
             let interval = {
-                let mut b = inner.borrow_mut();
+                let mut b = inner.get_mut();
                 b.current = Some(now);
                 b.resolution
             };
 
-            spawn(sleep(interval).map_err(|_| panic!()).and_then(move |_| {
-                inner.borrow_mut().current.take();
-                Ok(())
-            }));
+            tokio_current_thread::spawn(sleep(interval).map_err(|_| panic!()).and_then(
+                move |_| {
+                    inner.get_mut().current.take();
+                    Ok(())
+                },
+            ));
             now
         }
     }
 }
 
-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> {
@@ -100,3 +102,148 @@ impl Service<()> for LowResTimeService {
         ok(self.now())
     }
 }
+
+#[derive(Clone, Debug)]
+pub struct SystemTime(Cell<SystemTimeInner>);
+
+#[derive(Debug)]
+struct SystemTimeInner {
+    resolution: Duration,
+    current: Option<time::SystemTime>,
+}
+
+impl SystemTimeInner {
+    fn new(resolution: Duration) -> Self {
+        SystemTimeInner {
+            resolution,
+            current: None,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct SystemTimeService(Cell<SystemTimeInner>);
+
+impl SystemTimeService {
+    pub fn with(resolution: Duration) -> SystemTimeService {
+        SystemTimeService(Cell::new(SystemTimeInner::new(resolution)))
+    }
+
+    /// 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;
+        if let Some(cur) = cur {
+            cur
+        } else {
+            let now = time::SystemTime::now();
+            let mut inner = self.0.clone();
+            let interval = {
+                let mut b = inner.get_mut();
+                b.current = Some(now);
+                b.resolution
+            };
+
+            tokio_current_thread::spawn(sleep(interval).map_err(|_| panic!()).and_then(
+                move |_| {
+                    inner.get_mut().current.take();
+                    Ok(())
+                },
+            ));
+            now
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use futures::future;
+    use std::time::{Duration, SystemTime};
+
+    /// State Under Test: Two calls of `SystemTimeService::now()` return the same value if they are done within resolution interval of `SystemTimeService`.
+    ///
+    /// Expected Behavior: Two back-to-back calls of `SystemTimeService::now()` return the same value.
+    #[test]
+    fn system_time_service_time_does_not_immediately_change() {
+        let resolution = Duration::from_millis(50);
+
+        let _ = actix_rt::System::new("test").block_on(future::lazy(|| {
+            let time_service = SystemTimeService::with(resolution);
+
+            assert_eq!(time_service.now(), time_service.now());
+
+            Ok::<(), ()>(())
+        }));
+    }
+
+    /// State Under Test: Two calls of `LowResTimeService::now()` return the same value if they are done within resolution interval of `SystemTimeService`.
+    ///
+    /// Expected Behavior: Two back-to-back calls of `LowResTimeService::now()` return the same value.
+    #[test]
+    fn lowres_time_service_time_does_not_immediately_change() {
+        let resolution = Duration::from_millis(50);
+
+        let _ = actix_rt::System::new("test").block_on(future::lazy(|| {
+            let time_service = LowResTimeService::with(resolution);
+
+            assert_eq!(time_service.now(), time_service.now());
+
+            Ok::<(), ()>(())
+        }));
+    }
+
+    /// State Under Test: `SystemTimeService::now()` updates returned value every resolution period.
+    ///
+    /// Expected Behavior: Two calls of `LowResTimeService::now()` made in subsequent resolution interval return different values
+    /// and second value is greater than the first one at least by a resolution interval.
+    #[test]
+    fn system_time_service_time_updates_after_resolution_interval() {
+        let resolution = Duration::from_millis(100);
+        let wait_time = Duration::from_millis(150);
+
+        let _ = actix_rt::System::new("test").block_on(future::lazy(|| {
+            let time_service = SystemTimeService::with(resolution);
+
+            let first_time = time_service
+                .now()
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .unwrap();
+
+            sleep(wait_time).then(move |_| {
+                let second_time = time_service
+                    .now()
+                    .duration_since(SystemTime::UNIX_EPOCH)
+                    .unwrap();
+
+                assert!(second_time - first_time >= wait_time);
+
+                Ok::<(), ()>(())
+            })
+        }));
+    }
+
+    /// State Under Test: `LowResTimeService::now()` updates returned value every resolution period.
+    ///
+    /// Expected Behavior: Two calls of `LowResTimeService::now()` made in subsequent resolution interval return different values
+    /// and second value is greater than the first one at least by a resolution interval.
+    #[test]
+    fn lowres_time_service_time_updates_after_resolution_interval() {
+        let resolution = Duration::from_millis(100);
+        let wait_time = Duration::from_millis(150);
+
+        let _ = actix_rt::System::new("test").block_on(future::lazy(|| {
+            let time_service = LowResTimeService::with(resolution);
+
+            let first_time = time_service.now();
+
+            sleep(wait_time).then(move |_| {
+                let second_time = time_service.now();
+
+                assert!(second_time - first_time >= wait_time);
+
+                Ok::<(), ()>(())
+            })
+        }));
+    }
+}

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 futures::try_ready;
+use actix_service::{NewTransform, Service, Transform};
+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> {
-    inner: T,
+pub struct Timeout<E = ()> {
     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,93 +41,91 @@ impl<E: fmt::Debug> fmt::Debug for TimeoutError<E> {
     }
 }
 
-impl<T> Timeout<T> {
-    pub fn new<Request>(timeout: Duration, inner: T) -> Self
-    where
-        T: NewService<Request> + Clone,
-    {
-        Timeout { inner, timeout }
-    }
-}
-
-impl<T, Request> NewService<Request> for Timeout<T>
-where
-    T: NewService<Request> + Clone,
-{
-    type Response = T::Response;
-    type Error = TimeoutError<T::Error>;
-    type InitError = T::InitError;
-    type Service = TimeoutService<T::Service>;
-    type Future = TimeoutFut<T, Request>;
-
-    fn new_service(&self) -> Self::Future {
-        TimeoutFut {
-            fut: self.inner.new_service(),
-            timeout: self.timeout,
+impl<E: fmt::Display> fmt::Display for TimeoutError<E> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            TimeoutError::Service(e) => e.fmt(f),
+            TimeoutError::Timeout => write!(f, "Service call timeout"),
         }
     }
 }
 
-/// `Timeout` response future
-#[derive(Debug)]
-pub struct TimeoutFut<T: NewService<Request>, Request> {
-    fut: T::Future,
-    timeout: Duration,
+impl<E: PartialEq> PartialEq for TimeoutError<E> {
+    fn eq(&self, other: &TimeoutError<E>) -> bool {
+        match self {
+            TimeoutError::Service(e1) => match other {
+                TimeoutError::Service(e2) => e1 == e2,
+                TimeoutError::Timeout => false,
+            },
+            TimeoutError::Timeout => match other {
+                TimeoutError::Service(_) => false,
+                TimeoutError::Timeout => true,
+            },
+        }
+    }
 }
 
-impl<T, Request> Future for TimeoutFut<T, Request>
-where
-    T: NewService<Request>,
-{
-    type Item = TimeoutService<T::Service>;
-    type Error = T::InitError;
+impl<E> Timeout<E> {
+    pub fn new(timeout: Duration) -> Self {
+        Timeout {
+            timeout,
+            _t: PhantomData,
+        }
+    }
+}
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        let service = try_ready!(self.fut.poll());
-        Ok(Async::Ready(TimeoutService::new(self.timeout, service)))
+impl<E> Clone for Timeout<E> {
+    fn clone(&self) -> Self {
+        Timeout::new(self.timeout)
+    }
+}
+
+impl<S, C, E> NewTransform<S, C> for Timeout<E>
+where
+    S: Service,
+{
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = TimeoutError<S::Error>;
+    type InitError = E;
+    type Transform = TimeoutService;
+    type Future = FutureResult<Self::Transform, Self::InitError>;
+
+    fn new_transform(&self, _: &C) -> Self::Future {
+        ok(TimeoutService {
+            timeout: self.timeout,
+        })
     }
 }
 
 /// Applies a timeout to requests.
-#[derive(Debug)]
-pub struct TimeoutService<T> {
-    inner: T,
+#[derive(Debug, Clone)]
+pub struct TimeoutService {
     timeout: Duration,
 }
 
-impl<T> TimeoutService<T> {
-    pub fn new<Request>(timeout: Duration, inner: T) -> Self
-    where
-        T: Service<Request>,
-    {
-        TimeoutService { inner, timeout }
+impl TimeoutService {
+    pub fn new(timeout: Duration) -> Self {
+        TimeoutService { timeout }
     }
 }
 
-impl<T: Clone> Clone for TimeoutService<T> {
-    fn clone(&self) -> Self {
-        TimeoutService {
-            inner: self.inner.clone(),
-            timeout: self.timeout,
-        }
-    }
-}
-
-impl<T, Request> Service<Request> for TimeoutService<T>
+impl<S> Transform<S> for TimeoutService
 where
-    T: Service<Request>,
+    S: Service,
 {
-    type Response = T::Response;
-    type Error = TimeoutError<T::Error>;
-    type Future = TimeoutServiceResponse<T, Request>;
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = TimeoutError<S::Error>;
+    type Future = TimeoutServiceResponse<S>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.inner.poll_ready().map_err(TimeoutError::Service)
+        Ok(Async::Ready(()))
     }
 
-    fn call(&mut self, request: Request) -> Self::Future {
+    fn call(&mut self, request: S::Request, service: &mut S) -> Self::Future {
         TimeoutServiceResponse {
-            fut: self.inner.call(request),
+            fut: service.call(request),
             sleep: Delay::new(clock::now() + self.timeout),
         }
     }
@@ -128,14 +133,14 @@ where
 
 /// `TimeoutService` response future
 #[derive(Debug)]
-pub struct TimeoutServiceResponse<T: Service<Request>, Request> {
+pub struct TimeoutServiceResponse<T: Service> {
     fut: T::Future,
     sleep: Delay,
 }
 
-impl<T, Request> Future for TimeoutServiceResponse<T, Request>
+impl<T> Future for TimeoutServiceResponse<T>
 where
-    T: Service<Request>,
+    T: Service,
 {
     type Item = T::Response;
     type Error = TimeoutError<T::Error>;
@@ -156,3 +161,75 @@ 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 Request = ();
+        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()
+                .apply(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()
+                .apply(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/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "actix-router"
+version = "0.1.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Path router"
+keywords = ["actix"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://actix.rs/api/actix-net/stable/actix_router/"
+license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
+edition = "2018"
+workspace = "../"
+
+[lib]
+name = "actix_router"
+path = "src/lib.rs"
+
+[features]
+default = ["http"]
+
+[dependencies]
+bytes = "0.4"
+regex = "1.0"
+serde = "1.0.80"
+string = "0.1.3"
+http = { version="0.1.14", optional=true }
+
+[dev-dependencies]
+http = "0.1.14"
+serde_derive = "1.0"

router/src/de.rs

@@ -0,0 +1,709 @@
+use serde::de::{self, Deserializer, Error as DeError, Visitor};
+use serde::forward_to_deserialize_any;
+
+use crate::path::{Path, PathIter};
+use crate::ResourcePath;
+
+macro_rules! unsupported_type {
+    ($trait_fn:ident, $name:expr) => {
+        fn $trait_fn<V>(self, _: V) -> Result<V::Value, Self::Error>
+            where V: Visitor<'de>
+        {
+            Err(de::value::Error::custom(concat!("unsupported type: ", $name)))
+        }
+    };
+}
+
+macro_rules! parse_single_value {
+    ($trait_fn:ident, $visit_fn:ident, $tp:tt) => {
+        fn $trait_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+            where V: Visitor<'de>
+        {
+            if self.path.len() != 1 {
+                Err(de::value::Error::custom(
+                    format!("wrong number of parameters: {} expected 1",
+                            self.path.len()).as_str()))
+            } else {
+                let v = self.path[0].parse().map_err(
+                    |_| de::value::Error::custom(
+                        format!("can not parse {:?} to a {}", &self.path[0], $tp)))?;
+                visitor.$visit_fn(v)
+            }
+        }
+    }
+}
+
+pub struct PathDeserializer<'de, T: ResourcePath + 'de> {
+    path: &'de Path<T>,
+}
+
+impl<'de, T: ResourcePath + 'de> PathDeserializer<'de, T> {
+    pub fn new(path: &'de Path<T>) -> Self {
+        PathDeserializer { path }
+    }
+}
+
+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>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_map(ParamsDeserializer {
+            params: self.path.iter(),
+            current: None,
+        })
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        _: &'static str,
+        _: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_map(visitor)
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit_struct<V>(
+        self,
+        _: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_unit(visitor)
+    }
+
+    fn deserialize_newtype_struct<V>(
+        self,
+        _: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.path.len() < len {
+            Err(de::value::Error::custom(
+                format!(
+                    "wrong number of parameters: {} expected {}",
+                    self.path.len(),
+                    len
+                )
+                .as_str(),
+            ))
+        } else {
+            visitor.visit_seq(ParamsSeq {
+                params: self.path.iter(),
+            })
+        }
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self,
+        _: &'static str,
+        len: usize,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.path.len() < len {
+            Err(de::value::Error::custom(
+                format!(
+                    "wrong number of parameters: {} expected {}",
+                    self.path.len(),
+                    len
+                )
+                .as_str(),
+            ))
+        } else {
+            visitor.visit_seq(ParamsSeq {
+                params: self.path.iter(),
+            })
+        }
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        _: &'static str,
+        _: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.path.len() < 1 {
+            Err(de::value::Error::custom(
+                "expeceted at least one parameters",
+            ))
+        } else {
+            visitor.visit_enum(ValueEnum {
+                value: &self.path[0],
+            })
+        }
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        if self.path.len() != 1 {
+            Err(de::value::Error::custom(
+                format!("wrong number of parameters: {} expected 1", self.path.len()).as_str(),
+            ))
+        } else {
+            visitor.visit_str(&self.path[0])
+        }
+    }
+
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_seq(ParamsSeq {
+            params: self.path.iter(),
+        })
+    }
+
+    unsupported_type!(deserialize_any, "'any'");
+    unsupported_type!(deserialize_bytes, "bytes");
+    unsupported_type!(deserialize_option, "Option<T>");
+    unsupported_type!(deserialize_identifier, "identifier");
+    unsupported_type!(deserialize_ignored_any, "ignored_any");
+
+    parse_single_value!(deserialize_bool, visit_bool, "bool");
+    parse_single_value!(deserialize_i8, visit_i8, "i8");
+    parse_single_value!(deserialize_i16, visit_i16, "i16");
+    parse_single_value!(deserialize_i32, visit_i32, "i32");
+    parse_single_value!(deserialize_i64, visit_i64, "i64");
+    parse_single_value!(deserialize_u8, visit_u8, "u8");
+    parse_single_value!(deserialize_u16, visit_u16, "u16");
+    parse_single_value!(deserialize_u32, visit_u32, "u32");
+    parse_single_value!(deserialize_u64, visit_u64, "u64");
+    parse_single_value!(deserialize_f32, visit_f32, "f32");
+    parse_single_value!(deserialize_f64, visit_f64, "f64");
+    parse_single_value!(deserialize_string, visit_string, "String");
+    parse_single_value!(deserialize_byte_buf, visit_string, "String");
+    parse_single_value!(deserialize_char, visit_char, "char");
+}
+
+struct ParamsDeserializer<'de, T: ResourcePath> {
+    params: PathIter<'de, T>,
+    current: Option<(&'de str, &'de str)>,
+}
+
+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>
+    where
+        K: de::DeserializeSeed<'de>,
+    {
+        self.current = self.params.next().map(|ref item| (item.0, item.1));
+        match self.current {
+            Some((key, _)) => Ok(Some(seed.deserialize(Key { key })?)),
+            None => Ok(None),
+        }
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::DeserializeSeed<'de>,
+    {
+        if let Some((_, value)) = self.current.take() {
+            seed.deserialize(Value { value })
+        } else {
+            Err(de::value::Error::custom("unexpected item"))
+        }
+    }
+}
+
+struct Key<'de> {
+    key: &'de str,
+}
+
+impl<'de> Deserializer<'de> for Key<'de> {
+    type Error = de::value::Error;
+
+    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_str(self.key)
+    }
+
+    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("Unexpected"))
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
+            byte_buf option unit unit_struct newtype_struct seq tuple
+            tuple_struct map struct enum ignored_any
+    }
+}
+
+macro_rules! parse_value {
+    ($trait_fn:ident, $visit_fn:ident, $tp:tt) => {
+        fn $trait_fn<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+            where V: Visitor<'de>
+        {
+            let v = self.value.parse().map_err(
+                |_| de::value::Error::custom(
+                    format!("can not parse {:?} to a {}", self.value, $tp)))?;
+            visitor.$visit_fn(v)
+        }
+    }
+}
+
+struct Value<'de> {
+    value: &'de str,
+}
+
+impl<'de> Deserializer<'de> for Value<'de> {
+    type Error = de::value::Error;
+
+    parse_value!(deserialize_bool, visit_bool, "bool");
+    parse_value!(deserialize_i8, visit_i8, "i8");
+    parse_value!(deserialize_i16, visit_i16, "i16");
+    parse_value!(deserialize_i32, visit_i32, "i16");
+    parse_value!(deserialize_i64, visit_i64, "i64");
+    parse_value!(deserialize_u8, visit_u8, "u8");
+    parse_value!(deserialize_u16, visit_u16, "u16");
+    parse_value!(deserialize_u32, visit_u32, "u32");
+    parse_value!(deserialize_u64, visit_u64, "u64");
+    parse_value!(deserialize_f32, visit_f32, "f32");
+    parse_value!(deserialize_f64, visit_f64, "f64");
+    parse_value!(deserialize_string, visit_string, "String");
+    parse_value!(deserialize_byte_buf, visit_string, "String");
+    parse_value!(deserialize_char, visit_char, "char");
+
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_unit_struct<V>(
+        self,
+        _: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
+    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_borrowed_bytes(self.value.as_bytes())
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_borrowed_str(self.value)
+    }
+
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_some(self)
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        _: &'static str,
+        _: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_enum(ValueEnum { value: self.value })
+    }
+
+    fn deserialize_newtype_struct<V>(
+        self,
+        _: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_tuple<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("unsupported type: tuple"))
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        _: &'static str,
+        _: &'static [&'static str],
+        _: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("unsupported type: struct"))
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self,
+        _: &'static str,
+        _: usize,
+        _: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("unsupported type: tuple struct"))
+    }
+
+    unsupported_type!(deserialize_any, "any");
+    unsupported_type!(deserialize_seq, "seq");
+    unsupported_type!(deserialize_map, "map");
+    unsupported_type!(deserialize_identifier, "identifier");
+}
+
+struct ParamsSeq<'de, T: ResourcePath> {
+    params: PathIter<'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>
+    where
+        U: de::DeserializeSeed<'de>,
+    {
+        match self.params.next() {
+            Some(item) => Ok(Some(seed.deserialize(Value { value: item.1 })?)),
+            None => Ok(None),
+        }
+    }
+}
+
+struct ValueEnum<'de> {
+    value: &'de str,
+}
+
+impl<'de> de::EnumAccess<'de> for ValueEnum<'de> {
+    type Error = de::value::Error;
+    type Variant = UnitVariant;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
+    where
+        V: de::DeserializeSeed<'de>,
+    {
+        Ok((seed.deserialize(Key { key: self.value })?, UnitVariant))
+    }
+}
+
+struct UnitVariant;
+
+impl<'de> de::VariantAccess<'de> for UnitVariant {
+    type Error = de::value::Error;
+
+    fn unit_variant(self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+
+    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+
+    fn struct_variant<V>(
+        self,
+        _: &'static [&'static str],
+        _: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(de::value::Error::custom("not supported"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde::de;
+    use serde_derive::Deserialize;
+
+    use super::*;
+    use crate::path::Path;
+    use crate::router::Router;
+
+    #[derive(Deserialize)]
+    struct MyStruct {
+        key: String,
+        value: String,
+    }
+
+    #[derive(Deserialize)]
+    struct Id {
+        id: String,
+    }
+
+    #[derive(Debug, Deserialize)]
+    struct Test1(String, u32);
+
+    #[derive(Debug, Deserialize)]
+    struct Test2 {
+        key: String,
+        value: u32,
+    }
+
+    #[derive(Debug, Deserialize, PartialEq)]
+    #[serde(rename_all = "lowercase")]
+    enum TestEnum {
+        Val1,
+        Val2,
+    }
+
+    #[derive(Debug, Deserialize)]
+    struct Test3 {
+        val: TestEnum,
+    }
+
+    #[test]
+    fn test_request_extract() {
+        let mut router = Router::<()>::build();
+        router.path("/{key}/{value}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/name/user1/");
+        assert!(router.recognize(&mut path).is_some());
+
+        let s: MyStruct = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.key, "name");
+        assert_eq!(s.value, "user1");
+
+        let s: (String, String) =
+            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, "user1");
+
+        let mut router = Router::<()>::build();
+        router.path("/{key}/{value}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/name/32/");
+        assert!(router.recognize(&mut path).is_some());
+
+        let s: Test1 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, 32);
+
+        let s: Test2 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.key, "name");
+        assert_eq!(s.value, 32);
+
+        let s: (String, u8) =
+            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, 32);
+
+        let res: Vec<String> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(res[0], "name".to_owned());
+        assert_eq!(res[1], "32".to_owned());
+    }
+
+    #[test]
+    fn test_extract_path_single() {
+        let mut router = Router::<()>::build();
+        router.path("/{value}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/32/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: i8 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(i, 32);
+    }
+
+    #[test]
+    fn test_extract_enum() {
+        let mut router = Router::<()>::build();
+        router.path("/{val}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/val1/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: TestEnum = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(i, TestEnum::Val1);
+
+        let mut router = Router::<()>::build();
+        router.path("/{val1}/{val2}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/val1/val2/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: (TestEnum, TestEnum) =
+            de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(i, (TestEnum::Val1, TestEnum::Val2));
+    }
+
+    #[test]
+    fn test_extract_enum_value() {
+        let mut router = Router::<()>::build();
+        router.path("/{val}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/val1/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: Test3 = de::Deserialize::deserialize(PathDeserializer::new(&path)).unwrap();
+        assert_eq!(i.val, TestEnum::Val1);
+
+        let mut path = Path::new("/val3/");
+        assert!(router.recognize(&mut path).is_some());
+        let i: Result<Test3, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(i.is_err());
+        assert!(format!("{:?}", i).contains("unknown variant"));
+    }
+
+    #[test]
+    fn test_extract_errors() {
+        let mut router = Router::<()>::build();
+        router.path("/{value}/", ());
+        let router = router.finish();
+
+        let mut path = Path::new("/name/");
+        assert!(router.recognize(&mut path).is_some());
+
+        let s: Result<Test1, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("wrong number of parameters"));
+
+        let s: Result<Test2, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("can not parse"));
+
+        let s: Result<(String, String), de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("wrong number of parameters"));
+
+        let s: Result<u32, de::value::Error> =
+            de::Deserialize::deserialize(PathDeserializer::new(&path));
+        assert!(s.is_err());
+        assert!(format!("{:?}", s).contains("can not parse"));
+    }
+
+    // #[test]
+    // fn test_extract_path_decode() {
+    //     let mut router = Router::<()>::default();
+    //     router.register_resource(Resource::new(ResourceDef::new("/{value}/")));
+
+    //     macro_rules! test_single_value {
+    //         ($value:expr, $expected:expr) => {{
+    //             let req = TestRequest::with_uri($value).finish();
+    //             let info = router.recognize(&req, &(), 0);
+    //             let req = req.with_route_info(info);
+    //             assert_eq!(
+    //                 *Path::<String>::from_request(&req, &PathConfig::default()).unwrap(),
+    //                 $expected
+    //             );
+    //         }};
+    //     }
+
+    //     test_single_value!("/%25/", "%");
+    //     test_single_value!("/%40%C2%A3%24%25%5E%26%2B%3D/", "@£$%^&+=");
+    //     test_single_value!("/%2B/", "+");
+    //     test_single_value!("/%252B/", "%2B");
+    //     test_single_value!("/%2F/", "/");
+    //     test_single_value!("/%252F/", "%2F");
+    //     test_single_value!(
+    //         "/http%3A%2F%2Flocalhost%3A80%2Ffoo/",
+    //         "http://localhost:80/foo"
+    //     );
+    //     test_single_value!("/%2Fvar%2Flog%2Fsyslog/", "/var/log/syslog");
+    //     test_single_value!(
+    //         "/http%3A%2F%2Flocalhost%3A80%2Ffile%2F%252Fvar%252Flog%252Fsyslog/",
+    //         "http://localhost:80/file/%2Fvar%2Flog%2Fsyslog"
+    //     );
+
+    //     let req = TestRequest::with_uri("/%25/7/?id=test").finish();
+
+    //     let mut router = Router::<()>::default();
+    //     router.register_resource(Resource::new(ResourceDef::new("/{key}/{value}/")));
+    //     let info = router.recognize(&req, &(), 0);
+    //     let req = req.with_route_info(info);
+
+    //     let s = Path::<Test2>::from_request(&req, &PathConfig::default()).unwrap();
+    //     assert_eq!(s.key, "%");
+    //     assert_eq!(s.value, 7);
+
+    //     let s = Path::<(String, String)>::from_request(&req, &PathConfig::default()).unwrap();
+    //     assert_eq!(s.0, "%");
+    //     assert_eq!(s.1, "7");
+    // }
+
+    // #[test]
+    // fn test_extract_path_no_decode() {
+    //     let mut router = Router::<()>::default();
+    //     router.register_resource(Resource::new(ResourceDef::new("/{value}/")));
+
+    //     let req = TestRequest::with_uri("/%25/").finish();
+    //     let info = router.recognize(&req, &(), 0);
+    //     let req = req.with_route_info(info);
+    //     assert_eq!(
+    //         *Path::<String>::from_request(&req, &&PathConfig::default().disable_decoding())
+    //             .unwrap(),
+    //         "%25"
+    //     );
+    // }
+}

router/src/lib.rs

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

router/src/path.rs

@@ -0,0 +1,204 @@
+use std::ops::Index;
+use std::rc::Rc;
+
+use serde::de;
+
+use crate::de::PathDeserializer;
+use crate::ResourcePath;
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum PathItem {
+    Static(&'static str),
+    Segment(u16, u16),
+}
+
+/// Resource path match information
+///
+/// If resource path contains variable patterns, `Path` stores them.
+#[derive(Debug)]
+pub struct Path<T> {
+    path: T,
+    pub(crate) skip: u16,
+    pub(crate) segments: Vec<(Rc<String>, PathItem)>,
+}
+
+impl<T: Default> Default for Path<T> {
+    fn default() -> Self {
+        Path {
+            path: T::default(),
+            skip: 0,
+            segments: Vec::new(),
+        }
+    }
+}
+
+impl<T: Clone> Clone for Path<T> {
+    fn clone(&self) -> Self {
+        Path {
+            path: self.path.clone(),
+            skip: self.skip,
+            segments: self.segments.clone(),
+        }
+    }
+}
+
+impl<T: ResourcePath> Path<T> {
+    pub fn new(path: T) -> Path<T> {
+        Path {
+            path,
+            skip: 0,
+            segments: Vec::new(),
+        }
+    }
+
+    /// Get reference to inner path instance
+    pub fn get_ref(&self) -> &T {
+        &self.path
+    }
+
+    /// Get mutable reference to inner path instance
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.path
+    }
+
+    /// Path
+    pub fn path(&self) -> &str {
+        let skip = self.skip as usize;
+        let path = self.path.path();
+        if skip <= path.len() {
+            &path[skip..]
+        } else {
+            ""
+        }
+    }
+
+    /// Reset inner path
+    pub fn set(&mut self, path: T) {
+        self.skip = 0;
+        self.path = path;
+        self.segments.clear();
+    }
+
+    /// Skip first `n` chars in path
+    pub fn skip(&mut self, n: u16) {
+        self.skip = self.skip + n;
+    }
+
+    pub(crate) fn add(&mut self, name: Rc<String>, value: PathItem) {
+        match value {
+            PathItem::Static(s) => self.segments.push((name, PathItem::Static(s))),
+            PathItem::Segment(begin, end) => self
+                .segments
+                .push((name, PathItem::Segment(self.skip + begin, self.skip + end))),
+        }
+    }
+
+    #[doc(hidden)]
+    pub fn add_static(&mut self, name: &str, value: &'static str) {
+        self.segments
+            .push((Rc::new(name.to_string()), PathItem::Static(value)));
+    }
+
+    /// Check if there are any matched patterns
+    pub fn is_empty(&self) -> bool {
+        self.segments.is_empty()
+    }
+
+    /// Check number of extracted parameters
+    pub fn len(&self) -> usize {
+        self.segments.len()
+    }
+
+    /// Get matched parameter by name without type conversion
+    pub fn get(&self, key: &str) -> Option<&str> {
+        for item in self.segments.iter() {
+            if key == item.0.as_str() {
+                return match item.1 {
+                    PathItem::Static(ref s) => Some(&s),
+                    PathItem::Segment(s, e) => {
+                        Some(&self.path.path()[(s as usize)..(e as usize)])
+                    }
+                };
+            }
+        }
+        if key == "tail" {
+            Some(&self.path.path()[(self.skip as usize)..])
+        } else {
+            None
+        }
+    }
+
+    /// Get unprocessed part of the path
+    pub fn unprocessed(&self) -> &str {
+        &self.path.path()[(self.skip as usize)..]
+    }
+
+    /// Get matched parameter by name.
+    ///
+    /// If keyed parameter is not available empty string is used as default
+    /// value.
+    pub fn query(&self, key: &str) -> &str {
+        if let Some(s) = self.get(key) {
+            s
+        } else {
+            ""
+        }
+    }
+
+    /// Return iterator to items in parameter container
+    pub fn iter(&self) -> PathIter<T> {
+        PathIter {
+            idx: 0,
+            params: self,
+        }
+    }
+
+    /// Try to deserialize matching parameters to a specified type `U`
+    pub fn load<'de, U: serde::Deserialize<'de>>(&'de self) -> Result<U, de::value::Error> {
+        de::Deserialize::deserialize(PathDeserializer::new(self))
+    }
+}
+
+#[derive(Debug)]
+pub struct PathIter<'a, T> {
+    idx: usize,
+    params: &'a Path<T>,
+}
+
+impl<'a, T: ResourcePath> Iterator for PathIter<'a, T> {
+    type Item = (&'a str, &'a str);
+
+    #[inline]
+    fn next(&mut self) -> Option<(&'a str, &'a str)> {
+        if self.idx < self.params.len() {
+            let idx = self.idx;
+            let res = match self.params.segments[idx].1 {
+                PathItem::Static(ref s) => &s,
+                PathItem::Segment(s, e) => &self.params.path.path()[(s as usize)..(e as usize)],
+            };
+            self.idx += 1;
+            return Some((&self.params.segments[idx].0, res));
+        }
+        None
+    }
+}
+
+impl<'a, T: ResourcePath> Index<&'a str> for Path<T> {
+    type Output = str;
+
+    fn index(&self, name: &'a str) -> &str {
+        self.get(name)
+            .expect("Value for parameter is not available")
+    }
+}
+
+impl<T: ResourcePath> Index<usize> for Path<T> {
+    type Output = str;
+
+    fn index(&self, idx: usize) -> &str {
+        match self.segments[idx].1 {
+            PathItem::Static(ref s) => &s,
+            PathItem::Segment(s, e) => &self.path.path()[(s as usize)..(e as usize)],
+        }
+    }
+}

router/src/resource.rs

@@ -0,0 +1,430 @@
+use std::cmp::min;
+use std::hash::{Hash, Hasher};
+use std::rc::Rc;
+
+use regex::{escape, Regex};
+
+use crate::path::{Path, PathItem};
+use crate::ResourcePath;
+
+const MAX_DYNAMIC_SEGMENTS: usize = 16;
+
+/// ResourceDef describes an entry in resources table
+///
+/// Resource definition can contain only 16 dynamic segments
+#[derive(Clone, Debug)]
+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),
+    Var(String),
+}
+
+#[derive(Clone, Debug)]
+enum PatternType {
+    Static(String),
+    Prefix(String),
+    Dynamic(Regex, Vec<Rc<String>>, usize),
+}
+
+impl ResourceDef {
+    /// Parse path pattern and create new `Pattern` instance.
+    ///
+    /// Panics if path pattern is wrong.
+    pub fn new(path: &str) -> Self {
+        ResourceDef::with_prefix(path, false)
+    }
+
+    /// Parse path pattern and create new `Pattern` instance.
+    ///
+    /// Use `prefix` type instead of `static`.
+    ///
+    /// Panics if path regex pattern is wrong.
+    pub fn prefix(path: &str) -> Self {
+        ResourceDef::with_prefix(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) = ResourceDef::parse(&path, for_prefix);
+
+        let tp = if is_dynamic {
+            let re = match Regex::new(&pattern) {
+                Ok(re) => re,
+                Err(err) => panic!("Wrong path pattern: \"{}\" {}", path, err),
+            };
+            // actix creates one router per thread
+            let names = re
+                .capture_names()
+                .filter_map(|name| name.map(|name| Rc::new(name.to_owned())))
+                .collect();
+            PatternType::Dynamic(re, names, len)
+        } else if for_prefix {
+            PatternType::Prefix(pattern.clone())
+        } else {
+            PatternType::Static(pattern.clone())
+        };
+
+        ResourceDef {
+            tp,
+            elements,
+            name: String::new(),
+            rtp: ResourceType::Normal,
+            pattern: path.to_owned(),
+        }
+    }
+
+    /// Path pattern of the resource
+    pub fn pattern(&self) -> &str {
+        &self.pattern
+    }
+
+    /// Check if path matchs this pattern?
+    pub fn is_match(&self, path: &str) -> bool {
+        match self.tp {
+            PatternType::Static(ref s) => s == path,
+            PatternType::Dynamic(ref re, _, _) => re.is_match(path),
+            PatternType::Prefix(ref s) => path.starts_with(s),
+        }
+    }
+
+    /// Is the given path and parameters a match against this pattern?
+    pub fn match_path<T: ResourcePath>(&self, path: &mut Path<T>) -> bool {
+        match self.tp {
+            PatternType::Static(ref s) => {
+                if s == path.path() {
+                    path.skip(path.len() as u16);
+                    true
+                } else {
+                    false
+                }
+            }
+            PatternType::Dynamic(ref re, ref names, len) => {
+                let mut idx = 0;
+                let mut pos = 0;
+                let mut segments: [PathItem; MAX_DYNAMIC_SEGMENTS] =
+                    [PathItem::Static(""); MAX_DYNAMIC_SEGMENTS];
+
+                if let Some(captures) = re.captures(path.path()) {
+                    let mut passed = false;
+
+                    for capture in captures.iter() {
+                        if let Some(ref m) = capture {
+                            if !passed {
+                                passed = true;
+                                continue;
+                            }
+
+                            segments[idx] = PathItem::Segment(m.start() as u16, m.end() as u16);
+                            idx += 1;
+                            pos = m.end();
+                        }
+                    }
+                } else {
+                    return false;
+                }
+                for idx in 0..idx {
+                    path.add(names[idx].clone(), segments[idx]);
+                }
+                path.skip((pos + len) as u16);
+                true
+            }
+            PatternType::Prefix(ref s) => {
+                let rpath = path.path();
+                let len = if s == rpath {
+                    s.len()
+                } else if rpath.starts_with(s)
+                    && (s.ends_with('/') || rpath.split_at(s.len()).1.starts_with('/'))
+                {
+                    if s.ends_with('/') {
+                        s.len() - 1
+                    } else {
+                        s.len()
+                    }
+                } else {
+                    return false;
+                };
+                path.skip(min(rpath.len(), len) as u16);
+                true
+            }
+        }
+    }
+
+    // /// Build resource path.
+    // pub fn resource_path<U, I>(
+    //     &self, path: &mut String, elements: &mut U,
+    // ) -> Result<(), UrlGenerationError>
+    // where
+    //     U: Iterator<Item = I>,
+    //     I: AsRef<str>,
+    // {
+    //     match self.tp {
+    //         PatternType::Prefix(ref p) => path.push_str(p),
+    //         PatternType::Static(ref p) => path.push_str(p),
+    //         PatternType::Dynamic(..) => {
+    //             for el in &self.elements {
+    //                 match *el {
+    //                     PatternElement::Str(ref s) => path.push_str(s),
+    //                     PatternElement::Var(_) => {
+    //                         if let Some(val) = elements.next() {
+    //                             path.push_str(val.as_ref())
+    //                         } else {
+    //                             return Err(UrlGenerationError::NotEnoughElements);
+    //                         }
+    //                     }
+    //                 }
+    //             }
+    //         }
+    //     };
+    //     Ok(())
+    // }
+
+    fn parse_param(pattern: &str) -> (PatternElement, String, &str) {
+        const DEFAULT_PATTERN: &str = "[^/]+";
+        let mut params_nesting = 0usize;
+        let close_idx = pattern
+            .find(|c| match c {
+                '{' => {
+                    params_nesting += 1;
+                    false
+                }
+                '}' => {
+                    params_nesting -= 1;
+                    params_nesting == 0
+                }
+                _ => false,
+            })
+            .expect("malformed dynamic segment");
+        let (mut param, rem) = pattern.split_at(close_idx + 1);
+        param = &param[1..param.len() - 1]; // Remove outer brackets
+        let (name, pattern) = match param.find(':') {
+            Some(idx) => {
+                let (name, pattern) = param.split_at(idx);
+                (name, &pattern[1..])
+            }
+            None => (param, DEFAULT_PATTERN),
+        };
+        (
+            PatternElement::Var(name.to_string()),
+            format!(r"(?P<{}>{})", &name, &pattern),
+            rem,
+        )
+    }
+
+    fn parse(
+        mut pattern: &str,
+        for_prefix: bool,
+    ) -> (String, Vec<PatternElement>, bool, usize) {
+        if pattern.find('{').is_none() {
+            return (
+                String::from(pattern),
+                vec![PatternElement::Str(String::from(pattern))],
+                false,
+                pattern.chars().count(),
+            );
+        };
+
+        let mut elems = Vec::new();
+        let mut re = String::from("^");
+        let mut dyn_elems = 0;
+
+        while let Some(idx) = pattern.find('{') {
+            let (prefix, rem) = pattern.split_at(idx);
+            elems.push(PatternElement::Str(String::from(prefix)));
+            re.push_str(&escape(prefix));
+            let (param_pattern, re_part, rem) = Self::parse_param(rem);
+            elems.push(param_pattern);
+            re.push_str(&re_part);
+            pattern = rem;
+            dyn_elems += 1;
+        }
+
+        elems.push(PatternElement::Str(String::from(pattern)));
+        re.push_str(&escape(pattern));
+
+        if dyn_elems > MAX_DYNAMIC_SEGMENTS {
+            panic!(
+                "Only {} dynanic segments are allowed, provided: {}",
+                MAX_DYNAMIC_SEGMENTS, dyn_elems
+            );
+        }
+
+        if !for_prefix {
+            re.push_str("$");
+        }
+
+        (re, elems, true, pattern.chars().count())
+    }
+}
+
+impl Eq for ResourceDef {}
+
+impl PartialEq for ResourceDef {
+    fn eq(&self, other: &ResourceDef) -> bool {
+        self.pattern == other.pattern
+    }
+}
+
+impl Hash for ResourceDef {
+    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)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use http::{HttpTryFrom, Uri};
+
+    #[test]
+    fn test_parse_static() {
+        let re = ResourceDef::new("/");
+        assert!(re.is_match("/"));
+        assert!(!re.is_match("/a"));
+
+        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 = ResourceDef::new("/name/");
+        assert!(re.is_match("/name/"));
+        assert!(!re.is_match("/name"));
+        assert!(!re.is_match("/name/gs"));
+
+        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 = ResourceDef::new("/user/{id}");
+        assert!(re.is_match("/user/profile"));
+        assert!(re.is_match("/user/2345"));
+        assert!(!re.is_match("/user/2345/"));
+        assert!(!re.is_match("/user/2345/sdg"));
+
+        let mut path = Path::new("/user/profile");
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "profile");
+
+        let mut path = Path::new("/user/1245125");
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "1245125");
+
+        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"));
+
+        let mut path = Path::new("/v151/resource/adahg32");
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("version").unwrap(), "151");
+        assert_eq!(path.get("id").unwrap(), "adahg32");
+
+        let re = ResourceDef::new("/{id:[[:digit:]]{6}}");
+        assert!(re.is_match("/012345"));
+        assert!(!re.is_match("/012"));
+        assert!(!re.is_match("/01234567"));
+        assert!(!re.is_match("/XXXXXX"));
+
+        let mut path = Path::new("/012345");
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "012345");
+    }
+
+    #[test]
+    fn test_parse_urlencoded_param() {
+        let re = ResourceDef::new("/user/{id}/test");
+
+        let mut path = Path::new("/user/2345/test");
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "2345");
+
+        let mut path = Path::new("/user/qwe%25/test");
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "qwe%25");
+
+        let uri = Uri::try_from("/user/qwe%25/test").unwrap();
+        let mut path = Path::new(uri);
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "qwe%25");
+    }
+
+    #[test]
+    fn test_resource_prefix() {
+        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 = ResourceDef::prefix("/name/");
+        assert!(re.is_match("/name/"));
+        assert!(re.is_match("/name/gs"));
+        assert!(!re.is_match("/name"));
+    }
+
+    #[test]
+    fn test_reousrce_prefix_dynamic() {
+        let re = ResourceDef::prefix("/{name}/");
+        assert!(re.is_match("/name/"));
+        assert!(re.is_match("/name/gs"));
+        assert!(!re.is_match("/name"));
+
+        let mut path = Path::new("/test2/");
+        assert!(re.match_path(&mut path));
+        assert_eq!(&path["name"], "test2");
+        assert_eq!(&path[0], "test2");
+
+        let mut path = Path::new("/test2/subpath1/subpath2/index.html");
+        assert!(re.match_path(&mut path));
+        assert_eq!(&path["name"], "test2");
+        assert_eq!(&path[0], "test2");
+    }
+}

router/src/router.rs

@@ -0,0 +1,414 @@
+use std::collections::HashMap;
+use std::rc::Rc;
+
+use crate::path::Path;
+use crate::resource::ResourceDef;
+use crate::ResourcePath;
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub(crate) enum ResourceId {
+    Default,
+    Normal(u16),
+}
+
+/// Information about current resource
+#[derive(Clone, Debug)]
+pub struct ResourceInfo {
+    rmap: Rc<ResourceMap>,
+    resource: ResourceId,
+}
+
+#[derive(Default, Debug)]
+pub(crate) struct ResourceMap {
+    root: Option<ResourceDef>,
+    named: HashMap<String, ResourceDef>,
+    patterns: Vec<ResourceDef>,
+}
+
+/// Resource router.
+pub struct Router<T> {
+    rmap: Rc<ResourceMap>,
+    named: HashMap<String, ResourceDef>,
+    resources: Vec<T>,
+}
+
+impl<T> Router<T> {
+    pub fn build() -> RouterBuilder<T> {
+        RouterBuilder {
+            rmap: ResourceMap::default(),
+            named: HashMap::new(),
+            resources: Vec::new(),
+        }
+    }
+
+    pub fn recognize<U: ResourcePath>(&self, path: &mut Path<U>) -> Option<(&T, ResourceInfo)> {
+        if !path.path().is_empty() {
+            for (idx, resource) in self.rmap.patterns.iter().enumerate() {
+                if resource.match_path(path) {
+                    let info = ResourceInfo {
+                        rmap: self.rmap.clone(),
+                        resource: ResourceId::Normal(idx as u16),
+                    };
+                    return Some((&self.resources[idx], info));
+                }
+            }
+        }
+        None
+    }
+
+    pub fn recognize_mut<U: ResourcePath>(
+        &mut self,
+        path: &mut Path<U>,
+    ) -> Option<(&mut T, ResourceInfo)> {
+        if !path.path().is_empty() {
+            for (idx, resource) in self.rmap.patterns.iter().enumerate() {
+                if resource.match_path(path) {
+                    let info = ResourceInfo {
+                        rmap: self.rmap.clone(),
+                        resource: ResourceId::Normal(idx as u16),
+                    };
+                    return Some((&mut self.resources[idx], info));
+                }
+            }
+        }
+        None
+    }
+}
+
+impl<'a, T> IntoIterator for &'a Router<T> {
+    type Item = &'a T;
+    type IntoIter = std::slice::Iter<'a, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.resources.iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a mut Router<T> {
+    type Item = &'a mut T;
+    type IntoIter = std::slice::IterMut<'a, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.resources.iter_mut()
+    }
+}
+
+impl ResourceMap {
+    fn register(&mut self, pattern: ResourceDef) {
+        self.patterns.push(pattern);
+    }
+
+    fn register_named(&mut self, name: String, pattern: ResourceDef) {
+        self.patterns.push(pattern.clone());
+        self.named.insert(name, pattern);
+    }
+
+    fn has_resource(&self, path: &str) -> bool {
+        unimplemented!()
+    }
+}
+
+pub struct RouterBuilder<T> {
+    rmap: ResourceMap,
+    named: HashMap<String, ResourceDef>,
+    resources: Vec<T>,
+}
+
+impl<T> RouterBuilder<T> {
+    /// Register resource for specified path.
+    pub fn path(&mut self, path: &str, resource: T) {
+        self.rmap.register(ResourceDef::new(path));
+        self.resources.push(resource);
+    }
+
+    /// Register resource for specified path prefix.
+    pub fn prefix(&mut self, prefix: &str, resource: T) {
+        self.rmap.register(ResourceDef::prefix(prefix));
+        self.resources.push(resource);
+    }
+
+    /// Register resource for ResourceDef
+    pub fn rdef(&mut self, rdef: ResourceDef, resource: T) {
+        self.rmap.register(rdef);
+        self.resources.push(resource);
+    }
+
+    /// Finish configuration and create router instance.
+    pub fn finish(self) -> Router<T> {
+        Router {
+            rmap: Rc::new(self.rmap),
+            named: self.named,
+            resources: self.resources,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::path::Path;
+    use crate::router::{ResourceId, Router};
+
+    #[test]
+    fn test_recognizer_1() {
+        let mut router = Router::<usize>::build();
+        router.path("/name", 10);
+        router.path("/name/{val}", 11);
+        router.path("/name/{val}/index.html", 12);
+        router.path("/file/{file}.{ext}", 13);
+        router.path("/v{val}/{val2}/index.html", 14);
+        router.path("/v/{tail:.*}", 15);
+        router.path("/test2/{test}.html", 16);
+        router.path("/{test}/index.html", 17);
+        let mut router = router.finish();
+
+        let mut path = Path::new("/unknown");
+        assert!(router.recognize_mut(&mut path).is_none());
+
+        let mut path = Path::new("/name");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 10);
+        assert_eq!(info.resource, ResourceId::Normal(0));
+        assert!(path.is_empty());
+
+        let mut path = Path::new("/name/value");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 11);
+        assert_eq!(info.resource, ResourceId::Normal(1));
+        assert_eq!(path.get("val").unwrap(), "value");
+        assert_eq!(&path["val"], "value");
+
+        let mut path = Path::new("/name/value2/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 12);
+        assert_eq!(info.resource, ResourceId::Normal(2));
+        assert_eq!(path.get("val").unwrap(), "value2");
+
+        let mut path = Path::new("/file/file.gz");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 13);
+        assert_eq!(info.resource, ResourceId::Normal(3));
+        assert_eq!(path.get("file").unwrap(), "file");
+        assert_eq!(path.get("ext").unwrap(), "gz");
+
+        let mut path = Path::new("/vtest/ttt/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 14);
+        assert_eq!(info.resource, ResourceId::Normal(4));
+        assert_eq!(path.get("val").unwrap(), "test");
+        assert_eq!(path.get("val2").unwrap(), "ttt");
+
+        let mut path = Path::new("/v/blah-blah/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 15);
+        assert_eq!(info.resource, ResourceId::Normal(5));
+        assert_eq!(path.get("tail").unwrap(), "blah-blah/index.html");
+
+        let mut path = Path::new("/test2/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 16);
+        assert_eq!(info.resource, ResourceId::Normal(6));
+        assert_eq!(path.get("test").unwrap(), "index");
+
+        let mut path = Path::new("/bbb/index.html");
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 17);
+        assert_eq!(info.resource, ResourceId::Normal(7));
+        assert_eq!(path.get("test").unwrap(), "bbb");
+    }
+
+    #[test]
+    fn test_recognizer_2() {
+        let mut router = Router::<usize>::build();
+        router.path("/index.json", 10);
+        router.path("/{source}.json", 11);
+        let mut router = router.finish();
+
+        let mut path = Path::new("/index.json");
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 10);
+
+        let mut path = Path::new("/test.json");
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 11);
+    }
+
+    #[test]
+    fn test_recognizer_with_prefix() {
+        let mut router = Router::<usize>::build();
+        router.path("/name", 10);
+        router.path("/name/{val}", 11);
+        let mut router = router.finish();
+
+        let mut path = Path::new("/name");
+        path.skip(5);
+        assert!(router.recognize_mut(&mut path).is_none());
+
+        let mut path = Path::new("/test/name");
+        path.skip(5);
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 10);
+
+        let mut path = Path::new("/test/name/value");
+        path.skip(5);
+        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 11);
+        assert_eq!(info.resource, ResourceId::Normal(1));
+        assert_eq!(path.get("val").unwrap(), "value");
+        assert_eq!(&path["val"], "value");
+
+        // same patterns
+        let mut router = Router::<usize>::build();
+        router.path("/name", 10);
+        router.path("/name/{val}", 11);
+        let mut router = router.finish();
+
+        let mut path = Path::new("/name");
+        path.skip(6);
+        assert!(router.recognize_mut(&mut path).is_none());
+
+        let mut path = Path::new("/test2/name");
+        path.skip(6);
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 10);
+
+        let mut path = Path::new("/test2/name-test");
+        path.skip(6);
+        assert!(router.recognize_mut(&mut path).is_none());
+
+        let mut path = Path::new("/test2/name/ttt");
+        path.skip(6);
+        let (h, _) = router.recognize_mut(&mut path).unwrap();
+        assert_eq!(*h, 11);
+        assert_eq!(&path["val"], "ttt");
+    }
+
+    // #[test]
+    // fn test_request_resource() {
+    //     let mut router = Router::<()>::default();
+    //     let mut resource = Resource::new(ResourcePattern::new("/index.json"));
+    //     resource.name("r1");
+    //     router.register_resource(resource);
+    //     let mut resource = Resource::new(ResourcePattern::new("/test.json"));
+    //     resource.name("r2");
+    //     router.register_resource(resource);
+
+    //     let req = TestRequest::with_uri("/index.json").finish();
+    //     let info = router.recognize(&req, &(), 0);
+    //     assert_eq!(info.resource, ResourceId::Normal(0));
+
+    //     assert_eq!(info.name(), "r1");
+
+    //     let req = TestRequest::with_uri("/test.json").finish();
+    //     let info = router.recognize(&req, &(), 0);
+    //     assert_eq!(info.resource, ResourceId::Normal(1));
+    //     assert_eq!(info.name(), "r2");
+    // }
+
+    // #[test]
+    // fn test_has_resource() {
+    //     let mut router = Router::<()>::default();
+    //     let scope = Scope::new("/test").resource("/name", |_| "done");
+    //     router.register_scope(scope);
+
+    //     {
+    //         let info = router.default_route_info();
+    //         assert!(!info.has_resource("/test"));
+    //         assert!(info.has_resource("/test/name"));
+    //     }
+
+    //     let scope = Scope::new("/test2").nested("/test10", |s| s.resource("/name", |_| "done"));
+    //     router.register_scope(scope);
+
+    //     let info = router.default_route_info();
+    //     assert!(info.has_resource("/test2/test10/name"));
+    // }
+
+    // #[test]
+    // fn test_url_for() {
+    //     let mut router = Router::<()>::new(ResourcePattern::prefix(""));
+
+    //     let mut resource = Resource::new(ResourcePattern::new("/tttt"));
+    //     resource.name("r0");
+    //     router.register_resource(resource);
+
+    //     let scope = Scope::new("/test").resource("/name", |r| {
+    //         r.name("r1");
+    //     });
+    //     router.register_scope(scope);
+
+    //     let scope =
+    //         Scope::new("/test2").nested("/test10", |s| s.resource("/name", |r| r.name("r2")));
+    //     router.register_scope(scope);
+    //     router.finish();
+
+    //     let req = TestRequest::with_uri("/test").request();
+    //     {
+    //         let info = router.default_route_info();
+
+    //         let res = info
+    //             .url_for(&req, "r0", Vec::<&'static str>::new())
+    //             .unwrap();
+    //         assert_eq!(res.as_str(), "http://localhost:8080/tttt");
+
+    //         let res = info
+    //             .url_for(&req, "r1", Vec::<&'static str>::new())
+    //             .unwrap();
+    //         assert_eq!(res.as_str(), "http://localhost:8080/test/name");
+
+    //         let res = info
+    //             .url_for(&req, "r2", Vec::<&'static str>::new())
+    //             .unwrap();
+    //         assert_eq!(res.as_str(), "http://localhost:8080/test2/test10/name");
+    //     }
+
+    //     let req = TestRequest::with_uri("/test/name").request();
+    //     let info = router.recognize(&req, &(), 0);
+    //     assert_eq!(info.resource, ResourceId::Normal(1));
+
+    //     let res = info
+    //         .url_for(&req, "r0", Vec::<&'static str>::new())
+    //         .unwrap();
+    //     assert_eq!(res.as_str(), "http://localhost:8080/tttt");
+
+    //     let res = info
+    //         .url_for(&req, "r1", Vec::<&'static str>::new())
+    //         .unwrap();
+    //     assert_eq!(res.as_str(), "http://localhost:8080/test/name");
+
+    //     let res = info
+    //         .url_for(&req, "r2", Vec::<&'static str>::new())
+    //         .unwrap();
+    //     assert_eq!(res.as_str(), "http://localhost:8080/test2/test10/name");
+    // }
+
+    // #[test]
+    // fn test_url_for_dynamic() {
+    //     let mut router = Router::<()>::new(ResourcePattern::prefix(""));
+
+    //     let mut resource = Resource::new(ResourcePattern::new("/{name}/test/index.{ext}"));
+    //     resource.name("r0");
+    //     router.register_resource(resource);
+
+    //     let scope = Scope::new("/{name1}").nested("/{name2}", |s| {
+    //         s.resource("/{name3}/test/index.{ext}", |r| r.name("r2"))
+    //     });
+    //     router.register_scope(scope);
+    //     router.finish();
+
+    //     let req = TestRequest::with_uri("/test").request();
+    //     {
+    //         let info = router.default_route_info();
+
+    //         let res = info.url_for(&req, "r0", vec!["sec1", "html"]).unwrap();
+    //         assert_eq!(res.as_str(), "http://localhost:8080/sec1/test/index.html");
+
+    //         let res = info
+    //             .url_for(&req, "r2", vec!["sec1", "sec2", "sec3", "html"])
+    //             .unwrap();
+    //         assert_eq!(
+    //             res.as_str(),
+    //             "http://localhost:8080/sec1/sec2/sec3/test/index.html"
+    //         );
+    //     }
+    // }
+}

router/src/url.rs

@@ -0,0 +1,214 @@
+use std::rc::Rc;
+
+use crate::ResourcePath;
+
+#[allow(dead_code)]
+const GEN_DELIMS: &[u8] = b":/?#[]@";
+#[allow(dead_code)]
+const SUB_DELIMS_WITHOUT_QS: &[u8] = b"!$'()*,";
+#[allow(dead_code)]
+const SUB_DELIMS: &[u8] = b"!$'()*,+?=;";
+#[allow(dead_code)]
+const RESERVED: &[u8] = b":/?#[]@!$'()*,+?=;";
+#[allow(dead_code)]
+const UNRESERVED: &[u8] = b"abcdefghijklmnopqrstuvwxyz
+    ABCDEFGHIJKLMNOPQRSTUVWXYZ
+    1234567890
+    -._~";
+const ALLOWED: &[u8] = b"abcdefghijklmnopqrstuvwxyz
+    ABCDEFGHIJKLMNOPQRSTUVWXYZ
+    1234567890
+    -._~
+    !$'()*,";
+const QS: &[u8] = b"+&=;b";
+
+#[inline]
+fn bit_at(array: &[u8], ch: u8) -> bool {
+    array[(ch >> 3) as usize] & (1 << (ch & 7)) != 0
+}
+
+#[inline]
+fn set_bit(array: &mut [u8], ch: u8) {
+    array[(ch >> 3) as usize] |= 1 << (ch & 7)
+}
+
+thread_local! {
+    static DEFAULT_QUOTER: Quoter = { Quoter::new(b"@:", b"/+") };
+}
+
+#[derive(Default, Clone, Debug)]
+pub struct Url {
+    uri: http::Uri,
+    path: Option<Rc<String>>,
+}
+
+impl Url {
+    pub fn new(uri: http::Uri) -> Url {
+        let path = DEFAULT_QUOTER.with(|q| q.requote(uri.path().as_bytes()));
+
+        Url { uri, path }
+    }
+
+    pub fn uri(&self) -> &http::Uri {
+        &self.uri
+    }
+
+    pub fn path(&self) -> &str {
+        if let Some(ref s) = self.path {
+            s
+        } else {
+            self.uri.path()
+        }
+    }
+
+    pub fn update(&mut self, uri: &http::Uri) {
+        self.uri = uri.clone();
+        self.path = DEFAULT_QUOTER.with(|q| q.requote(uri.path().as_bytes()));
+    }
+}
+
+impl ResourcePath for Url {
+    fn path(&self) -> &str {
+        self.path()
+    }
+}
+
+pub(crate) struct Quoter {
+    safe_table: [u8; 16],
+    protected_table: [u8; 16],
+}
+
+impl Quoter {
+    pub fn new(safe: &[u8], protected: &[u8]) -> Quoter {
+        let mut q = Quoter {
+            safe_table: [0; 16],
+            protected_table: [0; 16],
+        };
+
+        // prepare safe table
+        for i in 0..128 {
+            if ALLOWED.contains(&i) {
+                set_bit(&mut q.safe_table, i);
+            }
+            if QS.contains(&i) {
+                set_bit(&mut q.safe_table, i);
+            }
+        }
+
+        for ch in safe {
+            set_bit(&mut q.safe_table, *ch)
+        }
+
+        // prepare protected table
+        for ch in protected {
+            set_bit(&mut q.safe_table, *ch);
+            set_bit(&mut q.protected_table, *ch);
+        }
+
+        q
+    }
+
+    pub fn requote(&self, val: &[u8]) -> Option<Rc<String>> {
+        let mut has_pct = 0;
+        let mut pct = [b'%', 0, 0];
+        let mut idx = 0;
+        let mut cloned: Option<Vec<u8>> = None;
+
+        let len = val.len();
+        while idx < len {
+            let ch = val[idx];
+
+            if has_pct != 0 {
+                pct[has_pct] = val[idx];
+                has_pct += 1;
+                if has_pct == 3 {
+                    has_pct = 0;
+                    let buf = cloned.as_mut().unwrap();
+
+                    if let Some(ch) = restore_ch(pct[1], pct[2]) {
+                        if ch < 128 {
+                            if bit_at(&self.protected_table, ch) {
+                                buf.extend_from_slice(&pct);
+                                idx += 1;
+                                continue;
+                            }
+
+                            if bit_at(&self.safe_table, ch) {
+                                buf.push(ch);
+                                idx += 1;
+                                continue;
+                            }
+                        }
+                        buf.push(ch);
+                    } else {
+                        buf.extend_from_slice(&pct[..]);
+                    }
+                }
+            } else if ch == b'%' {
+                has_pct = 1;
+                if cloned.is_none() {
+                    let mut c = Vec::with_capacity(len);
+                    c.extend_from_slice(&val[..idx]);
+                    cloned = Some(c);
+                }
+            } else if let Some(ref mut cloned) = cloned {
+                cloned.push(ch)
+            }
+            idx += 1;
+        }
+
+        if let Some(data) = cloned {
+            // Unsafe: we get data from http::Uri, which does utf-8 checks already
+            // this code only decodes valid pct encoded values
+            Some(Rc::new(unsafe { String::from_utf8_unchecked(data) }))
+        } else {
+            None
+        }
+    }
+}
+
+#[inline]
+fn from_hex(v: u8) -> Option<u8> {
+    if v >= b'0' && v <= b'9' {
+        Some(v - 0x30) // ord('0') == 0x30
+    } else if v >= b'A' && v <= b'F' {
+        Some(v - 0x41 + 10) // ord('A') == 0x41
+    } else if v > b'a' && v <= b'f' {
+        Some(v - 0x61 + 10) // ord('a') == 0x61
+    } else {
+        None
+    }
+}
+
+#[inline]
+fn restore_ch(d1: u8, d2: u8) -> Option<u8> {
+    from_hex(d1).and_then(|d1| from_hex(d2).and_then(move |d2| Some(d1 << 4 | d2)))
+}
+
+#[cfg(test)]
+mod tests {
+    use http::{HttpTryFrom, Uri};
+
+    use super::*;
+    use crate::{Path, ResourceDef};
+
+    #[test]
+    fn test_parse_url() {
+        let re = ResourceDef::new("/user/{id}/test");
+
+        let url = Uri::try_from("/user/2345/test").unwrap();
+        let mut path = Path::new(Url::new(url));
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "2345");
+
+        let url = Uri::try_from("/user/qwe%25/test").unwrap();
+        let mut path = Path::new(Url::new(url));
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "qwe%");
+
+        let url = Uri::try_from("/user/qwe%25rty/test").unwrap();
+        let mut path = Path::new(Url::new(url));
+        assert!(re.match_path(&mut path));
+        assert_eq!(path.get("id").unwrap(), "qwe%rty");
+    }
+}