add blocking mod support

.travis.yml

@@ -35,7 +35,7 @@ script:
     cargo test --features="ssl,tls,rust-tls" -- --nocapture
     cd actix-codec && cargo test && cd ..
     cd actix-service && cargo test && cd ..
-    cd actix-server && cargo test --features="ssl,tls,rust-tls" -- --nocapture && cd ..
+    cd actix-server && cargo test --all-features -- --nocapture && cd ..
     cd actix-rt && cargo test && cd ..
     cd actix-connector && cargo test && cd ..
     cd actix-utils && cargo test && cd ..

Cargo.toml

@@ -1,3 +1,18 @@
+[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"
+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",
@@ -5,7 +20,19 @@ members = [
   "actix-rt",
   "actix-service",
   "actix-server",
+  "actix-server-config",
   "actix-test-server",
   "actix-utils",
   "router",
 ]
+
+[dev-dependencies]
+actix-service = "0.3.3"
+actix-codec = "0.1.1"
+actix-rt = "0.2.0"
+actix-server = { path="actix-server", features=["ssl"] }
+env_logger = "0.6"
+futures = "0.1.25"
+openssl = "0.10"
+tokio-tcp = "0.1"
+tokio-openssl = "0.3"

README.md

@@ -1,20 +1,18 @@
 # Actix net [![Build Status](https://travis-ci.org/actix/actix-net.svg?branch=master)](https://travis-ci.org/actix/actix-net) [![codecov](https://codecov.io/gh/actix/actix-net/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-net) [![crates.io](https://meritbadge.herokuapp.com/actix-net)](https://crates.io/crates/actix-net) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-Actix net - framework for composable network services (experimental)
+Actix net - framework for composable network services
 
 ## Documentation & community resources
 
 * [API Documentation (Development)](https://actix.rs/actix-net/actix_net/)
 * [Chat on gitter](https://gitter.im/actix/actix)
 * Cargo package: [actix-net](https://crates.io/crates/actix-net)
-* Minimum supported Rust version: 1.26 or later
+* Minimum supported Rust version: 1.32 or later
 
 ## Example
 
 ```rust
-fn main() {
-    let sys = actix_rt::System::new("test");
-
+fn main() -> io::Result<()> {
     // load ssl keys
     let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
     builder.set_private_key_file("./examples/key.pem", SslFiletype::PEM).unwrap();
@@ -26,7 +24,7 @@ fn main() {
     // bind socket address and start workers. By default server uses number of
     // available logical cpu as threads count. actix net start separate
     // instances of service pipeline in each worker.
-    actix_server::build()
+    Server::build()
         .bind(
             // configure service pipeline
             "basic", "0.0.0.0:8443",
@@ -35,28 +33,23 @@ fn main() {
                 let acceptor = acceptor.clone();
 
                 // service for converting incoming TcpStream to a SslStream<TcpStream>
-                (move |stream| {
-                SslAcceptorExt::accept_async(&acceptor, stream)
-                    .map_err(|e| println!("Openssl error: {}", e))
-            })
-            // convert closure to a `NewService`
-            .into_new_service()
-
-            // .and_then() combinator uses other service to convert incoming `Request` to a `Response`
-            // and then uses that response as an input for next service.
-            // in this case, on success we use `logger` service
-            .and_then(logger)
-
-            // Next service counts number of connections
-            .and_then(move |req| {
-                let num = num.fetch_add(1, Ordering::Relaxed);
-                println!("processed {:?} connections", num);
-                future::ok(())
-            })
-        }).unwrap()
-        .start();
-
-    sys.run();
+                fn_service(move |stream: Io<tokio_tcp::TcpStream>| {
+                    SslAcceptorExt::accept_async(&acceptor, stream.into_parts().0)
+                        .map_err(|e| println!("Openssl error: {}", e))
+                })
+                // .and_then() combinator uses other service to convert incoming `Request` to a
+                // `Response` and then uses that response as an input for next
+                // service. in this case, on success we use `logger` service
+                .and_then(fn_service(logger))
+                // Next service counts number of connections
+                .and_then(move |_| {
+                    let num = num.fetch_add(1, Ordering::Relaxed);
+                    println!("got ssl connection {:?}", num);
+                    future::ok(())
+                })
+            },
+        )?
+        .run()
 }
 ```
 

actix-codec/CHANGES.md

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

actix-codec/Cargo.toml

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

actix-codec/src/framed.rs

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

actix-connector/CHANGES.md

@@ -1,8 +1,15 @@
 # Changes
 
+## [0.3.0] - 2019-03-02
+
+### Changed
+
+* Migrate to actix-service 0.3
+
+
 ## [0.2.0] - 2019-02-01
 
-### Changes
+### Changed
 
 * Migrate to actix-service 0.2
 

actix-connector/Cargo.toml

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

actix-connector/src/connector.rs

@@ -4,8 +4,8 @@ use std::net::{IpAddr, SocketAddr};
 use std::time::Duration;
 use std::{fmt, io};
 
-use actix_service::{NewService, Service};
-use 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};
@@ -177,12 +177,13 @@ impl Connector {
         cfg: ResolverConfig,
         opts: ResolverOpts,
     ) -> impl NewService<
+        (),
         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)))
     }
 }
 

actix-connector/src/ssl/openssl.rs

@@ -44,7 +44,9 @@ impl<R, T, E> Clone for OpensslConnector<R, T, E> {
     }
 }
 
-impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService for OpensslConnector<R, T, E> {
+impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService<()>
+    for OpensslConnector<R, T, E>
+{
     type Request = (R, T);
     type Response = (R, SslStream<T>);
     type Error = HandshakeError<T>;
@@ -52,7 +54,7 @@ impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService for OpensslConnect
     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,

actix-rt/CHANGES.md

@@ -1,5 +1,21 @@
 # Changes
 
+## [0.2.1] - 2019-03-11
+
+### Added
+
+* Added `blocking` module
+
+* Arbiter::exec_fn - execute fn on the arbiter's thread
+
+* Arbiter::exec - execute fn on the arbiter's thread and wait result
+
+## [0.2.0] - 2019-03-06
+
+* `run` method returns `io::Result<()>`
+
+* Removed `Handle`
+
 ## [0.1.0] - 2018-12-09
 
 * Initial release

actix-rt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-rt"
-version = "0.1.0"
+version = "0.2.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix runtime"
 keywords = ["network", "framework", "async", "futures"]
@@ -18,9 +18,14 @@ name = "actix_rt"
 path = "src/lib.rs"
 
 [dependencies]
-log = "0.4"
 bytes = "0.4"
-futures = "0.1.24"
+derive_more = "0.14"
+futures = "0.1.25"
+parking_lot = "0.7"
+lazy_static = "1.2"
+log = "0.4"
+num_cpus = "1.10"
+threadpool = "1.7"
 tokio-current-thread = "0.1"
 tokio-executor = "0.1.5"
 tokio-reactor = "0.1.7"

actix-rt/src/arbiter.rs

@@ -4,7 +4,7 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 use std::{fmt, thread};
 
 use futures::sync::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
-use futures::sync::oneshot::{channel, Sender};
+use futures::sync::oneshot::{channel, Canceled, Sender};
 use futures::{future, Async, Future, IntoFuture, Poll, Stream};
 use tokio_current_thread::spawn;
 
@@ -22,6 +22,7 @@ pub(crate) static COUNT: AtomicUsize = AtomicUsize::new(0);
 pub(crate) enum ArbiterCommand {
     Stop,
     Execute(Box<Future<Item = (), Error = ()> + Send>),
+    ExecuteFn(Box<FnExec>),
 }
 
 impl fmt::Debug for ArbiterCommand {
@@ -29,6 +30,7 @@ impl fmt::Debug for ArbiterCommand {
         match self {
             ArbiterCommand::Stop => write!(f, "ArbiterCommand::Stop"),
             ArbiterCommand::Execute(_) => write!(f, "ArbiterCommand::Execute"),
+            ArbiterCommand::ExecuteFn(_) => write!(f, "ArbiterCommand::ExecuteFn"),
         }
     }
 }
@@ -158,6 +160,35 @@ impl Arbiter {
             .0
             .unbounded_send(ArbiterCommand::Execute(Box::new(future)));
     }
+
+    /// Send a function to the arbiter's thread and exeute.
+    pub fn exec_fn<F>(&self, f: F)
+    where
+        F: FnOnce() + Send + 'static,
+    {
+        let _ = self
+            .0
+            .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || {
+                let _ = f();
+            })));
+    }
+
+    /// Send a function to the arbiter's thread, exeute and return result.
+    pub fn exec<F, R>(&self, f: F) -> impl Future<Item = R, Error = Canceled>
+    where
+        F: FnOnce() -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        let (tx, rx) = channel();
+        let _ = self
+            .0
+            .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || {
+                if !tx.is_canceled() {
+                    let _ = tx.send(f());
+                }
+            })));
+        rx
+    }
 }
 
 struct ArbiterController {
@@ -194,6 +225,9 @@ impl Future for ArbiterController {
                     ArbiterCommand::Execute(fut) => {
                         spawn(fut);
                     }
+                    ArbiterCommand::ExecuteFn(f) => {
+                        f.call_box();
+                    }
                 },
                 Ok(Async::NotReady) => return Ok(Async::NotReady),
             }
@@ -257,11 +291,16 @@ impl Future for SystemArbiter {
     }
 }
 
-// /// Execute function in arbiter's thread
-// impl<I: Send, E: Send> Handler<Execute<I, E>> for SystemArbiter {
-//     type Result = Result<I, E>;
+pub trait FnExec: Send + 'static {
+    fn call_box(self: Box<Self>);
+}
 
-//     fn handle(&mut self, msg: Execute<I, E>, _: &mut Context<Self>) -> Result<I, E> {
-//         msg.exec()
-//     }
-// }
+impl<F> FnExec for F
+where
+    F: FnOnce() + Send + 'static,
+{
+    #[cfg_attr(feature = "cargo-clippy", allow(boxed_local))]
+    fn call_box(self: Box<Self>) {
+        (*self)()
+    }
+}

actix-rt/src/blocking.rs

@@ -0,0 +1,88 @@
+//! Thread pool for blocking operations
+
+use std::fmt;
+
+use derive_more::Display;
+use futures::sync::oneshot;
+use futures::{Async, Future, Poll};
+use parking_lot::Mutex;
+use threadpool::ThreadPool;
+
+/// Env variable for default cpu pool size
+const ENV_CPU_POOL_VAR: &str = "ACTIX_CPU_POOL";
+
+lazy_static::lazy_static! {
+    pub(crate) static ref DEFAULT_POOL: Mutex<ThreadPool> = {
+        let default = match std::env::var(ENV_CPU_POOL_VAR) {
+            Ok(val) => {
+                if let Ok(val) = val.parse() {
+                    val
+                } else {
+                    log::error!("Can not parse ACTIX_CPU_POOL value");
+                    num_cpus::get() * 5
+                }
+            }
+            Err(_) => num_cpus::get() * 5,
+        };
+        Mutex::new(
+            threadpool::Builder::new()
+                .thread_name("actix-web".to_owned())
+                .num_threads(default)
+                .build(),
+        )
+    };
+}
+
+thread_local! {
+    static POOL: ThreadPool = {
+        DEFAULT_POOL.lock().clone()
+    };
+}
+
+/// Blocking operation execution error
+#[derive(Debug, Display)]
+pub enum BlockingError<E: fmt::Debug> {
+    #[display(fmt = "{:?}", _0)]
+    Error(E),
+    #[display(fmt = "Thread pool is gone")]
+    Canceled,
+}
+
+/// Execute blocking function on a thread pool, returns future that resolves
+/// to result of the function execution.
+pub fn run<F, I, E>(f: F) -> CpuFuture<I, E>
+where
+    F: FnOnce() -> Result<I, E> + Send + 'static,
+    I: Send + 'static,
+    E: Send + fmt::Debug + 'static,
+{
+    let (tx, rx) = oneshot::channel();
+    POOL.with(|pool| {
+        pool.execute(move || {
+            if !tx.is_canceled() {
+                let _ = tx.send(f());
+            }
+        })
+    });
+
+    CpuFuture { rx }
+}
+
+/// Blocking operation completion future. It resolves with results
+/// of blocking function execution.
+pub struct CpuFuture<I, E> {
+    rx: oneshot::Receiver<Result<I, E>>,
+}
+
+impl<I, E: fmt::Debug> Future for CpuFuture<I, E> {
+    type Item = I;
+    type Error = BlockingError<E>;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let res = futures::try_ready!(self.rx.poll().map_err(|_| BlockingError::Canceled));
+        match res {
+            Ok(val) => Ok(Async::Ready(val)),
+            Err(err) => Err(BlockingError::Error(err)),
+        }
+    }
+}

actix-rt/src/builder.rs

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

actix-rt/src/lib.rs

@@ -1,13 +1,14 @@
 //! A runtime implementation that runs everything on the current thread.
 
 mod arbiter;
+pub mod blocking;
 mod builder;
 mod runtime;
 mod system;
 
 pub use self::arbiter::Arbiter;
 pub use self::builder::{Builder, SystemRunner};
-pub use self::runtime::{Handle, Runtime};
+pub use self::runtime::Runtime;
 pub use self::system::System;
 
 /// Spawns a future on the current arbiter.

actix-rt/src/runtime.rs

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

actix-rt/src/system.rs

@@ -1,13 +1,18 @@
 use std::cell::RefCell;
+use std::io;
+use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
 
 use futures::sync::mpsc::UnboundedSender;
 
 use crate::arbiter::{Arbiter, SystemCommand};
 use crate::builder::{Builder, SystemRunner};
 
+static SYSTEM_COUNT: AtomicUsize = ATOMIC_USIZE_INIT;
+
 /// System is a runtime manager.
 #[derive(Clone, Debug)]
 pub struct System {
+    id: usize,
     sys: UnboundedSender<SystemCommand>,
     arbiter: Arbiter,
     stop_on_panic: bool,
@@ -28,6 +33,7 @@ impl System {
             sys,
             arbiter,
             stop_on_panic,
+            id: SYSTEM_COUNT.fetch_add(1, Ordering::SeqCst),
         };
         System::set_current(sys.clone());
         sys
@@ -81,6 +87,11 @@ impl System {
         })
     }
 
+    /// System id
+    pub fn id(&self) -> usize {
+        self.id
+    }
+
     /// Stop the system
     pub fn stop(&self) {
         self.stop_with_code(0)
@@ -109,7 +120,7 @@ impl System {
     /// This function will start tokio runtime and will finish once the
     /// `System::stop()` message get called.
     /// Function `f` get called within tokio runtime context.
-    pub fn run<F>(f: F) -> i32
+    pub fn run<F>(f: F) -> io::Result<()>
     where
         F: FnOnce() + 'static,
     {

actix-server-config/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "actix-server-config"
+version = "0.1.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix server config utils"
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+license = "MIT/Apache-2.0"
+edition = "2018"
+workspace = ".."
+
+[lib]
+name = "actix_server_config"
+path = "src/lib.rs"
+
+[dependencies]
+futures = "0.1.25"

actix-server-config/src/lib.rs

@@ -0,0 +1,109 @@
+use std::cell::Cell;
+use std::fmt;
+use std::net::SocketAddr;
+use std::rc::Rc;
+
+#[derive(Debug, Clone)]
+pub struct ServerConfig {
+    addr: SocketAddr,
+    secure: Rc<Cell<bool>>,
+}
+
+impl ServerConfig {
+    pub fn new(addr: SocketAddr) -> Self {
+        ServerConfig {
+            addr,
+            secure: Rc::new(Cell::new(false)),
+        }
+    }
+
+    /// Returns the address of the local half of this TCP server socket
+    pub fn local_addr(&self) -> SocketAddr {
+        self.addr
+    }
+
+    /// Returns true if connection is secure (tls enabled)
+    pub fn secure(&self) -> bool {
+        self.secure.as_ref().get()
+    }
+
+    /// Set secure flag
+    pub fn set_secure(&self) {
+        self.secure.as_ref().set(true)
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum Protocol {
+    Unknown,
+    Http10,
+    Http11,
+    Http2,
+    Proto1,
+    Proto2,
+    Proto3,
+    Proto4,
+    Proto5,
+    Proto6,
+}
+
+pub struct Io<T, P = ()> {
+    io: T,
+    proto: Protocol,
+    params: P,
+}
+
+impl<T> Io<T, ()> {
+    pub fn new(io: T) -> Self {
+        Self {
+            io,
+            proto: Protocol::Unknown,
+            params: (),
+        }
+    }
+}
+
+impl<T, P> Io<T, P> {
+    /// Reconstruct from a parts.
+    pub fn from_parts(io: T, params: P, proto: Protocol) -> Self {
+        Self { io, params, proto }
+    }
+
+    /// Deconstruct into a parts.
+    pub fn into_parts(self) -> (T, P, Protocol) {
+        (self.io, self.params, self.proto)
+    }
+
+    /// Returns a shared reference to the underlying stream.
+    pub fn get_ref(&self) -> &T {
+        &self.io
+    }
+
+    /// Returns a mutable reference to the underlying stream.
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.io
+    }
+
+    /// Get selected protocol
+    pub fn protocol(&self) -> Protocol {
+        self.proto
+    }
+
+    /// Maps an Io<_, P> to Io<_, U> by applying a function to a contained value.
+    pub fn map<U, F>(self, op: F) -> Io<T, U>
+    where
+        F: FnOnce(P) -> U,
+    {
+        Io {
+            io: self.io,
+            proto: self.proto,
+            params: op(self.params),
+        }
+    }
+}
+
+impl<T: fmt::Debug, P> fmt::Debug for Io<T, P> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Io {{{:?}}}", self.io)
+    }
+}

actix-server/CHANGES.md

@@ -1,15 +1,43 @@
 # Changes
 
+## [0.4.0] - 2019-03-xx
+
+* Upgrade actix-service
+
+
+## [0.3.1] - 2019-03-04
+
+### Added
+
+* Add `ServerBuilder::maxconnrate` sets the maximum per-worker number of concurrent connections
+
+* Add helper ssl error `SslError`
+
+
+### Changed
+
+* Rename `StreamServiceFactory` to `ServiceFactory`
+
+* Deprecate `StreamServiceFactory`
+
+
+## [0.3.0] - 2019-03-02
+
+### Changed
+
+* Use new `NewService` trait
+
+
 ## [0.2.1] - 2019-02-09
 
-### Changes
+### Changed
 
 * Drop service response
 
 
 ## [0.2.0] - 2019-02-01
 
-### Changes
+### Changed
 
 * Migrate to actix-service 0.2
 

actix-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-server"
-version = "0.2.1"
+version = "0.3.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix server - General purpose tcp server"
 keywords = ["network", "framework", "async", "futures"]
@@ -11,7 +11,7 @@ categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
-workspace = "../"
+workspace = ".."
 
 [package.metadata.docs.rs]
 features = ["ssl", "tls", "rust-tls"]
@@ -33,16 +33,15 @@ ssl = ["openssl", "tokio-openssl"]
 rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
 
 [dependencies]
-actix-service = "0.2.1"
-actix-rt = "0.1.0"
+actix-rt = "0.2.0"
+actix-service = "0.3.3"
+actix-server-config = { path="../actix-server-config" }
 
 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"
@@ -65,5 +64,6 @@ webpki = { version = "0.19", optional = true }
 webpki-roots = { version = "0.16", optional = true }
 
 [dev-dependencies]
-env_logger = "0.6"
+bytes = "0.4"
 actix-codec = "0.1.0"
+env_logger = "0.6"

actix-server/src/builder.rs

@@ -12,18 +12,18 @@ use num_cpus;
 use tokio_timer::sleep;
 
 use crate::accept::{AcceptLoop, AcceptNotify, Command};
-use crate::config::{ConfiguredService, ServiceConfig};
 use crate::server::{Server, ServerCommand};
-use crate::services::{InternalServiceFactory, StreamNewService, StreamServiceFactory};
-use crate::services::{ServiceFactory, ServiceNewService};
+use crate::service_config::{ConfiguredService, ServiceConfig};
+use crate::services::{InternalServiceFactory, ServiceFactory, StreamNewService};
 use crate::signals::{Signal, Signals};
 use crate::worker::{self, Worker, WorkerAvailability, WorkerClient};
-use crate::Token;
+use crate::{ssl, Token};
 
 /// Server builder
 pub struct ServerBuilder {
     threads: usize,
     token: Token,
+    backlog: i32,
     workers: Vec<(usize, WorkerClient)>,
     services: Vec<Box<InternalServiceFactory>>,
     sockets: Vec<(Token, net::TcpListener)>,
@@ -54,6 +54,7 @@ impl ServerBuilder {
             services: Vec::new(),
             sockets: Vec::new(),
             accept: AcceptLoop::new(server.clone()),
+            backlog: 2048,
             exit: false,
             shutdown_timeout: Duration::from_secs(30),
             no_signals: false,
@@ -71,6 +72,21 @@ impl ServerBuilder {
         self
     }
 
+    /// Set the maximum number of pending connections.
+    ///
+    /// This refers to the number of clients that can be waiting to be served.
+    /// Exceeding this number results in the client getting an error when
+    /// attempting to connect. It should only affect servers under significant
+    /// load.
+    ///
+    /// Generally set in the 64-2048 range. Default value is 2048.
+    ///
+    /// This method should be called before `bind()` method call.
+    pub fn backlog(mut self, num: i32) -> Self {
+        self.backlog = num;
+        self
+    }
+
     /// Sets the maximum per-worker number of concurrent connections.
     ///
     /// All socket listeners will stop accepting connections when this limit is
@@ -82,9 +98,18 @@ impl ServerBuilder {
         self
     }
 
-    /// Stop actix system.
+    /// Sets the maximum per-worker concurrent connection establish process.
     ///
-    /// `SystemExit` message stops currently running system.
+    /// All listeners will stop accepting connections when this limit is reached. It
+    /// can be used to limit the global SSL CPU usage.
+    ///
+    /// By default max connections is set to a 256.
+    pub fn maxconnrate(self, num: usize) -> Self {
+        ssl::max_concurrent_ssl_connect(num);
+        self
+    }
+
+    /// Stop actix system.
     pub fn system_exit(mut self) -> Self {
         self.exit = true;
         self
@@ -117,7 +142,7 @@ impl ServerBuilder {
     where
         F: Fn(&mut ServiceConfig) -> io::Result<()>,
     {
-        let mut cfg = ServiceConfig::new(self.threads);
+        let mut cfg = ServiceConfig::new(self.threads, self.backlog);
 
         f(&mut cfg)?;
 
@@ -138,19 +163,19 @@ impl ServerBuilder {
     /// Add new service to the server.
     pub fn bind<F, U, N: AsRef<str>>(mut self, name: N, addr: U, factory: F) -> io::Result<Self>
     where
-        F: StreamServiceFactory,
+        F: ServiceFactory,
         U: net::ToSocketAddrs,
     {
-        let sockets = bind_addr(addr)?;
-
-        let token = self.token.next();
-        self.services.push(StreamNewService::create(
-            name.as_ref().to_string(),
-            token,
-            factory,
-        ));
+        let sockets = bind_addr(addr, self.backlog)?;
 
         for lst in sockets {
+            let token = self.token.next();
+            self.services.push(StreamNewService::create(
+                name.as_ref().to_string(),
+                token,
+                factory.clone(),
+                lst.local_addr()?,
+            ));
             self.sockets.push((token, lst));
         }
         Ok(self)
@@ -162,38 +187,19 @@ impl ServerBuilder {
         name: N,
         lst: net::TcpListener,
         factory: F,
-    ) -> Self
+    ) -> io::Result<Self>
     where
-        F: StreamServiceFactory,
+        F: ServiceFactory,
     {
         let token = self.token.next();
         self.services.push(StreamNewService::create(
             name.as_ref().to_string(),
             token,
             factory,
+            lst.local_addr()?,
         ));
         self.sockets.push((token, lst));
-        self
-    }
-
-    /// Add new service to the server.
-    pub fn listen2<F, N: AsRef<str>>(
-        mut self,
-        name: N,
-        lst: net::TcpListener,
-        factory: F,
-    ) -> Self
-    where
-        F: ServiceFactory,
-    {
-        let token = self.token.next();
-        self.services.push(ServiceNewService::create(
-            name.as_ref().to_string(),
-            token,
-            factory,
-        ));
-        self.sockets.push((token, lst));
-        self
+        Ok(self)
     }
 
     /// Spawn new thread and start listening for incoming connections.
@@ -204,24 +210,20 @@ 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() {
+    /// fn main() -> std::io::Result<()> {
     ///     Server::new().
     ///         .service(
-    ///            HttpServer::new(|| App::new().resource("/", |r| r.h(|_| HttpResponse::Ok())))
+    ///            HttpServer::new(|| App::new().service(web::service("/").to(|| HttpResponse::Ok())))
     ///                .bind("127.0.0.1:0")
-    ///                .expect("Can not bind to 127.0.0.1:0"))
-    ///         .run();
+    ///         .run()
     /// }
     /// ```
-    pub fn run(self) {
+    pub fn run(self) -> io::Result<()> {
         let sys = System::new("http-server");
         self.start();
-        sys.run();
+        sys.run()
     }
 
     /// Starts processing incoming connections and return server controller.
@@ -408,12 +410,15 @@ impl Future for ServerBuilder {
     }
 }
 
-pub(super) fn bind_addr<S: net::ToSocketAddrs>(addr: S) -> io::Result<Vec<net::TcpListener>> {
+pub(super) fn bind_addr<S: net::ToSocketAddrs>(
+    addr: S,
+    backlog: i32,
+) -> io::Result<Vec<net::TcpListener>> {
     let mut err = None;
     let mut succ = false;
     let mut sockets = Vec::new();
     for addr in addr.to_socket_addrs()? {
-        match create_tcp_listener(addr) {
+        match create_tcp_listener(addr, backlog) {
             Ok(lst) => {
                 succ = true;
                 sockets.push(lst);
@@ -436,12 +441,12 @@ pub(super) fn bind_addr<S: net::ToSocketAddrs>(addr: S) -> io::Result<Vec<net::T
     }
 }
 
-fn create_tcp_listener(addr: net::SocketAddr) -> io::Result<net::TcpListener> {
+fn create_tcp_listener(addr: net::SocketAddr, backlog: i32) -> io::Result<net::TcpListener> {
     let builder = match addr {
         net::SocketAddr::V4(_) => TcpBuilder::new_v4()?,
         net::SocketAddr::V6(_) => TcpBuilder::new_v6()?,
     };
     builder.reuse_address(true)?;
     builder.bind(addr)?;
-    Ok(builder.listen(1024)?)
+    Ok(builder.listen(backlog)?)
 }

actix-server/src/lib.rs

@@ -2,18 +2,23 @@
 
 mod accept;
 mod builder;
-mod config;
 mod counter;
 mod server;
+mod service_config;
 mod services;
 mod signals;
 pub mod ssl;
 mod worker;
 
+pub use actix_server_config::{Io, Protocol, ServerConfig};
+
 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::service_config::{ServiceConfig, ServiceRuntime};
+pub use self::services::ServiceFactory;
+
+#[doc(hidden)]
+pub use self::services::ServiceFactory as StreamServiceFactory;
 
 /// Socket id token
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -28,6 +33,6 @@ impl Token {
 }
 
 /// Start server building process
-pub fn build() -> ServerBuilder {
+pub fn new() -> ServerBuilder {
     ServerBuilder::default()
 }

actix-server/src/service_config.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 use std::{fmt, io, net};
 
+use actix_server_config::Io;
 use actix_service::{IntoNewService, NewService};
 use futures::future::{join_all, Future};
 use log::error;
@@ -18,12 +19,14 @@ pub struct ServiceConfig {
     pub(crate) services: Vec<(String, net::TcpListener)>,
     pub(crate) apply: Option<Box<ServiceRuntimeConfiguration>>,
     pub(crate) threads: usize,
+    pub(crate) backlog: i32,
 }
 
 impl ServiceConfig {
-    pub(super) fn new(threads: usize) -> ServiceConfig {
+    pub(super) fn new(threads: usize, backlog: i32) -> ServiceConfig {
         ServiceConfig {
             threads,
+            backlog,
             services: Vec::new(),
             apply: None,
         }
@@ -42,7 +45,7 @@ impl ServiceConfig {
     where
         U: net::ToSocketAddrs,
     {
-        let sockets = bind_addr(addr)?;
+        let sockets = bind_addr(addr, self.backlog)?;
 
         for lst in sockets {
             self.listen(name.as_ref(), lst);
@@ -114,7 +117,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| {
@@ -170,7 +173,7 @@ impl ServiceRuntime {
     pub fn service<T, F>(&mut self, name: &str, service: F)
     where
         F: IntoNewService<T>,
-        T: NewService<Request = TcpStream, Response = ()> + 'static,
+        T: NewService<Request = Io<TcpStream>, Response = ()> + 'static,
         T::Future: 'static,
         T::Service: 'static,
         T::InitError: fmt::Debug,
@@ -206,7 +209,7 @@ struct ServiceFactory<T> {
 
 impl<T> NewService for ServiceFactory<T>
 where
-    T: NewService<Request = TcpStream, Response = ()>,
+    T: NewService<Request = Io<TcpStream>, Response = ()>,
     T::Future: 'static,
     T::Service: 'static,
     T::Error: 'static,
@@ -219,8 +222,8 @@ where
     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/services.rs

@@ -1,7 +1,8 @@
-use std::net;
+use std::net::{self, SocketAddr};
 use std::time::Duration;
 
 use actix_rt::spawn;
+use actix_server_config::{Io, ServerConfig};
 use actix_service::{NewService, Service};
 use futures::future::{err, ok, FutureResult};
 use futures::{Future, Poll};
@@ -13,7 +14,7 @@ use super::Token;
 use crate::counter::CounterGuard;
 
 /// Server message
-pub enum ServerMessage {
+pub(crate) enum ServerMessage {
     /// New stream
     Connect(net::TcpStream),
     /// Gracefull shutdown
@@ -22,14 +23,8 @@ pub enum ServerMessage {
     ForceShutdown,
 }
 
-pub trait StreamServiceFactory: Send + Clone + 'static {
-    type NewService: NewService<Request = TcpStream>;
-
-    fn create(&self) -> Self::NewService;
-}
-
 pub trait ServiceFactory: Send + Clone + 'static {
-    type NewService: NewService<Request = ServerMessage>;
+    type NewService: NewService<ServerConfig, Request = Io<TcpStream>>;
 
     fn create(&self) -> Self::NewService;
 }
@@ -63,7 +58,7 @@ impl<T> StreamService<T> {
 
 impl<T> Service for StreamService<T>
 where
-    T: Service<Request = TcpStream>,
+    T: Service<Request = Io<TcpStream>>,
     T::Future: 'static,
     T::Error: 'static,
 {
@@ -84,7 +79,7 @@ where
                 });
 
                 if let Ok(stream) = stream {
-                    spawn(self.service.call(stream).then(move |res| {
+                    spawn(self.service.call(Io::new(stream)).then(move |res| {
                         drop(guard);
                         res.map_err(|_| ()).map(|_| ())
                     }));
@@ -98,104 +93,35 @@ where
     }
 }
 
-pub(crate) struct ServerService<T> {
-    service: T,
-}
-
-impl<T> ServerService<T> {
-    fn new(service: T) -> Self {
-        ServerService { service }
-    }
-}
-
-impl<T> Service for ServerService<T>
-where
-    T: Service<Request = ServerMessage>,
-    T::Future: 'static,
-    T::Error: 'static,
-{
-    type Request = (Option<CounterGuard>, ServerMessage);
-    type Response = ();
-    type Error = ();
-    type Future = FutureResult<(), ()>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready().map_err(|_| ())
-    }
-
-    fn call(&mut self, (guard, req): (Option<CounterGuard>, ServerMessage)) -> Self::Future {
-        spawn(self.service.call(req).then(move |res| {
-            drop(guard);
-            res.map_err(|_| ()).map(|_| ())
-        }));
-        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> {
+pub(crate) struct StreamNewService<F: ServiceFactory> {
     name: String,
     inner: F,
     token: Token,
+    addr: SocketAddr,
 }
 
 impl<F> StreamNewService<F>
 where
-    F: StreamServiceFactory,
+    F: ServiceFactory,
 {
-    pub(crate) fn create(name: String, token: Token, inner: F) -> Box<InternalServiceFactory> {
-        Box::new(Self { name, token, inner })
+    pub(crate) fn create(
+        name: String,
+        token: Token,
+        inner: F,
+        addr: SocketAddr,
+    ) -> Box<InternalServiceFactory> {
+        Box::new(Self {
+            name,
+            token,
+            inner,
+            addr,
+        })
     }
 }
 
 impl<F> InternalServiceFactory for StreamNewService<F>
 where
-    F: StreamServiceFactory,
+    F: ServiceFactory,
 {
     fn name(&self, _: Token) -> &str {
         &self.name
@@ -206,15 +132,17 @@ where
             name: self.name.clone(),
             inner: self.inner.clone(),
             token: self.token,
+            addr: self.addr,
         })
     }
 
     fn create(&self) -> Box<Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
         let token = self.token;
+        let config = ServerConfig::new(self.addr);
         Box::new(
             self.inner
                 .create()
-                .new_service()
+                .new_service(&config)
                 .map_err(|_| ())
                 .map(move |inner| {
                     let service: BoxedServerService = Box::new(StreamService::new(inner));
@@ -241,19 +169,7 @@ impl InternalServiceFactory for Box<InternalServiceFactory> {
 impl<F, T> ServiceFactory for F
 where
     F: Fn() -> T + Send + Clone + 'static,
-    T: NewService<Request = ServerMessage>,
-{
-    type NewService = T;
-
-    fn create(&self) -> T {
-        (self)()
-    }
-}
-
-impl<F, T> StreamServiceFactory for F
-where
-    F: Fn() -> T + Send + Clone + 'static,
-    T: NewService<Request = TcpStream>,
+    T: NewService<ServerConfig, Request = Io<TcpStream>>,
 {
     type NewService = T;
 

actix-server/src/ssl/mod.rs

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

actix-server/src/ssl/nativetls.rs

@@ -6,18 +6,19 @@ use futures::{future::ok, future::FutureResult, Async, Future, Poll};
 use native_tls::{self, Error, HandshakeError, TlsAcceptor};
 use tokio_io::{AsyncRead, AsyncWrite};
 
-use super::MAX_CONN_COUNTER;
 use crate::counter::{Counter, CounterGuard};
+use crate::ssl::MAX_CONN_COUNTER;
+use crate::{Io, Protocol, ServerConfig};
 
 /// Support `SSL` connections via native-tls package
 ///
 /// `tls` feature enables `NativeTlsAcceptor` type
-pub struct NativeTlsAcceptor<T> {
+pub struct NativeTlsAcceptor<T, P = ()> {
     acceptor: TlsAcceptor,
-    io: PhantomData<T>,
+    io: PhantomData<(T, P)>,
 }
 
-impl<T: AsyncRead + AsyncWrite> NativeTlsAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite, P> NativeTlsAcceptor<T, P> {
     /// Create `NativeTlsAcceptor` instance
     pub fn new(acceptor: TlsAcceptor) -> Self {
         NativeTlsAcceptor {
@@ -27,7 +28,7 @@ impl<T: AsyncRead + AsyncWrite> NativeTlsAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> Clone for NativeTlsAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite, P> Clone for NativeTlsAcceptor<T, P> {
     fn clone(&self) -> Self {
         Self {
             acceptor: self.acceptor.clone(),
@@ -36,15 +37,17 @@ impl<T: AsyncRead + AsyncWrite> Clone for NativeTlsAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService for NativeTlsAcceptor<T> {
-    type Request = T;
-    type Response = TlsStream<T>;
+impl<T: AsyncRead + AsyncWrite, P> NewService<ServerConfig> for NativeTlsAcceptor<T, P> {
+    type Request = Io<T, P>;
+    type Response = Io<TlsStream<T>, P>;
     type Error = Error;
-    type Service = NativeTlsAcceptorService<T>;
+    type Service = NativeTlsAcceptorService<T, P>;
     type InitError = ();
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &ServerConfig) -> Self::Future {
+        cfg.set_secure();
+
         MAX_CONN_COUNTER.with(|conns| {
             ok(NativeTlsAcceptorService {
                 acceptor: self.acceptor.clone(),
@@ -55,17 +58,17 @@ impl<T: AsyncRead + AsyncWrite> NewService for NativeTlsAcceptor<T> {
     }
 }
 
-pub struct NativeTlsAcceptorService<T> {
+pub struct NativeTlsAcceptorService<T, P> {
     acceptor: TlsAcceptor,
-    io: PhantomData<T>,
+    io: PhantomData<(T, P)>,
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service for NativeTlsAcceptorService<T> {
-    type Request = T;
-    type Response = TlsStream<T>;
+impl<T: AsyncRead + AsyncWrite, P> Service for NativeTlsAcceptorService<T, P> {
+    type Request = Io<T, P>;
+    type Response = Io<TlsStream<T>, P>;
     type Error = Error;
-    type Future = Accept<T>;
+    type Future = Accept<T, P>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         if self.conns.available() {
@@ -75,10 +78,12 @@ impl<T: AsyncRead + AsyncWrite> Service for NativeTlsAcceptorService<T> {
         }
     }
 
-    fn call(&mut self, req: T) -> Self::Future {
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        let (io, params, _) = req.into_parts();
         Accept {
             _guard: self.conns.get(),
-            inner: Some(self.acceptor.accept(req)),
+            inner: Some(self.acceptor.accept(io)),
+            params: Some(params),
         }
     }
 }
@@ -97,21 +102,30 @@ pub struct TlsStream<S> {
 
 /// Future returned from `NativeTlsAcceptor::accept` which will resolve
 /// once the accept handshake has finished.
-pub struct Accept<S> {
+pub struct Accept<S, P> {
     inner: Option<Result<native_tls::TlsStream<S>, HandshakeError<S>>>,
+    params: Option<P>,
     _guard: CounterGuard,
 }
 
-impl<Io: AsyncRead + AsyncWrite> Future for Accept<Io> {
-    type Item = TlsStream<Io>;
+impl<T: AsyncRead + AsyncWrite, P> Future for Accept<T, P> {
+    type Item = Io<TlsStream<T>, P>;
     type Error = Error;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
         match self.inner.take().expect("cannot poll MidHandshake twice") {
-            Ok(stream) => Ok(TlsStream { inner: stream }.into()),
+            Ok(stream) => Ok(Async::Ready(Io::from_parts(
+                TlsStream { inner: stream },
+                self.params.take().unwrap(),
+                Protocol::Unknown,
+            ))),
             Err(HandshakeError::Failure(e)) => Err(e),
             Err(HandshakeError::WouldBlock(s)) => match s.handshake() {
-                Ok(stream) => Ok(TlsStream { inner: stream }.into()),
+                Ok(stream) => Ok(Async::Ready(Io::from_parts(
+                    TlsStream { inner: stream },
+                    self.params.take().unwrap(),
+                    Protocol::Unknown,
+                ))),
                 Err(HandshakeError::Failure(e)) => Err(e),
                 Err(HandshakeError::WouldBlock(s)) => {
                     self.inner = Some(Err(HandshakeError::WouldBlock(s)));

actix-server/src/ssl/openssl.rs

@@ -6,18 +6,19 @@ use openssl::ssl::{HandshakeError, SslAcceptor};
 use tokio_io::{AsyncRead, AsyncWrite};
 use tokio_openssl::{AcceptAsync, SslAcceptorExt, SslStream};
 
-use super::MAX_CONN_COUNTER;
 use crate::counter::{Counter, CounterGuard};
+use crate::ssl::MAX_CONN_COUNTER;
+use crate::{Io, Protocol, ServerConfig};
 
 /// Support `SSL` connections via openssl package
 ///
 /// `ssl` feature enables `OpensslAcceptor` type
-pub struct OpensslAcceptor<T> {
+pub struct OpensslAcceptor<T, P = ()> {
     acceptor: SslAcceptor,
-    io: PhantomData<T>,
+    io: PhantomData<(T, P)>,
 }
 
-impl<T> OpensslAcceptor<T> {
+impl<T, P> OpensslAcceptor<T, P> {
     /// Create default `OpensslAcceptor`
     pub fn new(acceptor: SslAcceptor) -> Self {
         OpensslAcceptor {
@@ -27,7 +28,7 @@ impl<T> OpensslAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> Clone for OpensslAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite, P> Clone for OpensslAcceptor<T, P> {
     fn clone(&self) -> Self {
         Self {
             acceptor: self.acceptor.clone(),
@@ -36,15 +37,17 @@ impl<T: AsyncRead + AsyncWrite> Clone for OpensslAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService for OpensslAcceptor<T> {
-    type Request = T;
-    type Response = SslStream<T>;
+impl<T: AsyncRead + AsyncWrite, P> NewService<ServerConfig> for OpensslAcceptor<T, P> {
+    type Request = Io<T, P>;
+    type Response = Io<SslStream<T>, P>;
     type Error = HandshakeError<T>;
-    type Service = OpensslAcceptorService<T>;
+    type Service = OpensslAcceptorService<T, P>;
     type InitError = ();
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &ServerConfig) -> Self::Future {
+        cfg.set_secure();
+
         MAX_CONN_COUNTER.with(|conns| {
             ok(OpensslAcceptorService {
                 acceptor: self.acceptor.clone(),
@@ -55,17 +58,17 @@ impl<T: AsyncRead + AsyncWrite> NewService for OpensslAcceptor<T> {
     }
 }
 
-pub struct OpensslAcceptorService<T> {
+pub struct OpensslAcceptorService<T, P> {
     acceptor: SslAcceptor,
-    io: PhantomData<T>,
     conns: Counter,
+    io: PhantomData<(T, P)>,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service for OpensslAcceptorService<T> {
-    type Request = T;
-    type Response = SslStream<T>;
+impl<T: AsyncRead + AsyncWrite, P> Service for OpensslAcceptorService<T, P> {
+    type Request = Io<T, P>;
+    type Response = Io<SslStream<T>, P>;
     type Error = HandshakeError<T>;
-    type Future = OpensslAcceptorServiceFut<T>;
+    type Future = OpensslAcceptorServiceFut<T, P>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         if self.conns.available() {
@@ -75,27 +78,52 @@ impl<T: AsyncRead + AsyncWrite> Service for OpensslAcceptorService<T> {
         }
     }
 
-    fn call(&mut self, req: T) -> Self::Future {
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        let (io, params, _) = req.into_parts();
         OpensslAcceptorServiceFut {
             _guard: self.conns.get(),
-            fut: SslAcceptorExt::accept_async(&self.acceptor, req),
+            fut: SslAcceptorExt::accept_async(&self.acceptor, io),
+            params: Some(params),
         }
     }
 }
 
-pub struct OpensslAcceptorServiceFut<T>
+pub struct OpensslAcceptorServiceFut<T, P>
 where
     T: AsyncRead + AsyncWrite,
 {
     fut: AcceptAsync<T>,
+    params: Option<P>,
     _guard: CounterGuard,
 }
 
-impl<T: AsyncRead + AsyncWrite> Future for OpensslAcceptorServiceFut<T> {
-    type Item = SslStream<T>;
+impl<T: AsyncRead + AsyncWrite, P> Future for OpensslAcceptorServiceFut<T, P> {
+    type Item = Io<SslStream<T>, P>;
     type Error = HandshakeError<T>;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        self.fut.poll()
+        let io = futures::try_ready!(self.fut.poll());
+        let proto = if let Some(protos) = io.get_ref().ssl().selected_alpn_protocol() {
+            const H2: &[u8] = b"\x02h2";
+            const HTTP10: &[u8] = b"\x08http/1.0";
+            const HTTP11: &[u8] = b"\x08http/1.1";
+
+            if protos.windows(3).any(|window| window == H2) {
+                Protocol::Http2
+            } else if protos.windows(9).any(|window| window == HTTP11) {
+                Protocol::Http11
+            } else if protos.windows(9).any(|window| window == HTTP10) {
+                Protocol::Http10
+            } else {
+                Protocol::Unknown
+            }
+        } else {
+            Protocol::Unknown
+        };
+        Ok(Async::Ready(Io::from_parts(
+            io,
+            self.params.take().unwrap(),
+            proto,
+        )))
     }
 }

actix-server/src/ssl/rustls.rs

@@ -8,18 +8,19 @@ use rustls::{ServerConfig, ServerSession};
 use tokio_io::{AsyncRead, AsyncWrite};
 use tokio_rustls::{Accept, TlsAcceptor, TlsStream};
 
-use super::MAX_CONN_COUNTER;
 use crate::counter::{Counter, CounterGuard};
+use crate::ssl::MAX_CONN_COUNTER;
+use crate::{Io, Protocol, ServerConfig as SrvConfig};
 
 /// Support `SSL` connections via rustls package
 ///
 /// `rust-tls` feature enables `RustlsAcceptor` type
-pub struct RustlsAcceptor<T> {
+pub struct RustlsAcceptor<T, P = ()> {
     config: Arc<ServerConfig>,
-    io: PhantomData<T>,
+    io: PhantomData<(T, P)>,
 }
 
-impl<T: AsyncRead + AsyncWrite> RustlsAcceptor<T> {
+impl<T: AsyncRead + AsyncWrite, P> RustlsAcceptor<T, P> {
     /// Create `RustlsAcceptor` new service
     pub fn new(config: ServerConfig) -> Self {
         RustlsAcceptor {
@@ -29,7 +30,7 @@ impl<T: AsyncRead + AsyncWrite> RustlsAcceptor<T> {
     }
 }
 
-impl<T> Clone for RustlsAcceptor<T> {
+impl<T, P> Clone for RustlsAcceptor<T, P> {
     fn clone(&self) -> Self {
         Self {
             config: self.config.clone(),
@@ -38,15 +39,17 @@ impl<T> Clone for RustlsAcceptor<T> {
     }
 }
 
-impl<T: AsyncRead + AsyncWrite> NewService for RustlsAcceptor<T> {
-    type Request = T;
-    type Response = TlsStream<T, ServerSession>;
+impl<T: AsyncRead + AsyncWrite, P> NewService<SrvConfig> for RustlsAcceptor<T, P> {
+    type Request = Io<T, P>;
+    type Response = Io<TlsStream<T, ServerSession>, P>;
     type Error = io::Error;
-    type Service = RustlsAcceptorService<T>;
+    type Service = RustlsAcceptorService<T, P>;
     type InitError = ();
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
+        cfg.set_secure();
+
         MAX_CONN_COUNTER.with(|conns| {
             ok(RustlsAcceptorService {
                 acceptor: self.config.clone().into(),
@@ -57,17 +60,17 @@ impl<T: AsyncRead + AsyncWrite> NewService for RustlsAcceptor<T> {
     }
 }
 
-pub struct RustlsAcceptorService<T> {
+pub struct RustlsAcceptorService<T, P> {
     acceptor: TlsAcceptor,
-    io: PhantomData<T>,
+    io: PhantomData<(T, P)>,
     conns: Counter,
 }
 
-impl<T: AsyncRead + AsyncWrite> Service for RustlsAcceptorService<T> {
-    type Request = T;
-    type Response = TlsStream<T, ServerSession>;
+impl<T: AsyncRead + AsyncWrite, P> Service for RustlsAcceptorService<T, P> {
+    type Request = Io<T, P>;
+    type Response = Io<TlsStream<T, ServerSession>, P>;
     type Error = io::Error;
-    type Future = RustlsAcceptorServiceFut<T>;
+    type Future = RustlsAcceptorServiceFut<T, P>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         if self.conns.available() {
@@ -77,27 +80,35 @@ impl<T: AsyncRead + AsyncWrite> Service for RustlsAcceptorService<T> {
         }
     }
 
-    fn call(&mut self, req: T) -> Self::Future {
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        let (io, params, _) = req.into_parts();
         RustlsAcceptorServiceFut {
             _guard: self.conns.get(),
-            fut: self.acceptor.accept(req),
+            fut: self.acceptor.accept(io),
+            params: Some(params),
         }
     }
 }
 
-pub struct RustlsAcceptorServiceFut<T>
+pub struct RustlsAcceptorServiceFut<T, P>
 where
     T: AsyncRead + AsyncWrite,
 {
     fut: Accept<T>,
+    params: Option<P>,
     _guard: CounterGuard,
 }
 
-impl<T: AsyncRead + AsyncWrite> Future for RustlsAcceptorServiceFut<T> {
-    type Item = TlsStream<T, ServerSession>;
+impl<T: AsyncRead + AsyncWrite, P> Future for RustlsAcceptorServiceFut<T, P> {
+    type Item = Io<TlsStream<T, ServerSession>, P>;
     type Error = io::Error;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        self.fut.poll()
+        let io = futures::try_ready!(self.fut.poll());
+        Ok(Async::Ready(Io::from_parts(
+            io,
+            self.params.take().unwrap(),
+            Protocol::Unknown,
+        )))
     }
 }

actix-server/tests/test_server.rs

@@ -0,0 +1,147 @@
+use std::io::Read;
+use std::sync::mpsc;
+use std::{net, thread, time};
+
+use actix_codec::{BytesCodec, Framed};
+use actix_server::{Io, Server, ServerConfig};
+use actix_service::{fn_cfg_factory, fn_service, IntoService};
+use bytes::Bytes;
+use futures::{Future, Sink};
+use net2::TcpBuilder;
+use tokio_tcp::TcpStream;
+
+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()
+}
+
+#[test]
+fn test_bind() {
+    let addr = unused_addr();
+
+    thread::spawn(move || {
+        Server::build()
+            .bind("test", addr, move || {
+                fn_cfg_factory(move |cfg: &ServerConfig| {
+                    assert_eq!(cfg.local_addr(), addr);
+                    Ok::<_, ()>((|_| Ok::<_, ()>(())).into_service())
+                })
+            })
+            .unwrap()
+            .run()
+    });
+
+    thread::sleep(time::Duration::from_millis(500));
+    assert!(net::TcpStream::connect(addr).is_ok());
+}
+
+#[test]
+fn test_bind_no_config() {
+    let addr = unused_addr();
+    let (tx, rx) = mpsc::channel();
+
+    thread::spawn(move || {
+        let sys = actix_rt::System::new("test");
+        let srv = Server::build()
+            .bind("test", addr, move || fn_service(|_| Ok::<_, ()>(())))
+            .unwrap()
+            .start();
+        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = sys.run();
+    });
+    let (_, sys) = rx.recv().unwrap();
+    assert!(net::TcpStream::connect(addr).is_ok());
+    let _ = sys.stop();
+}
+
+#[test]
+fn test_listen() {
+    let addr = unused_addr();
+
+    thread::spawn(move || {
+        let lst = net::TcpListener::bind(addr).unwrap();
+        Server::build()
+            .listen("test", lst, move || {
+                fn_cfg_factory(move |cfg: &ServerConfig| {
+                    assert_eq!(cfg.local_addr(), addr);
+                    Ok::<_, ()>((|_| Ok::<_, ()>(())).into_service())
+                })
+            })
+            .unwrap()
+            .run()
+    });
+
+    thread::sleep(time::Duration::from_millis(500));
+    assert!(net::TcpStream::connect(addr).is_ok());
+}
+
+#[test]
+#[cfg(unix)]
+fn test_start() {
+    let addr = unused_addr();
+    let (tx, rx) = mpsc::channel();
+
+    thread::spawn(move || {
+        let sys = actix_rt::System::new("test");
+
+        let srv = Server::build()
+            .backlog(100)
+            .bind("test", addr, move || {
+                fn_cfg_factory(move |cfg: &ServerConfig| {
+                    assert_eq!(cfg.local_addr(), addr);
+                    Ok::<_, ()>(
+                        (|io: Io<TcpStream>| {
+                            Framed::new(io.into_parts().0, BytesCodec)
+                                .send(Bytes::from_static(b"test"))
+                                .then(|_| Ok::<_, ()>(()))
+                        })
+                        .into_service(),
+                    )
+                })
+            })
+            .unwrap()
+            .start();
+
+        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = sys.run();
+    });
+    let (srv, sys) = rx.recv().unwrap();
+
+    let mut buf = [0u8; 4];
+    let mut conn = net::TcpStream::connect(addr).unwrap();
+    let _ = conn.read_exact(&mut buf);
+    assert_eq!(buf, b"test"[..]);
+
+    // pause
+    let _ = srv.pause();
+    thread::sleep(time::Duration::from_millis(200));
+    let mut conn = net::TcpStream::connect(addr).unwrap();
+    conn.set_read_timeout(Some(time::Duration::from_millis(100)))
+        .unwrap();
+    let res = conn.read_exact(&mut buf);
+    assert!(res.is_err());
+
+    // resume
+    let _ = srv.resume();
+    thread::sleep(time::Duration::from_millis(100));
+    assert!(net::TcpStream::connect(addr).is_ok());
+    assert!(net::TcpStream::connect(addr).is_ok());
+    assert!(net::TcpStream::connect(addr).is_ok());
+
+    let mut buf = [0u8; 4];
+    let mut conn = net::TcpStream::connect(addr).unwrap();
+    let _ = conn.read_exact(&mut buf);
+    assert_eq!(buf, b"test"[..]);
+
+    // stop
+    let _ = srv.stop(false);
+    thread::sleep(time::Duration::from_millis(100));
+    assert!(net::TcpStream::connect(addr).is_err());
+
+    thread::sleep(time::Duration::from_millis(100));
+    let _ = sys.stop();
+}

actix-service/CHANGES.md

@@ -1,5 +1,57 @@
 # Changes
 
+## [0.3.3] - 2019-03-09
+
+### Added
+
+* Add `ApplyTransform` new service for transform and new service.
+
+* Add `NewService::apply_cfg()` combinator, allows to use
+  nested `NewService` with different config parameter.
+
+### Changed
+
+* Revert IntoFuture change
+
+
+## [0.3.2] - 2019-03-04
+
+### Changed
+
+* Change `NewService::Future` and `Transform::Future` to the `IntoFuture` trait.
+
+* Export `AndThenTransform` type
+
+
+## [0.3.1] - 2019-03-04
+
+### Changed
+
+* Simplify Transform trait
+
+
+## [0.3.0] - 2019-03-02
+
+## Added
+
+* Added boxed NewService and Service.
+
+## Changed
+
+* Added `Config` parameter to `NewService` trait.
+
+* Added `Config` parameter to `NewTransform` trait.
+
+
+## [0.2.2] - 2019-02-19
+
+### Added
+
+* Added `NewService` impl for `Rc<S> where S: NewService`
+
+* Added `NewService` impl for `Arc<S> where S: NewService`
+
+
 ## [0.2.1] - 2019-02-03
 
 ### Changed

actix-service/Cargo.toml

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

actix-service/src/and_then.rs

@@ -1,3 +1,5 @@
+use std::marker::PhantomData;
+
 use futures::{try_ready, Async, Future, Poll};
 
 use super::{IntoNewService, NewService, Service};
@@ -105,29 +107,31 @@ 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<F: IntoNewService<B>>(a: A, f: F) -> Self
+    pub fn new<F: IntoNewService<B, C>>(a: A, f: F) -> Self
     where
-        A: NewService,
-        B: NewService<Request = 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> NewService for AndThenNewService<A, B>
+impl<A, B, C> NewService<C> for AndThenNewService<A, B, C>
 where
-    A: NewService,
-    B: NewService<Request = 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;
@@ -135,14 +139,14 @@ where
     type Service = AndThen<A::Service, B::Service>;
 
     type InitError = A::InitError;
-    type Future = AndThenNewServiceFuture<A, B>;
+    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,
@@ -151,14 +155,15 @@ where
         Self {
             a: self.a.clone(),
             b: self.b.clone(),
+            _t: PhantomData,
         }
     }
 }
 
-pub struct AndThenNewServiceFuture<A, B>
+pub struct AndThenNewServiceFuture<A, B, C>
 where
-    A: NewService,
-    B: NewService<Request = A::Response>,
+    A: NewService<C>,
+    B: NewService<C, Request = A::Response>,
 {
     fut_b: B::Future,
     fut_a: A::Future,
@@ -166,10 +171,10 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B> AndThenNewServiceFuture<A, B>
+impl<A, B, C> AndThenNewServiceFuture<A, B, C>
 where
-    A: NewService,
-    B: NewService<Request = A::Response>,
+    A: NewService<C>,
+    B: NewService<C, Request = A::Response>,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
         AndThenNewServiceFuture {
@@ -181,10 +186,10 @@ where
     }
 }
 
-impl<A, B> Future for AndThenNewServiceFuture<A, B>
+impl<A, B, C> Future for AndThenNewServiceFuture<A, B, C>
 where
-    A: NewService,
-    B: NewService<Request = 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;
@@ -286,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

@@ -1,168 +1,57 @@
+use std::rc::Rc;
+
 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()),
-        }
-    }
-}
+use crate::and_then::AndThen;
+use crate::from_err::FromErr;
+use crate::{NewService, Transform};
 
 /// `Apply` new service combinator
-pub struct AndThenTransformNewService<T, A, B> {
+pub struct AndThenTransform<T, A, B, C> {
     a: A,
     b: B,
-    t: T,
+    t: Rc<T>,
+    _t: std::marker::PhantomData<C>,
 }
 
-impl<T, A, B> AndThenTransformNewService<T, A, B>
+impl<T, A, B, C> AndThenTransform<T, A, B, C>
 where
-    A: NewService,
-    B: NewService<Error = A::Error, InitError = A::InitError>,
-    T: NewTransform<B::Service, Request = A::Response, InitError = A::InitError>,
+    A: NewService<C>,
+    B: NewService<C, InitError = A::InitError>,
+    T: Transform<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 }
+        Self {
+            a,
+            b,
+            t: Rc::new(t),
+            _t: std::marker::PhantomData,
+        }
     }
 }
 
-impl<T, A, B> Clone for AndThenTransformNewService<T, A, B>
+impl<T, A, B, C> Clone for AndThenTransform<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> NewService for AndThenTransformNewService<T, A, B>
+impl<T, A, B, C> NewService<C> for AndThenTransform<T, A, B, C>
 where
-    A: NewService,
-    B: NewService<Error = A::Error, InitError = A::InitError>,
-    T: NewTransform<B::Service, Request = A::Response, InitError = A::InitError>,
+    A: NewService<C>,
+    B: NewService<C, InitError = A::InitError>,
+    T: Transform<B::Service, Request = A::Response, InitError = A::InitError>,
     T::Error: From<A::Error>,
 {
     type Request = A::Request;
@@ -170,50 +59,50 @@ where
     type Error = T::Error;
 
     type InitError = T::InitError;
-    type Service = AndThenTransform<T::Transform, A::Service, B::Service>;
-    type Future = AndThenTransformNewServiceFuture<T, A, B>;
+    type Service = AndThen<FromErr<A::Service, T::Error>, T::Transform>;
+    type Future = AndThenTransformFuture<T, A, B, C>;
 
-    fn new_service(&self) -> Self::Future {
-        AndThenTransformNewServiceFuture {
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        AndThenTransformFuture {
             a: None,
-            b: None,
             t: None,
-            fut_a: self.a.new_service(),
-            fut_b: self.b.new_service(),
-            fut_t: self.t.new_transform(),
+            t_cell: self.t.clone(),
+            fut_a: self.a.new_service(cfg),
+            fut_b: self.b.new_service(cfg),
+            fut_t: None,
         }
     }
 }
 
-pub struct AndThenTransformNewServiceFuture<T, A, B>
+pub struct AndThenTransformFuture<T, A, B, C>
 where
-    A: NewService,
-    B: NewService<Error = A::Error, InitError = A::InitError>,
-    T: NewTransform<B::Service, Request = A::Response, InitError = A::InitError>,
+    A: NewService<C>,
+    B: NewService<C, InitError = A::InitError>,
+    T: Transform<B::Service, Request = A::Response, InitError = A::InitError>,
     T::Error: From<A::Error>,
 {
-    fut_b: B::Future,
     fut_a: A::Future,
-    fut_t: T::Future,
+    fut_b: B::Future,
+    fut_t: Option<T::Future>,
     a: Option<A::Service>,
-    b: Option<B::Service>,
     t: Option<T::Transform>,
+    t_cell: Rc<T>,
 }
 
-impl<T, A, B> Future for AndThenTransformNewServiceFuture<T, A, B>
+impl<T, A, B, C> Future for AndThenTransformFuture<T, A, B, C>
 where
-    A: NewService,
-    B: NewService<Error = A::Error, InitError = A::InitError>,
-    T: NewTransform<B::Service, Request = A::Response, InitError = A::InitError>,
+    A: NewService<C>,
+    B: NewService<C, InitError = A::InitError>,
+    T: Transform<B::Service, Request = A::Response, InitError = A::InitError>,
     T::Error: From<A::Error>,
 {
-    type Item = AndThenTransform<T::Transform, A::Service, B::Service>;
+    type Item = AndThen<FromErr<A::Service, T::Error>, T::Transform>;
     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.fut_t.is_none() {
+            if let Async::Ready(service) = self.fut_b.poll()? {
+                self.fut_t = Some(self.t_cell.new_transform(service));
             }
         }
 
@@ -223,18 +112,17 @@ where
             }
         }
 
-        if self.b.is_none() {
-            if let Async::Ready(service) = self.fut_b.poll()? {
-                self.b = Some(service);
+        if let Some(ref mut fut) = self.fut_t {
+            if let Async::Ready(transform) = fut.poll()? {
+                self.t = Some(transform);
             }
         }
 
-        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()),
-            }))
+        if self.a.is_some() && self.t.is_some() {
+            Ok(Async::Ready(AndThen::new(
+                FromErr::new(self.a.take().unwrap()),
+                self.t.take().unwrap(),
+            )))
         } else {
             Ok(Async::NotReady)
         }
@@ -269,10 +157,11 @@ mod tests {
     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,
-        );
+        let mut srv = blank
+            .into_service()
+            .apply_fn(Srv, |req: &'static str, srv: &mut Srv| {
+                srv.call(()).map(move |res| (req, res))
+            });
         assert!(srv.poll_ready().is_ok());
         let res = srv.call("srv").poll();
         assert!(res.is_ok());
@@ -287,7 +176,7 @@ mod tests {
             |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() {
+        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
             assert!(srv.poll_ready().is_ok());
             let res = srv.call("srv").poll();
             assert!(res.is_ok());

actix-service/src/and_then_apply_fn.rs

@@ -129,23 +129,27 @@ where
 }
 
 /// `ApplyNewService` new service combinator
-pub struct AndThenApplyNewService<A, B, F, Out> {
+pub struct AndThenApplyNewService<A, B, F, Out, Cfg> {
     a: A,
     b: B,
     f: Cell<F>,
-    r: PhantomData<(Out)>,
+    r: PhantomData<(Out, Cfg)>,
 }
 
-impl<A, B, F, Out> AndThenApplyNewService<A, B, F, Out>
+impl<A, B, F, Out, Cfg> AndThenApplyNewService<A, B, F, Out, Cfg>
 where
-    A: NewService,
-    B: NewService<Error = A::Error, InitError = A::InitError>,
+    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>, B1: IntoNewService<B>>(a: A1, b: B1, f: F) -> Self {
+    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(),
@@ -155,7 +159,7 @@ where
     }
 }
 
-impl<A, B, F, Out> Clone for AndThenApplyNewService<A, B, F, Out>
+impl<A, B, F, Out, Cfg> Clone for AndThenApplyNewService<A, B, F, Out, Cfg>
 where
     A: Clone,
     B: Clone,
@@ -170,10 +174,10 @@ where
     }
 }
 
-impl<A, B, F, Out> NewService for AndThenApplyNewService<A, B, F, Out>
+impl<A, B, F, Out, Cfg> NewService<Cfg> for AndThenApplyNewService<A, B, F, Out, Cfg>
 where
-    A: NewService,
-    B: NewService<Error = A::Error, InitError = A::InitError>,
+    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>,
@@ -181,26 +185,26 @@ where
     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 Service = AndThenApply<A::Service, B::Service, F, Out>;
-    type Future = AndThenApplyNewServiceFuture<A, B, F, Out>;
+    type Future = AndThenApplyNewServiceFuture<A, B, F, Out, Cfg>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &Cfg) -> Self::Future {
         AndThenApplyNewServiceFuture {
             a: None,
             b: None,
             f: self.f.clone(),
-            fut_a: self.a.new_service(),
-            fut_b: self.b.new_service(),
+            fut_a: self.a.new_service(cfg).into_future(),
+            fut_b: self.b.new_service(cfg).into_future(),
         }
     }
 }
 
-pub struct AndThenApplyNewServiceFuture<A, B, F, Out>
+pub struct AndThenApplyNewServiceFuture<A, B, F, Out, Cfg>
 where
-    A: NewService,
-    B: NewService<Error = A::Error, InitError = A::InitError>,
+    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>,
@@ -212,10 +216,10 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B, F, Out> Future for AndThenApplyNewServiceFuture<A, B, F, Out>
+impl<A, B, F, Out, Cfg> Future for AndThenApplyNewServiceFuture<A, B, F, Out, Cfg>
 where
-    A: NewService,
-    B: NewService<Error = A::Error, InitError = A::InitError>,
+    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>,
@@ -254,7 +258,8 @@ mod tests {
     use futures::future::{ok, FutureResult};
     use futures::{Async, Future, Poll};
 
-    use crate::{Blank, BlankNewService, NewService, Service, ServiceExt};
+    use crate::blank::{Blank, BlankNewService};
+    use crate::{NewService, Service, ServiceExt};
 
     #[derive(Clone)]
     struct Srv;
@@ -290,7 +295,7 @@ mod tests {
             || 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/apply.rs

@@ -1,213 +1,172 @@
-use futures::{try_ready, Async, Future, IntoFuture, Poll};
+use std::marker::PhantomData;
 
-use super::{FnNewTransform, FnTransform};
-use super::{
-    IntoNewService, IntoNewTransform, IntoService, IntoTransform, NewService, NewTransform,
-    Service, Transform,
-};
+use futures::{Async, Future, IntoFuture, Poll};
+
+use super::{IntoNewService, IntoService, NewService, Service};
 
 /// `Apply` service combinator
-pub struct Apply<T, S>
+pub struct Apply<T, F, In, Out>
 where
-    T: Transform<S>,
-    T::Error: From<S::Error>,
-    S: Service,
+    T: Service,
 {
-    transform: T,
-    service: S,
+    service: T,
+    f: F,
+    r: PhantomData<(In, Out)>,
 }
 
-impl<T, S> Apply<T, S>
+impl<T, F, In, Out> Apply<T, F, In, Out>
 where
-    T: Transform<S>,
-    T::Error: From<S::Error>,
-    S: Service,
-{
-    /// Create new `Apply` combinator
-    pub fn new<T1: IntoTransform<T, S>, S1: IntoService<S>>(
-        transform: T1,
-        service: S1,
-    ) -> Self {
-        Self {
-            transform: transform.into_transform(),
-            service: service.into_service(),
-        }
-    }
-}
-
-impl<F, S, Req, Out> Apply<FnTransform<F, S, Req, Out>, S>
-where
-    F: FnMut(Req, &mut S) -> Out,
+    T: Service,
+    F: FnMut(In, &mut T) -> Out,
     Out: IntoFuture,
-    Out::Error: From<S::Error>,
-    S: Service,
+    Out::Error: From<T::Error>,
 {
     /// Create new `Apply` combinator
-    pub fn new_fn<S1: IntoService<S>>(service: S1, transform: F) -> Self {
+    pub fn new<I: IntoService<T>>(service: I, f: F) -> Self {
         Self {
             service: service.into_service(),
-            transform: transform.into_transform(),
+            f,
+            r: PhantomData,
         }
     }
 }
 
-impl<T, S> Clone for Apply<T, S>
+impl<T, F, In, Out> Clone for Apply<T, F, In, Out>
 where
-    S: Service + Clone,
-    T::Error: From<S::Error>,
-    T: Transform<S> + Clone,
+    T: Service + Clone,
+    F: Clone,
 {
     fn clone(&self) -> Self {
         Apply {
             service: self.service.clone(),
-            transform: self.transform.clone(),
+            f: self.f.clone(),
+            r: PhantomData,
         }
     }
 }
 
-impl<T, S> Service for Apply<T, S>
+impl<T, F, In, Out> Service for Apply<T, F, In, Out>
 where
-    T: Transform<S>,
-    T::Error: From<S::Error>,
-    S: Service,
+    T: Service,
+    F: FnMut(In, &mut T) -> Out,
+    Out: IntoFuture,
+    Out::Error: From<T::Error>,
 {
-    type Request = T::Request;
-    type Response = T::Response;
-    type Error = T::Error;
-    type Future = T::Future;
+    type Request = In;
+    type Response = Out::Item;
+    type Error = Out::Error;
+    type Future = Out::Future;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        try_ready!(self.service.poll_ready());
-        self.transform.poll_ready()
+        self.service.poll_ready().map_err(|e| e.into())
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        self.transform.call(req, &mut self.service).into_future()
+    fn call(&mut self, req: In) -> Self::Future {
+        (self.f)(req, &mut self.service).into_future()
     }
 }
 
 /// `ApplyNewService` new service combinator
-pub struct ApplyNewService<T, S>
+pub struct ApplyNewService<T, F, In, Out, Cfg>
 where
-    T: NewTransform<S::Service, InitError = S::InitError>,
-    T::Error: From<S::Error>,
-    S: NewService,
+    T: NewService<Cfg>,
 {
-    transform: T,
-    service: S,
+    service: T,
+    f: F,
+    r: PhantomData<(In, Out, Cfg)>,
 }
 
-impl<T, S> ApplyNewService<T, S>
+impl<T, F, In, Out, Cfg> ApplyNewService<T, F, In, Out, Cfg>
 where
-    T: NewTransform<S::Service, InitError = S::InitError>,
-    T::Error: From<S::Error>,
-    S: NewService,
+    T: NewService<Cfg>,
+    F: FnMut(In, &mut T::Service) -> Out + Clone,
+    Out: IntoFuture,
+    Out::Error: From<T::Error>,
 {
     /// Create new `ApplyNewService` new service instance
-    pub fn new<T1: IntoNewTransform<T, S::Service>, S1: IntoNewService<S>>(
-        transform: T1,
-        service: S1,
-    ) -> Self {
+    pub fn new<F1: IntoNewService<T, Cfg>>(service: F1, f: F) -> Self {
         Self {
-            transform: transform.into_new_transform(),
+            f,
             service: service.into_new_service(),
+            r: PhantomData,
         }
     }
 }
 
-impl<F, S, In, Out> ApplyNewService<FnNewTransform<F, S::Service, In, Out, S::InitError>, S>
+impl<T, F, In, Out, Cfg> Clone for ApplyNewService<T, F, In, Out, Cfg>
 where
-    F: FnMut(In, &mut S::Service) -> Out + Clone,
+    T: NewService<Cfg> + Clone,
+    F: FnMut(In, &mut T::Service) -> Out + Clone,
     Out: IntoFuture,
-    Out::Error: From<S::Error>,
-    S: NewService,
-{
-    /// Create new `Apply` combinator factory
-    pub fn new_fn<S1: IntoNewService<S>>(service: S1, transform: F) -> Self {
-        Self {
-            service: service.into_new_service(),
-            transform: FnNewTransform::new(transform),
-        }
-    }
-}
-
-impl<T, S> Clone for ApplyNewService<T, S>
-where
-    T: NewTransform<S::Service, InitError = S::InitError> + Clone,
-    T::Error: From<S::Error>,
-    S: NewService + Clone,
 {
     fn clone(&self) -> Self {
         Self {
             service: self.service.clone(),
-            transform: self.transform.clone(),
+            f: self.f.clone(),
+            r: PhantomData,
         }
     }
 }
 
-impl<T, S> NewService for ApplyNewService<T, S>
+impl<T, F, In, Out, Cfg> NewService<Cfg> for ApplyNewService<T, F, In, Out, Cfg>
 where
-    T: NewTransform<S::Service, InitError = S::InitError>,
-    T::Error: From<S::Error>,
-    S: NewService,
+    T: NewService<Cfg>,
+    F: FnMut(In, &mut T::Service) -> Out + Clone,
+    Out: IntoFuture,
+    Out::Error: From<T::Error>,
 {
-    type Request = T::Request;
-    type Response = T::Response;
-    type Error = T::Error;
-    type Service = Apply<T::Transform, S::Service>;
+    type Request = In;
+    type Response = Out::Item;
+    type Error = Out::Error;
+    type Service = Apply<T::Service, F, In, Out>;
 
     type InitError = T::InitError;
-    type Future = ApplyNewServiceFuture<T, S>;
+    type Future = ApplyNewServiceFuture<T, F, In, Out, Cfg>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &Cfg) -> Self::Future {
+        ApplyNewServiceFuture::new(self.service.new_service(cfg), self.f.clone())
+    }
+}
+
+pub struct ApplyNewServiceFuture<T, F, In, Out, Cfg>
+where
+    T: NewService<Cfg>,
+    F: FnMut(In, &mut T::Service) -> Out + Clone,
+    Out: IntoFuture,
+{
+    fut: T::Future,
+    f: Option<F>,
+    r: PhantomData<(In, Out)>,
+}
+
+impl<T, F, In, Out, Cfg> ApplyNewServiceFuture<T, F, In, Out, Cfg>
+where
+    T: NewService<Cfg>,
+    F: FnMut(In, &mut T::Service) -> Out + Clone,
+    Out: IntoFuture,
+{
+    fn new(fut: T::Future, f: F) -> Self {
         ApplyNewServiceFuture {
-            fut_t: self.transform.new_transform(),
-            fut_s: self.service.new_service(),
-            service: None,
-            transform: None,
+            f: Some(f),
+            fut,
+            r: PhantomData,
         }
     }
 }
 
-pub struct ApplyNewServiceFuture<T, S>
+impl<T, F, In, Out, Cfg> Future for ApplyNewServiceFuture<T, F, In, Out, Cfg>
 where
-    T: NewTransform<S::Service, InitError = S::InitError>,
-    T::Error: From<S::Error>,
-    S: NewService,
+    T: NewService<Cfg>,
+    F: FnMut(In, &mut T::Service) -> Out + Clone,
+    Out: IntoFuture,
+    Out::Error: From<T::Error>,
 {
-    fut_s: S::Future,
-    fut_t: T::Future,
-    service: Option<S::Service>,
-    transform: Option<T::Transform>,
-}
-
-impl<T, S> Future for ApplyNewServiceFuture<T, S>
-where
-    T: NewTransform<S::Service, InitError = S::InitError>,
-    T::Error: From<S::Error>,
-    S: NewService,
-{
-    type Item = Apply<T::Transform, S::Service>;
+    type Item = Apply<T::Service, F, In, Out>;
     type Error = T::InitError;
 
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        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(),
-            }))
+        if let Async::Ready(service) = self.fut.poll()? {
+            Ok(Async::Ready(Apply::new(service, self.f.take().unwrap())))
         } else {
             Ok(Async::NotReady)
         }
@@ -220,7 +179,7 @@ mod tests {
     use futures::{Async, Future, Poll};
 
     use super::*;
-    use crate::{NewService, Service};
+    use crate::{IntoService, NewService, Service, ServiceExt};
 
     #[derive(Clone)]
     struct Srv;
@@ -240,10 +199,14 @@ mod tests {
     }
 
     #[test]
-    fn test_apply() {
-        let mut srv = Apply::new_fn(Srv, |req: &'static str, srv| {
-            srv.call(()).map(move |res| (req, res))
-        });
+    fn test_call() {
+        let blank = |req| Ok(req);
+
+        let mut srv = blank
+            .into_service()
+            .apply_fn(Srv, |req: &'static str, srv| {
+                srv.call(()).map(move |res| (req, res))
+            });
         assert!(srv.poll_ready().is_ok());
         let res = srv.call("srv").poll();
         assert!(res.is_ok());
@@ -253,26 +216,10 @@ mod tests {
     #[test]
     fn test_new_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!()
-        }
-    }
-
-    #[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/apply_cfg.rs

@@ -0,0 +1,163 @@
+use std::marker::PhantomData;
+
+use futures::{Async, Future, Poll};
+
+use crate::and_then::AndThen;
+use crate::{IntoNewService, NewService};
+
+/// `ApplyNewService` new service combinator
+pub struct ApplyConfig<F, A, B, C1, C2> {
+    a: A,
+    b: B,
+    f: F,
+    r: PhantomData<(C1, C2)>,
+}
+
+impl<F, A, B, C1, C2> ApplyConfig<F, A, B, C1, C2>
+where
+    A: NewService<C1>,
+    B: NewService<C2, Request = A::Response, Error = A::Error, InitError = A::InitError>,
+    F: Fn(&C1) -> C2,
+{
+    /// Create new `ApplyNewService` new service instance
+    pub fn new<A1: IntoNewService<A, C1>, B1: IntoNewService<B, C2>>(
+        a: A1,
+        b: B1,
+        f: F,
+    ) -> Self {
+        Self {
+            f,
+            a: a.into_new_service(),
+            b: b.into_new_service(),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<F, A, B, C1, C2> Clone for ApplyConfig<F, A, B, C1, C2>
+where
+    A: Clone,
+    B: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            a: self.a.clone(),
+            b: self.b.clone(),
+            f: self.f.clone(),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<F, A, B, C1, C2> NewService<C1> for ApplyConfig<F, A, B, C1, C2>
+where
+    A: NewService<C1>,
+    B: NewService<C2, Request = A::Response, Error = A::Error, InitError = A::InitError>,
+    F: Fn(&C1) -> C2,
+{
+    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 = ApplyConfigResponse<A, B, C1, C2>;
+
+    fn new_service(&self, cfg: &C1) -> Self::Future {
+        let cfg2 = (self.f)(cfg);
+
+        ApplyConfigResponse {
+            a: None,
+            b: None,
+            fut_a: self.a.new_service(cfg),
+            fut_b: self.b.new_service(&cfg2),
+        }
+    }
+}
+
+pub struct ApplyConfigResponse<A, B, C1, C2>
+where
+    A: NewService<C1>,
+    B: NewService<C2>,
+{
+    fut_b: B::Future,
+    fut_a: A::Future,
+    a: Option<A::Service>,
+    b: Option<B::Service>,
+}
+
+impl<A, B, C1, C2> Future for ApplyConfigResponse<A, B, C1, C2>
+where
+    A: NewService<C1>,
+    B: NewService<C2, Request = A::Response, Error = A::Error, InitError = A::InitError>,
+{
+    type Item = AndThen<A::Service, B::Service>;
+    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(AndThen::new(
+                self.a.take().unwrap(),
+                self.b.take().unwrap(),
+            )))
+        } else {
+            Ok(Async::NotReady)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use futures::future::{ok, FutureResult};
+    use futures::{Async, Future, Poll};
+
+    use crate::{fn_cfg_factory, NewService, Service};
+
+    #[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_new_service() {
+        let new_srv = fn_cfg_factory(|_: &usize| Ok::<_, ()>(Srv)).apply_cfg(
+            fn_cfg_factory(|s: &String| {
+                assert_eq!(s, "test");
+                Ok::<_, ()>(Srv)
+            }),
+            |cfg: &usize| {
+                assert_eq!(*cfg, 1);
+                "test".to_string()
+            },
+        );
+
+        if let Async::Ready(mut srv) = new_srv.new_service(&1).poll().unwrap() {
+            assert!(srv.poll_ready().is_ok());
+        }
+    }
+}

actix-service/src/blank.rs

@@ -68,15 +68,16 @@ impl<R, E1, E2> Default for BlankNewService<R, E1, E2> {
     }
 }
 
-impl<R, E1, E2> NewService for BlankNewService<R, E1, E2> {
+impl<R, E1, E2> NewService<()> for BlankNewService<R, E1, E2> {
     type Request = R;
     type Response = R;
     type Error = E1;
-    type InitError = E2;
     type Service = Blank<R, E1>;
+
+    type InitError = E2;
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, _: &()) -> Self::Future {
         ok(Blank::default())
     }
 }

actix-service/src/boxed.rs

@@ -0,0 +1,137 @@
+use crate::{NewService, Service};
+use futures::{Future, IntoFuture, 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)
+                .into_future()
+                .map(ServiceWrapper::boxed),
+        )
+    }
+}
+
+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,9 +1,39 @@
 use std::marker::PhantomData;
 
-use futures::future::{ok, FutureResult};
-use futures::{Async, IntoFuture, Poll};
+use futures::future::{ok, Future, FutureResult};
+use futures::{try_ready, Async, IntoFuture, Poll};
 
-use super::{IntoNewService, IntoService, NewService, Service};
+use crate::{IntoConfigurableNewService, IntoNewService, IntoService, NewService, Service};
+
+/// Create `NewService` for function that can act as Service
+pub fn fn_service<F, Req, Out, Cfg>(f: F) -> FnNewService<F, Req, Out, Cfg>
+where
+    F: FnMut(Req) -> Out + Clone,
+    Out: IntoFuture,
+{
+    FnNewService::new(f)
+}
+
+/// 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() -> 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<Error = E>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    FnNewServiceConfig::new(f)
+}
 
 pub struct FnService<F, Req, Out>
 where
@@ -66,16 +96,16 @@ where
     }
 }
 
-pub struct FnNewService<F, Req, Out>
+pub struct FnNewService<F, Req, Out, Cfg>
 where
     F: FnMut(Req) -> Out,
     Out: IntoFuture,
 {
     f: F,
-    _t: PhantomData<(Req,)>,
+    _t: PhantomData<(Req, Cfg)>,
 }
 
-impl<F, Req, Out> FnNewService<F, Req, Out>
+impl<F, Req, Out, Cfg> FnNewService<F, Req, Out, Cfg>
 where
     F: FnMut(Req) -> Out + Clone,
     Out: IntoFuture,
@@ -85,7 +115,7 @@ where
     }
 }
 
-impl<F, Req, Out> NewService for FnNewService<F, Req, Out>
+impl<F, Req, Out, Cfg> NewService<Cfg> for FnNewService<F, Req, Out, Cfg>
 where
     F: FnMut(Req) -> Out + Clone,
     Out: IntoFuture,
@@ -94,25 +124,16 @@ where
     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, Out> IntoNewService<FnNewService<F, Req, Out>> for F
-where
-    F: FnMut(Req) -> Out + Clone + 'static,
-    Out: IntoFuture,
-{
-    fn into_new_service(self) -> FnNewService<F, Req, Out> {
-        FnNewService::new(self)
-    }
-}
-
-impl<F, Req, Out> Clone for FnNewService<F, Req, Out>
+impl<F, Req, Out, Cfg> Clone for FnNewService<F, Req, Out, Cfg>
 where
     F: FnMut(Req) -> Out + Clone,
     Out: IntoFuture,
@@ -121,3 +142,170 @@ where
         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<Error = E>,
+    R::Item: IntoService<S>,
+    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<Error = E>,
+    R::Item: IntoService<S>,
+    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<Error = E>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type Service = S;
+
+    type InitError = E;
+    type Future = FnNewServiceConfigFut<R, S, E>;
+
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        FnNewServiceConfigFut {
+            fut: (self.f)(cfg).into_future(),
+            _t: PhantomData,
+        }
+    }
+}
+
+pub struct FnNewServiceConfigFut<R, S, E>
+where
+    R: IntoFuture<Error = E>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    fut: R::Future,
+    _t: PhantomData<(S,)>,
+}
+
+impl<R, S, E> Future for FnNewServiceConfigFut<R, S, E>
+where
+    R: IntoFuture<Error = E>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    type Item = S;
+    type Error = R::Error;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        Ok(Async::Ready(try_ready!(self.fut.poll()).into_service()))
+    }
+}
+
+impl<F, C, R, S, E> Clone for FnNewServiceConfig<F, C, R, S, E>
+where
+    F: Fn(&C) -> R + Clone,
+    R: IntoFuture<Error = E>,
+    R::Item: IntoService<S>,
+    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<Error = E>,
+    R::Item: IntoService<S>,
+    S: Service,
+{
+    fn into_new_service(self) -> FnNewServiceConfig<F, C, R, S, E> {
+        FnNewServiceConfig::new(self)
+    }
+}

actix-service/src/fn_transform.rs

@@ -1,121 +1,64 @@
 use std::marker::PhantomData;
 
 use futures::future::{ok, FutureResult};
-use futures::{Async, IntoFuture, Poll};
+use futures::IntoFuture;
 
-use super::{IntoNewTransform, IntoTransform, NewTransform, Transform};
+use crate::{Apply, IntoTransform, Service, Transform};
 
-pub struct FnTransform<F, S, Req, Res>
+pub struct FnTransform<F, S, In, Out, Err>
 where
-    F: FnMut(Req, &mut S) -> Res,
-    Res: IntoFuture,
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
 {
     f: F,
-    _t: PhantomData<(S, Req, Res)>,
+    _t: PhantomData<(S, In, Out, Err)>,
 }
 
-impl<F, S, Req, Res> FnTransform<F, S, Req, Res>
+impl<F, S, In, Out, Err> FnTransform<F, S, In, Out, Err>
 where
-    F: FnMut(Req, &mut S) -> Res,
-    Res: IntoFuture,
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
 {
     pub fn new(f: F) -> Self {
         FnTransform { f, _t: PhantomData }
     }
 }
 
-impl<F, S, Req, Res> Clone for FnTransform<F, S, Req, Res>
+impl<F, S, In, Out, Err> Transform<S> for FnTransform<F, S, In, Out, Err>
 where
-    F: FnMut(Req, &mut S) -> Res + Clone,
-    Res: IntoFuture,
+    S: Service,
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
+    Out::Error: From<S::Error>,
 {
-    fn clone(&self) -> Self {
-        FnTransform {
-            f: self.f.clone(),
-            _t: PhantomData,
-        }
+    type Request = In;
+    type Response = Out::Item;
+    type Error = Out::Error;
+    type Transform = Apply<S, F, In, Out>;
+    type InitError = Err;
+    type Future = FutureResult<Self::Transform, Self::InitError>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        ok(Apply::new(service, self.f.clone()))
     }
 }
 
-impl<F, S, Req, Res> Transform<S> for FnTransform<F, S, Req, Res>
+impl<F, S, In, Out, Err> IntoTransform<FnTransform<F, S, In, Out, Err>, S> for F
 where
-    F: FnMut(Req, &mut S) -> Res,
-    Res: IntoFuture,
+    S: Service,
+    F: FnMut(In, &mut S) -> Out + Clone,
+    Out: IntoFuture,
+    Out::Error: From<S::Error>,
 {
-    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> {
+    fn into_transform(self) -> FnTransform<F, S, In, Out, Err> {
         FnTransform::new(self)
     }
 }
 
-pub struct FnNewTransform<F, S, Req, Out, Err>
+impl<F, S, In, Out, Err> Clone for FnTransform<F, S, In, Out, Err>
 where
-    F: FnMut(Req, &mut S) -> Out + Clone,
+    F: FnMut(In, &mut S) -> Out + Clone,
     Out: IntoFuture,
-{
-    f: F,
-    _t: PhantomData<(S, Req, Out, Err)>,
-}
-
-impl<F, S, Req, Res, Err> FnNewTransform<F, S, Req, Res, Err>
-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> NewTransform<S> for FnNewTransform<F, S, Req, Res, Err>
-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) -> Self::Future {
-        ok(FnTransform::new(self.f.clone()))
-    }
-}
-
-impl<F, S, Req, Res, Err> IntoNewTransform<FnNewTransform<F, S, Req, Res, Err>, S> for F
-where
-    F: FnMut(Req, &mut S) -> Res + Clone,
-    Res: IntoFuture,
-{
-    fn into_new_transform(self) -> FnNewTransform<F, S, Req, Res, Err> {
-        FnNewTransform::new(self)
-    }
-}
-
-impl<F, S, Req, Res, Err> Clone for FnNewTransform<F, S, Req, Res, Err>
-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

@@ -81,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(a: A) -> Self
     where
-        A: NewService,
+        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,
 {
@@ -109,9 +109,9 @@ where
     }
 }
 
-impl<A, E> NewService for FromErrNewService<A, E>
+impl<A, E, C> NewService<C> for FromErrNewService<A, E, C>
 where
-    A: NewService,
+    A: NewService<C>,
     E: From<A::Error>,
 {
     type Request = A::Request;
@@ -120,28 +120,28 @@ where
     type Service = FromErr<A::Service, E>;
 
     type InitError = A::InitError;
-    type Future = FromErrNewServiceFuture<A, E>;
+    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>
+pub struct FromErrNewServiceFuture<A, E, C>
 where
-    A: NewService,
+    A: NewService<C>,
     E: From<A::Error>,
 {
     fut: A::Future,
     e: PhantomData<E>,
 }
 
-impl<A, E> Future for FromErrNewServiceFuture<A, E>
+impl<A, E, C> Future for FromErrNewServiceFuture<A, E, C>
 where
-    A: NewService,
+    A: NewService<C>,
     E: From<A::Error>,
 {
     type Item = FromErr<A::Service, E>;
@@ -208,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,10 +1,17 @@
+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;
-mod blank;
+mod apply_cfg;
+pub mod blank;
+pub mod boxed;
 mod cell;
 mod fn_service;
 mod fn_transform;
@@ -14,21 +21,21 @@ 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::AndThenTransform;
 use self::and_then_apply_fn::{AndThenApply, AndThenApplyNewService};
 pub use self::apply::{Apply, ApplyNewService};
-pub use self::blank::{Blank, BlankNewService};
-pub use self::fn_service::{FnNewService, FnService};
-pub use self::fn_transform::{FnNewTransform, FnTransform};
+pub use self::apply_cfg::ApplyConfig;
+pub use self::fn_service::{fn_cfg_factory, fn_factory, fn_service, FnService};
+pub use self::fn_transform::FnTransform;
 pub use self::from_err::{FromErr, FromErrNewService};
 pub use self::map::{Map, MapNewService};
 pub use self::map_err::{MapErr, MapErrNewService};
 pub use self::map_init_err::MapInitErr;
 pub use self::then::{Then, ThenNewService};
-pub use self::transform::{IntoNewTransform, IntoTransform, NewTransform, Transform};
+pub use self::transform::{ApplyTransform, IntoTransform, Transform};
 
 /// An asynchronous function from `Request` to a `Response`.
 pub trait Service {
@@ -70,20 +77,6 @@ pub trait Service {
 /// 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_fn<F, B, B1, Out>(self, service: B1, f: F) -> AndThenApply<Self, B, F, Out>
@@ -185,7 +178,9 @@ impl<T: ?Sized> ServiceExt for T where T: Service {}
 /// accepts new TCP streams, obtains a new `Service` value using the
 /// `NewService` trait, and uses that new `Service` value to process inbound
 /// requests on that new TCP stream.
-pub trait NewService {
+///
+/// `Config` is a service factory configuration type.
+pub trait NewService<Config = ()> {
     /// Requests handled by the service.
     type Request;
 
@@ -209,37 +204,37 @@ pub trait NewService {
     type Future: Future<Item = Self::Service, Error = Self::InitError>;
 
     /// Create and return a new service value asynchronously.
-    fn new_service(&self) -> Self::Future;
+    fn new_service(&self, cfg: &Config) -> Self::Future;
 
-    /// Apply function to specified service and use it as a next service in
+    /// Apply transform service to specified service and use it as a next service in
     /// chain.
     fn apply<T, T1, B, B1>(
         self,
         transform: T1,
         service: B1,
-    ) -> AndThenTransformNewService<T, Self, B>
+    ) -> AndThenTransform<T, Self, B, Config>
     where
         Self: Sized,
-        T: NewTransform<B::Service, Request = Self::Response, InitError = Self::InitError>,
+        T: Transform<B::Service, Request = Self::Response, InitError = Self::InitError>,
         T::Error: From<Self::Error>,
-        T1: IntoNewTransform<T, B::Service>,
-        B: NewService<Error = Self::Error, InitError = Self::InitError>,
-        B1: IntoNewService<B>,
+        T1: IntoTransform<T, B::Service>,
+        B: NewService<Config, InitError = Self::InitError>,
+        B1: IntoNewService<B, Config>,
     {
-        AndThenTransformNewService::new(
-            transform.into_new_transform(),
-            self,
-            service.into_new_service(),
-        )
+        AndThenTransform::new(transform.into_transform(), self, service.into_new_service())
     }
 
     /// Apply function to specified service and use it as a next service in
     /// chain.
-    fn apply_fn<B, I, F, Out>(self, service: I, f: F) -> AndThenApplyNewService<Self, B, F, Out>
+    fn apply_fn<B, I, F, Out>(
+        self,
+        service: I,
+        f: F,
+    ) -> AndThenApplyNewService<Self, B, F, Out, Config>
     where
         Self: Sized,
-        B: NewService<Error = Self::Error, InitError = Self::InitError>,
-        I: IntoNewService<B>,
+        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>,
@@ -247,12 +242,30 @@ pub trait NewService {
         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>
+    /// Map this service's config type to a different config,
+    /// and use for nested service
+    fn apply_cfg<F, C, B, B1>(self, service: B1, f: F) -> ApplyConfig<F, Self, B, Config, C>
     where
         Self: Sized,
-        F: IntoNewService<B>,
+        F: Fn(&Config) -> C,
+        B1: IntoNewService<B, C>,
         B: NewService<
+            C,
+            Request = Self::Response,
+            Error = Self::Error,
+            InitError = Self::InitError,
+        >,
+    {
+        ApplyConfig::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, Config>
+    where
+        Self: Sized,
+        F: IntoNewService<B, Config>,
+        B: NewService<
+            Config,
             Request = Self::Response,
             Error = Self::Error,
             InitError = Self::InitError,
@@ -267,7 +280,7 @@ pub trait NewService {
     ///
     /// Note that this function consumes the receiving new service and returns a
     /// wrapped version of it.
-    fn from_err<E>(self) -> FromErrNewService<Self, E>
+    fn from_err<E>(self) -> FromErrNewService<Self, E, Config>
     where
         Self: Sized,
         E: From<Self::Error>,
@@ -281,11 +294,12 @@ pub trait NewService {
     ///
     /// Note that this function consumes the receiving future and returns a
     /// wrapped version of it.
-    fn then<F, B>(self, new_service: F) -> ThenNewService<Self, B>
+    fn then<F, B>(self, new_service: F) -> ThenNewService<Self, B, Config>
     where
         Self: Sized,
-        F: IntoNewService<B>,
+        F: IntoNewService<B, Config>,
         B: NewService<
+            Config,
             Request = Result<Self::Response, Self::Error>,
             Error = Self::Error,
             InitError = Self::InitError,
@@ -296,7 +310,7 @@ pub trait NewService {
 
     /// Map this service's output to a different type, returning a new service
     /// of the resulting type.
-    fn map<F, R>(self, f: F) -> MapNewService<Self, F, R>
+    fn map<F, R>(self, f: F) -> MapNewService<Self, F, R, Config>
     where
         Self: Sized,
         F: FnMut(Self::Response) -> R,
@@ -305,7 +319,7 @@ pub trait NewService {
     }
 
     /// Map this service's error to a different error, returning a new service.
-    fn map_err<F, E>(self, f: F) -> MapErrNewService<Self, F, E>
+    fn map_err<F, E>(self, f: F) -> MapErrNewService<Self, F, E, Config>
     where
         Self: Sized,
         F: Fn(Self::Error) -> E,
@@ -314,7 +328,7 @@ pub trait NewService {
     }
 
     /// Map this service's init error to a different error, returning a new service.
-    fn map_init_err<F, E>(self, f: F) -> MapInitErr<Self, F, E>
+    fn map_init_err<F, E>(self, f: F) -> MapInitErr<Self, F, E, Config>
     where
         Self: Sized,
         F: Fn(Self::InitError) -> E,
@@ -359,21 +373,35 @@ where
     }
 }
 
-impl<F, R, E, S> NewService for F
+impl<S, C> NewService<C> for Rc<S>
 where
-    F: Fn() -> R,
-    R: IntoFuture<Item = S, Error = E>,
-    S: Service,
+    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)
     }
 }
 
@@ -387,9 +415,9 @@ where
 }
 
 /// Trait for types that can be converted to a `NewService`
-pub trait IntoNewService<T>
+pub trait IntoNewService<T, C = ()>
 where
-    T: NewService,
+    T: NewService<C>,
 {
     /// Convert to an `NewService`
     fn into_new_service(self) -> T;
@@ -404,9 +432,27 @@ where
     }
 }
 
-impl<T> IntoNewService<T> for T
+impl<T, C> IntoNewService<T, C> for T
 where
-    T: NewService,
+    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

@@ -97,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(a: A, f: F) -> Self
     where
-        A: NewService,
-        F: FnMut(A::Response) -> Response,
+        A: NewService<Cfg>,
+        F: FnMut(A::Response) -> Res,
     {
         Self {
             a,
@@ -118,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,
@@ -132,49 +132,49 @@ where
     }
 }
 
-impl<A, F, Response> NewService for MapNewService<A, F, Response>
+impl<A, F, Res, Cfg> NewService<Cfg> for MapNewService<A, F, Res, Cfg>
 where
-    A: NewService,
-    F: FnMut(A::Response) -> Response + Clone,
+    A: NewService<Cfg>,
+    F: FnMut(A::Response) -> Res + Clone,
 {
     type Request = A::Request;
-    type Response = Response;
+    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, 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, Response>
+pub struct MapNewServiceFuture<A, F, Res, Cfg>
 where
-    A: NewService,
-    F: FnMut(A::Response) -> Response,
+    A: NewService<Cfg>,
+    F: FnMut(A::Response) -> Res,
 {
     fut: A::Future,
     f: Option<F>,
 }
 
-impl<A, F, Response> MapNewServiceFuture<A, F, Response>
+impl<A, F, Res, Cfg> MapNewServiceFuture<A, F, Res, Cfg>
 where
-    A: NewService,
-    F: FnMut(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, Response> Future for MapNewServiceFuture<A, F, Response>
+impl<A, F, Res, Cfg> Future for MapNewServiceFuture<A, F, Res, Cfg>
 where
-    A: NewService,
-    F: FnMut(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> {
@@ -229,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

@@ -98,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(a: A, f: F) -> Self
     where
-        A: NewService,
+        A: NewService<C>,
         F: Fn(A::Error) -> E,
     {
         Self {
@@ -119,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,
@@ -133,9 +133,9 @@ where
     }
 }
 
-impl<A, F, E> NewService for MapErrNewService<A, F, E>
+impl<A, F, E, C> NewService<C> for MapErrNewService<A, F, E, C>
 where
-    A: NewService,
+    A: NewService<C>,
     F: Fn(A::Error) -> E + Clone,
 {
     type Request = A::Request;
@@ -144,25 +144,25 @@ where
     type Service = MapErr<A::Service, F, E>;
 
     type InitError = A::InitError;
-    type Future = MapErrNewServiceFuture<A, F, E>;
+    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>
+pub struct MapErrNewServiceFuture<A, F, E, C>
 where
-    A: NewService,
+    A: NewService<C>,
     F: Fn(A::Error) -> E,
 {
     fut: A::Future,
     f: F,
 }
 
-impl<A, F, E> MapErrNewServiceFuture<A, F, E>
+impl<A, F, E, C> MapErrNewServiceFuture<A, F, E, C>
 where
-    A: NewService,
+    A: NewService<C>,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -170,9 +170,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapErrNewServiceFuture<A, F, E>
+impl<A, F, E, C> Future for MapErrNewServiceFuture<A, F, E, C>
 where
-    A: NewService,
+    A: NewService<C>,
     F: Fn(A::Error) -> E + Clone,
 {
     type Item = MapErr<A::Service, F, E>;
@@ -231,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(a: A, f: F) -> Self
     where
-        A: NewService,
+        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,9 +40,9 @@ where
     }
 }
 
-impl<A, F, E> NewService for MapInitErr<A, F, E>
+impl<A, F, E, C> NewService<C> for MapInitErr<A, F, E, C>
 where
-    A: NewService,
+    A: NewService<C>,
     F: Fn(A::InitError) -> E + Clone,
 {
     type Request = A::Request;
@@ -51,25 +51,25 @@ where
     type Service = A::Service;
 
     type InitError = E;
-    type Future = MapInitErrFuture<A, F, E>;
+    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>
+pub struct MapInitErrFuture<A, F, E, C>
 where
-    A: NewService,
+    A: NewService<C>,
     F: Fn(A::InitError) -> E,
 {
     f: F,
     fut: A::Future,
 }
 
-impl<A, F, E> MapInitErrFuture<A, F, E>
+impl<A, F, E, C> MapInitErrFuture<A, F, E, C>
 where
-    A: NewService,
+    A: NewService<C>,
     F: Fn(A::InitError) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -77,9 +77,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapInitErrFuture<A, F, E>
+impl<A, F, E, C> Future for MapInitErrFuture<A, F, E, C>
 where
-    A: NewService,
+    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};
@@ -109,34 +111,38 @@ where
 }
 
 /// `ThenNewService` new service combinator
-pub struct ThenNewService<A, B> {
+pub struct ThenNewService<A, B, C> {
     a: A,
     b: B,
+    _t: PhantomData<C>,
 }
 
-impl<A, B> ThenNewService<A, B> {
+impl<A, B, C> ThenNewService<A, B, C> {
     /// Create new `AndThen` combinator
     pub fn new<F>(a: A, f: F) -> Self
     where
-        A: NewService,
+        A: NewService<C>,
         B: NewService<
+            C,
             Request = Result<A::Response, A::Error>,
             Error = A::Error,
             InitError = A::InitError,
         >,
-        F: IntoNewService<B>,
+        F: IntoNewService<B, C>,
     {
         Self {
             a,
             b: f.into_new_service(),
+            _t: PhantomData,
         }
     }
 }
 
-impl<A, B> NewService for ThenNewService<A, B>
+impl<A, B, C> NewService<C> for ThenNewService<A, B, C>
 where
-    A: NewService,
+    A: NewService<C>,
     B: NewService<
+        C,
         Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
@@ -148,14 +154,14 @@ where
     type Service = Then<A::Service, B::Service>;
 
     type InitError = A::InitError;
-    type Future = ThenNewServiceFuture<A, B>;
+    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,
@@ -164,14 +170,16 @@ where
         Self {
             a: self.a.clone(),
             b: self.b.clone(),
+            _t: PhantomData,
         }
     }
 }
 
-pub struct ThenNewServiceFuture<A, B>
+pub struct ThenNewServiceFuture<A, B, C>
 where
-    A: NewService,
+    A: NewService<C>,
     B: NewService<
+        C,
         Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
@@ -183,10 +191,11 @@ where
     b: Option<B::Service>,
 }
 
-impl<A, B> ThenNewServiceFuture<A, B>
+impl<A, B, C> ThenNewServiceFuture<A, B, C>
 where
-    A: NewService,
+    A: NewService<C>,
     B: NewService<
+        C,
         Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
@@ -202,10 +211,11 @@ where
     }
 }
 
-impl<A, B> Future for ThenNewServiceFuture<A, B>
+impl<A, B, C> Future for ThenNewServiceFuture<A, B, C>
 where
-    A: NewService,
+    A: NewService<C>,
     B: NewService<
+        C,
         Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
@@ -319,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

@@ -1,50 +1,16 @@
-use futures::{Future, Poll};
+use std::rc::Rc;
+use std::sync::Arc;
 
-use crate::transform_map_err::{TransformMapErr, TransformMapErrNewTransform};
-use crate::Service;
+use futures::{Async, Future, IntoFuture, Poll};
 
-/// An asynchronous function for transforming service call result.
-pub trait Transform<Service> {
-    /// Requests handled by the service.
-    type Request;
+use crate::transform_map_init_err::TransformMapInitErr;
+use crate::{NewService, Service};
 
-    /// 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
-pub trait NewTransform<Service> {
+/// `Transform` service factory.
+///
+/// Transform factory creates service that wraps other services.
+/// `Config` is a service factory configuration type.
+pub trait Transform<S> {
     /// Requests handled by the service.
     type Request;
 
@@ -55,8 +21,7 @@ pub trait NewTransform<Service> {
     type Error;
 
     /// The `TransformService` value created by this factory
-    type Transform: Transform<
-        Service,
+    type Transform: Service<
         Request = Self::Request,
         Response = Self::Response,
         Error = Self::Error,
@@ -69,58 +34,52 @@ pub trait NewTransform<Service> {
     type Future: Future<Item = Self::Transform, Error = Self::InitError>;
 
     /// Create and return a new service value asynchronously.
-    fn new_transform(&self) -> Self::Future;
+    fn new_transform(&self, service: S) -> Self::Future;
 
-    /// Map this transforms's output to a different type, returning a new transform
-    /// of the resulting type.
-    fn map_err<F, E>(self, f: F) -> TransformMapErrNewTransform<Self, Service, F, E>
+    /// Map this service's factory init error to a different error,
+    /// returning a new transform service factory.
+    fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, F, E>
     where
         Self: Sized,
-        F: Fn(Self::Error) -> E,
+        F: Fn(Self::InitError) -> E,
     {
-        TransformMapErrNewTransform::new(self, f)
+        TransformMapInitErr::new(self, f)
     }
 }
 
-impl<'a, T, S> Transform<S> for &'a mut T
+impl<T, S> Transform<S> for Rc<T>
 where
-    T: Transform<S> + 'a,
-    S: Service<Error = T::Error>,
+    T: Transform<S>,
 {
     type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
+    type InitError = T::InitError;
+    type Transform = T::Transform;
     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)
+    fn new_transform(&self, service: S) -> T::Future {
+        self.as_ref().new_transform(service)
     }
 }
 
-impl<T, S> Transform<S> for Box<T>
+impl<T, S> Transform<S> for Arc<T>
 where
-    T: Transform<S> + ?Sized,
-    S: Service<Error = T::Error>,
+    T: Transform<S>,
 {
     type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
+    type InitError = T::InitError;
+    type Transform = T::Transform;
     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)
+    fn new_transform(&self, service: S) -> T::Future {
+        self.as_ref().new_transform(service)
     }
 }
 
-/// Trait for types that can be converted to a `TransformService`
+/// Trait for types that can be converted to a *transform service*
 pub trait IntoTransform<T, S>
 where
     T: Transform<S>,
@@ -129,15 +88,6 @@ where
     fn into_transform(self) -> T;
 }
 
-/// Trait for types that can be converted to a TransfromNewService
-pub trait IntoNewTransform<T, S>
-where
-    T: NewTransform<S>,
-{
-    /// Convert to an `TranformNewService`
-    fn into_new_transform(self) -> T;
-}
-
 impl<T, S> IntoTransform<T, S> for T
 where
     T: Transform<S>,
@@ -147,11 +97,79 @@ where
     }
 }
 
-impl<T, S> IntoNewTransform<T, S> for T
+/// `Apply` transform new service
+#[derive(Clone)]
+pub struct ApplyTransform<T, A, C> {
+    a: A,
+    t: Rc<T>,
+    _t: std::marker::PhantomData<C>,
+}
+
+impl<T, A, C> ApplyTransform<T, A, C>
 where
-    T: NewTransform<S>,
+    A: NewService<C>,
+    T: Transform<A::Service, Error = A::Error, InitError = A::InitError>,
 {
-    fn into_new_transform(self) -> T {
-        self
+    /// Create new `ApplyNewService` new service instance
+    pub fn new<F: IntoTransform<T, A::Service>>(t: F, a: A) -> Self {
+        Self {
+            a,
+            t: Rc::new(t.into_transform()),
+            _t: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<T, A, C> NewService<C> for ApplyTransform<T, A, C>
+where
+    A: NewService<C>,
+    T: Transform<A::Service, Error = A::Error, InitError = A::InitError>,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+
+    type Service = T::Transform;
+    type InitError = T::InitError;
+    type Future = ApplyTransformFuture<T, A, C>;
+
+    fn new_service(&self, cfg: &C) -> Self::Future {
+        ApplyTransformFuture {
+            t_cell: self.t.clone(),
+            fut_a: self.a.new_service(cfg).into_future(),
+            fut_t: None,
+        }
+    }
+}
+
+pub struct ApplyTransformFuture<T, A, C>
+where
+    A: NewService<C>,
+    T: Transform<A::Service, Error = A::Error, InitError = A::InitError>,
+{
+    fut_a: A::Future,
+    fut_t: Option<<T::Future as IntoFuture>::Future>,
+    t_cell: Rc<T>,
+}
+
+impl<T, A, C> Future for ApplyTransformFuture<T, A, C>
+where
+    A: NewService<C>,
+    T: Transform<A::Service, Error = A::Error, InitError = A::InitError>,
+{
+    type Item = T::Transform;
+    type Error = T::InitError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        if self.fut_t.is_none() {
+            if let Async::Ready(service) = self.fut_a.poll()? {
+                self.fut_t = Some(self.t_cell.new_transform(service).into_future());
+            }
+        }
+        if let Some(ref mut fut) = self.fut_t {
+            fut.poll()
+        } else {
+            Ok(Async::NotReady)
+        }
     }
 }

actix-service/src/transform_map_err.rs

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

actix-test-server/Cargo.toml

@@ -33,12 +33,11 @@ ssl = ["openssl", "actix-server/ssl"]
 rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
 
 [dependencies]
-actix-rt = "0.1.0"
-actix-server = "0.2.0"
+actix-rt = "0.2.0"
+# actix-server = "0.3.3"
+actix-server = { path="../actix-server" }
 
 log = "0.4"
-
-# io
 net2 = "0.2"
 futures = "0.1"
 tokio-tcp = "0.1"
@@ -55,3 +54,6 @@ 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]
+actix-service = "0.3.3"

actix-test-server/src/lib.rs

@@ -13,27 +13,24 @@ use tokio_tcp::TcpStream;
 /// The `TestServer` type.
 ///
 /// `TestServer` is very simple test server that simplify process of writing
-/// integration tests cases for actix applications.
+/// integration tests for actix-net applications.
 ///
 /// # Examples
 ///
 /// ```rust
-/// # extern crate actix_test_server;
-/// # use actix_web::*;
-/// #
-/// # fn my_handler(req: &HttpRequest) -> HttpResponse {
-/// #     HttpResponse::Ok().into()
-/// # }
-/// #
-/// # fn main() {
+/// use actix_service::{fn_service, IntoNewService};
 /// use actix_test_server::TestServer;
 ///
-/// let mut srv = TestServer::new(|app| app.handler(my_handler));
+/// fn main() {
+///     let srv = TestServer::with(|| fn_service(
+///         |sock| {
+///             println!("New connection: {:?}", sock);
+///             Ok::<_, ()>(())
+///         }
+///     ));
 ///
-/// let req = srv.get().finish().unwrap();
-/// let response = srv.execute(req.send()).unwrap();
-/// assert!(response.status().is_success());
-/// # }
+///     println!("SOCKET: {:?}", srv.connect());
+/// }
 /// ```
 pub struct TestServer;
 
@@ -57,13 +54,13 @@ impl TestServer {
             let local_addr = tcp.local_addr().unwrap();
 
             Server::build()
-                .listen("test", tcp, factory)
+                .listen("test", tcp, factory)?
                 .workers(1)
                 .disable_signals()
                 .start();
 
             tx.send((System::current(), local_addr)).unwrap();
-            sys.run();
+            sys.run()
         });
 
         let (system, addr) = rx.recv().unwrap();

actix-utils/CHANGES.md

@@ -1,5 +1,51 @@
 # Changes
 
+## [0.3.3] - 2019-03-09
+
+### Changed
+
+* Revert IntoFuture change
+
+* Add generic config param for IntoFramed and TakeOne new services
+
+
+## [0.3.2] - 2019-03-04
+
+### Changed
+
+* Use IntoFuture for new services
+
+
+## [0.3.1] - 2019-03-04
+
+### Changed
+
+* Use new type of transform trait
+
+
+## [0.3.0] - 2019-03-02
+
+### Changed
+
+* Use new `NewService` trait
+
+* BoxedNewService` and `BoxedService` types moved to actix-service crate.
+
+
+## [0.2.4] - 2019-02-21
+
+### Changed
+
+* Custom `BoxedNewService` implementation.
+
+
+## [0.2.3] - 2019-02-21
+
+### Added
+
+* Add `BoxedNewService` and `BoxedService`
+
+
 ## [0.2.2] - 2019-02-11
 
 ### Added

actix-utils/Cargo.toml

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

actix-utils/src/either.rs

@@ -1,6 +1,6 @@
 //! Contains `Either` service and related types and functions.
 use actix_service::{NewService, Service};
-use futures::{future, try_ready, Async, Future, Poll};
+use futures::{future, try_ready, Async, Future, IntoFuture, Poll};
 
 /// Combine two different service types into a single type.
 ///
@@ -53,10 +53,11 @@ pub enum Either<A, B> {
 }
 
 impl<A, B> Either<A, B> {
-    pub fn new_a(srv: A) -> Self
+    pub fn new_a<C>(srv: A) -> Self
     where
-        A: NewService,
+        A: NewService<C>,
         B: NewService<
+            C,
             Request = A::Request,
             Response = A::Response,
             Error = A::Error,
@@ -66,10 +67,11 @@ impl<A, B> Either<A, B> {
         Either::A(srv)
     }
 
-    pub fn new_b(srv: B) -> Self
+    pub fn new_b<C>(srv: B) -> Self
     where
-        A: NewService,
+        A: NewService<C>,
         B: NewService<
+            C,
             Request = A::Request,
             Response = A::Response,
             Error = A::Error,
@@ -80,10 +82,11 @@ impl<A, B> Either<A, B> {
     }
 }
 
-impl<A, B> NewService for Either<A, B>
+impl<A, B, C> NewService<C> for Either<A, B>
 where
-    A: NewService,
+    A: NewService<C>,
     B: NewService<
+        C,
         Request = A::Request,
         Response = A::Response,
         Error = A::Error,
@@ -95,12 +98,12 @@ where
     type Error = A::Error;
     type InitError = A::InitError;
     type Service = EitherService<A::Service, B::Service>;
-    type Future = EitherNewService<A, B>;
+    type Future = EitherNewService<A, B, 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)),
         }
     }
 }
@@ -115,15 +118,16 @@ impl<A: Clone, B: Clone> Clone for Either<A, B> {
 }
 
 #[doc(hidden)]
-pub enum EitherNewService<A: NewService, B: NewService> {
-    A(A::Future),
-    B(B::Future),
+pub enum EitherNewService<A: NewService<C>, B: NewService<C>, C> {
+    A(<A::Future as IntoFuture>::Future),
+    B(<B::Future as IntoFuture>::Future),
 }
 
-impl<A, B> Future for EitherNewService<A, B>
+impl<A, B, C> Future for EitherNewService<A, B, C>
 where
-    A: NewService,
+    A: NewService<C>,
     B: NewService<
+        C,
         Request = A::Request,
         Response = A::Response,
         Error = A::Error,

actix-utils/src/framed.rs

@@ -7,7 +7,7 @@ use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use actix_service::{IntoNewService, IntoService, NewService, Service};
 use futures::future::{ok, FutureResult};
 use futures::task::AtomicTask;
-use futures::{Async, Future, Poll, Sink, Stream};
+use futures::{Async, Future, IntoFuture, Poll, Sink, Stream};
 use log::debug;
 
 use crate::cell::Cell;
@@ -15,14 +15,15 @@ use crate::cell::Cell;
 type Request<U> = <U as Decoder>::Item;
 type Response<U> = <U as Encoder>::Item;
 
-pub struct FramedNewService<S, T, U> {
+pub struct FramedNewService<S, T, U, C> {
     factory: S,
-    _t: PhantomData<(T, U)>,
+    _t: PhantomData<(T, U, C)>,
 }
 
-impl<S, T, U> FramedNewService<S, T, U>
+impl<S, T, U, C> FramedNewService<S, T, U, C>
 where
-    S: NewService<Request = Request<U>, Response = Response<U>>,
+    C: Clone,
+    S: NewService<C, Request = Request<U>, Response = Response<U>>,
     S::Error: 'static,
     <S::Service as Service>::Future: 'static,
     T: AsyncRead + AsyncWrite,
@@ -30,7 +31,7 @@ where
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: std::fmt::Debug,
 {
-    pub fn new<F1: IntoNewService<S>>(factory: F1) -> Self {
+    pub fn new<F1: IntoNewService<S, C>>(factory: F1) -> Self {
         Self {
             factory: factory.into_new_service(),
             _t: PhantomData,
@@ -38,7 +39,7 @@ where
     }
 }
 
-impl<S, T, U> Clone for FramedNewService<S, T, U>
+impl<S, T, U, C> Clone for FramedNewService<S, T, U, C>
 where
     S: Clone,
 {
@@ -50,9 +51,10 @@ where
     }
 }
 
-impl<S, T, U> NewService for FramedNewService<S, T, U>
+impl<S, T, U, C> NewService<C> for FramedNewService<S, T, U, C>
 where
-    S: NewService<Request = Request<U>, Response = Response<U>> + Clone,
+    C: Clone,
+    S: NewService<C, Request = Request<U>, Response = Response<U>> + Clone,
     S::Error: 'static,
     <S::Service as Service>::Future: 'static,
     T: AsyncRead + AsyncWrite,
@@ -64,48 +66,53 @@ where
     type Response = FramedTransport<S::Service, T, U>;
     type Error = S::InitError;
     type InitError = S::InitError;
-    type Service = FramedService<S, T, U>;
+    type Service = FramedService<S, T, U, C>;
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &C) -> Self::Future {
         ok(FramedService {
             factory: self.factory.clone(),
+            config: cfg.clone(),
             _t: PhantomData,
         })
     }
 }
 
-pub struct FramedService<S, T, U> {
+pub struct FramedService<S, T, U, C> {
     factory: S,
+    config: C,
     _t: PhantomData<(T, U)>,
 }
 
-impl<S, T, U> Clone for FramedService<S, T, U>
+impl<S, T, U, C> Clone for FramedService<S, T, U, C>
 where
     S: Clone,
+    C: Clone,
 {
     fn clone(&self) -> Self {
         Self {
             factory: self.factory.clone(),
+            config: self.config.clone(),
             _t: PhantomData,
         }
     }
 }
 
-impl<S, T, U> Service for FramedService<S, T, U>
+impl<S, T, U, C> Service for FramedService<S, T, U, C>
 where
-    S: NewService<Request = Request<U>, Response = Response<U>>,
+    S: NewService<C, Request = Request<U>, Response = Response<U>>,
     S::Error: 'static,
     <S::Service as Service>::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: std::fmt::Debug,
+    C: Clone,
 {
     type Request = Framed<T, U>;
     type Response = FramedTransport<S::Service, T, U>;
     type Error = S::InitError;
-    type Future = FramedServiceResponseFuture<S, T, U>;
+    type Future = FramedServiceResponseFuture<S, T, U, C>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
         Ok(Async::Ready(()))
@@ -113,17 +120,16 @@ where
 
     fn call(&mut self, req: Framed<T, U>) -> Self::Future {
         FramedServiceResponseFuture {
-            fut: self.factory.new_service(),
-
+            fut: self.factory.new_service(&self.config),
             framed: Some(req),
         }
     }
 }
 
 #[doc(hidden)]
-pub struct FramedServiceResponseFuture<S, T, U>
+pub struct FramedServiceResponseFuture<S, T, U, C>
 where
-    S: NewService<Request = Request<U>, Response = Response<U>>,
+    S: NewService<C, Request = Request<U>, Response = Response<U>>,
     S::Error: 'static,
     <S::Service as Service>::Future: 'static,
     T: AsyncRead + AsyncWrite,
@@ -131,13 +137,13 @@ where
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: std::fmt::Debug,
 {
-    fut: S::Future,
+    fut: <S::Future as IntoFuture>::Future,
     framed: Option<Framed<T, U>>,
 }
 
-impl<S, T, U> Future for FramedServiceResponseFuture<S, T, U>
+impl<S, T, U, C> Future for FramedServiceResponseFuture<S, T, U, C>
 where
-    S: NewService<Request = Request<U>, Response = Response<U>>,
+    S: NewService<C, Request = Request<U>, Response = Response<U>>,
     S::Error: 'static,
     <S::Service as Service>::Future: 'static,
     T: AsyncRead + AsyncWrite,
@@ -402,7 +408,7 @@ where
     }
 }
 
-impl<T, U, F> NewService for IntoFramed<T, U, F>
+impl<T, C, U, F> NewService<C> for IntoFramed<T, U, F>
 where
     T: AsyncRead + AsyncWrite,
     F: Fn() -> U + Send + Clone + 'static,
@@ -415,7 +421,7 @@ where
     type Service = IntoFramedService<T, U, F>;
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, _: &C) -> Self::Future {
         ok(IntoFramedService {
             factory: self.factory.clone(),
             _t: PhantomData,

actix-utils/src/inflight.rs

@@ -1,4 +1,4 @@
-use actix_service::{NewTransform, Service, Transform};
+use actix_service::{Service, Transform, Void};
 use futures::future::{ok, FutureResult};
 use futures::{Async, Future, Poll};
 
@@ -24,32 +24,34 @@ impl Default for InFlight {
     }
 }
 
-impl<T: Service> NewTransform<T> for InFlight {
-    type Request = T::Request;
-    type Response = T::Response;
-    type Error = T::Error;
-    type InitError = ();
-    type Transform = InFlightService;
+impl<S: Service> Transform<S> for InFlight {
+    type Request = S::Request;
+    type Response = S::Response;
+    type Error = S::Error;
+    type InitError = Void;
+    type Transform = InFlightService<S>;
     type Future = FutureResult<Self::Transform, Self::InitError>;
 
-    fn new_transform(&self) -> Self::Future {
-        ok(InFlightService::new(self.max_inflight))
+    fn new_transform(&self, service: S) -> Self::Future {
+        ok(InFlightService::new(self.max_inflight, service))
     }
 }
 
-pub struct InFlightService {
+pub struct InFlightService<S> {
     count: Counter,
+    service: S,
 }
 
-impl InFlightService {
-    pub fn new(max: usize) -> Self {
+impl<S> InFlightService<S> {
+    pub fn new(max: usize, service: S) -> Self {
         Self {
+            service,
             count: Counter::new(max),
         }
     }
 }
 
-impl<T> Transform<T> for InFlightService
+impl<T> Service for InFlightService<T>
 where
     T: Service,
 {
@@ -59,6 +61,8 @@ where
     type Future = InFlightServiceResponse<T>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.service.poll_ready()?;
+
         if !self.count.available() {
             log::trace!("InFlight limit exceeded");
             Ok(Async::NotReady)
@@ -67,9 +71,9 @@ where
         }
     }
 
-    fn call(&mut self, req: T::Request, service: &mut T) -> Self::Future {
+    fn call(&mut self, req: T::Request) -> Self::Future {
         InFlightServiceResponse {
-            fut: service.call(req),
+            fut: self.service.call(req),
             _guard: self.count.get(),
         }
     }
@@ -98,7 +102,8 @@ mod tests {
     use std::time::Duration;
 
     use super::*;
-    use actix_service::{Blank, BlankNewService, NewService, Service, ServiceExt};
+    use actix_service::blank::{Blank, BlankNewService};
+    use actix_service::{NewService, Service, ServiceExt};
 
     struct SleepService(Duration);
 
@@ -121,7 +126,8 @@ mod tests {
     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));
+            let mut srv =
+                Blank::new().and_then(InFlightService::new(1, SleepService(wait_time)));
             assert_eq!(srv.poll_ready(), Ok(Async::Ready(())));
 
             let mut res = srv.call(());
@@ -142,7 +148,7 @@ mod tests {
             let srv =
                 BlankNewService::new().apply(InFlight::new(1), || Ok(SleepService(wait_time)));
 
-            if let Async::Ready(mut srv) = srv.new_service().poll().unwrap() {
+            if let Async::Ready(mut srv) = srv.new_service(&()).poll().unwrap() {
                 assert_eq!(srv.poll_ready(), Ok(Async::Ready(())));
 
                 let mut res = srv.call(());

actix-utils/src/keepalive.rs

@@ -1,13 +1,12 @@
 use std::marker::PhantomData;
 use std::time::{Duration, Instant};
 
-use actix_service::{NewService, Service};
+use actix_service::{NewService, Service, Void};
 use futures::future::{ok, FutureResult};
 use futures::{Async, Future, Poll};
 use tokio_timer::Delay;
 
 use super::time::{LowResTime, LowResTimeService};
-use super::Never;
 
 pub struct KeepAlive<R, E, F> {
     f: F,
@@ -44,18 +43,18 @@ where
     }
 }
 
-impl<R, E, F> NewService 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(),

actix-utils/src/lib.rs

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

actix-utils/src/order.rs

@@ -3,7 +3,7 @@ use std::fmt;
 use std::marker::PhantomData;
 use std::rc::Rc;
 
-use actix_service::{NewTransform, Service, Transform};
+use actix_service::{Service, Transform, Void};
 use futures::future::{ok, FutureResult};
 use futures::task::AtomicTask;
 use futures::unsync::oneshot;
@@ -63,13 +63,8 @@ where
         Self { _t: PhantomData }
     }
 
-    pub fn service() -> impl Transform<
-        S,
-        Request = S::Request,
-        Response = S::Response,
-        Error = InOrderError<S::Error>,
-    > {
-        InOrderService::new()
+    pub fn service(service: S) -> InOrderService<S> {
+        InOrderService::new(service)
     }
 }
 
@@ -85,7 +80,7 @@ where
     }
 }
 
-impl<S> NewTransform<S> for InOrder<S>
+impl<S> Transform<S> for InOrder<S>
 where
     S: Service,
     S::Response: 'static,
@@ -95,16 +90,17 @@ where
     type Request = S::Request;
     type Response = S::Response;
     type Error = InOrderError<S::Error>;
-    type InitError = ();
+    type InitError = Void;
     type Transform = InOrderService<S>;
     type Future = FutureResult<Self::Transform, Self::InitError>;
 
-    fn new_transform(&self) -> Self::Future {
-        ok(InOrderService::new())
+    fn new_transform(&self, service: S) -> Self::Future {
+        ok(InOrderService::new(service))
     }
 }
 
 pub struct InOrderService<S: Service> {
+    service: S,
     task: Rc<AtomicTask>,
     acks: VecDeque<Record<S::Response, S::Error>>,
 }
@@ -116,27 +112,16 @@ where
     S::Future: 'static,
     S::Error: 'static,
 {
-    pub fn new() -> Self {
+    pub fn new(service: S) -> Self {
         Self {
+            service,
             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>
+impl<S> Service for InOrderService<S>
 where
     S: Service,
     S::Response: 'static,
@@ -149,8 +134,12 @@ where
     type Future = InOrderServiceResponse<S>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        // poll_ready could be called from different task
         self.task.register();
 
+        // check nested service
+        self.service.poll_ready().map_err(InOrderError::Service)?;
+
         // check acks
         while !self.acks.is_empty() {
             let rec = self.acks.front_mut().unwrap();
@@ -167,13 +156,13 @@ where
         Ok(Async::Ready(()))
     }
 
-    fn call(&mut self, request: S::Request, service: &mut S) -> Self::Future {
+    fn call(&mut self, request: S::Request) -> 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| {
+        tokio_current_thread::spawn(self.service.call(request).then(move |res| {
             task.notify();
             let _ = tx1.send(res);
             Ok(())
@@ -210,7 +199,8 @@ mod tests {
     use std::time::Duration;
 
     use super::*;
-    use actix_service::{Blank, Service, ServiceExt};
+    use actix_service::blank::Blank;
+    use actix_service::{Service, ServiceExt};
 
     struct Srv;
 
@@ -256,7 +246,7 @@ mod tests {
             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 mut srv = Blank::new().and_then(InOrderService::new(Srv));
 
                 let res1 = srv.call(rx1);
                 let res2 = srv.call(rx2);

actix-utils/src/stream.rs

@@ -29,20 +29,21 @@ where
     }
 }
 
-pub struct StreamNewService<S, T, E> {
+pub struct StreamNewService<S, T, E, C> {
     factory: Rc<T>,
-    _t: PhantomData<(S, E)>,
+    _t: PhantomData<(S, E, C)>,
 }
 
-impl<S, T, E> StreamNewService<S, T, E>
+impl<S, T, E, C> StreamNewService<S, T, E, C>
 where
+    C: Clone,
     S: IntoStream,
-    T: NewService<Request = Request<S>, Response = (), Error = E, InitError = E>,
+    T: NewService<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>>(factory: F) -> Self {
+    pub fn new<F: IntoNewService<T, C>>(factory: F) -> Self {
         Self {
             factory: Rc::new(factory.into_new_service()),
             _t: PhantomData,
@@ -50,7 +51,7 @@ where
     }
 }
 
-impl<S, T, E> Clone for StreamNewService<S, T, E> {
+impl<S, T, E, C> Clone for StreamNewService<S, T, E, C> {
     fn clone(&self) -> Self {
         Self {
             factory: self.factory.clone(),
@@ -59,10 +60,11 @@ impl<S, T, E> Clone for StreamNewService<S, T, E> {
     }
 }
 
-impl<S, T, E> NewService for StreamNewService<S, T, E>
+impl<S, T, E, C> NewService<C> for StreamNewService<S, T, E, C>
 where
+    C: Clone,
     S: IntoStream + 'static,
-    T: NewService<Request = Request<S>, Response = (), Error = E, InitError = E>,
+    T: NewService<C, Request = Request<S>, Response = (), Error = E, InitError = E>,
     T::Future: 'static,
     T::Service: 'static,
     <T::Service as Service>::Future: 'static,
@@ -71,29 +73,32 @@ where
     type Response = ();
     type Error = E;
     type InitError = E;
-    type Service = StreamService<S, T, E>;
+    type Service = StreamService<S, T, E, C>;
     type Future = FutureResult<Self::Service, E>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, cfg: &C) -> Self::Future {
         ok(StreamService {
             factory: self.factory.clone(),
+            config: cfg.clone(),
             _t: PhantomData,
         })
     }
 }
 
-pub struct StreamService<S, T, E> {
+pub struct StreamService<S, T, E, C = ()> {
     factory: Rc<T>,
+    config: C,
     _t: PhantomData<(S, E)>,
 }
 
-impl<S, T, E> Service for StreamService<S, T, E>
+impl<S, T, E, C> Service for StreamService<S, T, E, C>
 where
     S: IntoStream + 'static,
-    T: NewService<Request = Request<S>, Response = (), Error = E, InitError = E>,
+    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 = ();
@@ -107,7 +112,7 @@ where
     fn call(&mut self, req: S) -> Self::Future {
         Box::new(
             self.factory
-                .new_service()
+                .new_service(&self.config)
                 .and_then(move |srv| StreamDispatcher::new(req, srv)),
         )
     }
@@ -227,7 +232,7 @@ impl<T> Clone for TakeItem<T> {
     }
 }
 
-impl<T: Stream> NewService for TakeItem<T> {
+impl<T: Stream, C> NewService<C> for TakeItem<T> {
     type Request = T;
     type Response = (Option<T::Item>, T);
     type Error = T::Error;
@@ -235,7 +240,7 @@ impl<T: Stream> NewService for TakeItem<T> {
     type Service = TakeItemService<T>;
     type Future = FutureResult<Self::Service, Self::InitError>;
 
-    fn new_service(&self) -> Self::Future {
+    fn new_service(&self, _: &C) -> Self::Future {
         ok(TakeItemService { _t: PhantomData })
     }
 }

actix-utils/src/time.rs

@@ -1,12 +1,11 @@
 use std::time::{self, Duration, Instant};
 
-use actix_service::{NewService, Service};
+use actix_service::{NewService, Service, Void};
 use futures::future::{ok, FutureResult};
 use futures::{Async, Future, Poll};
 use tokio_timer::sleep;
 
 use super::cell::Cell;
-use super::Never;
 
 #[derive(Clone, Debug)]
 pub struct LowResTime(Cell<Inner>);
@@ -42,15 +41,15 @@ impl Default for LowResTime {
     }
 }
 
-impl NewService 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())
     }
 }
@@ -92,7 +91,7 @@ impl 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> {

actix-utils/src/timeout.rs

@@ -6,7 +6,7 @@ use std::fmt;
 use std::marker::PhantomData;
 use std::time::Duration;
 
-use actix_service::{NewTransform, Service, Transform};
+use actix_service::{Service, Transform};
 use futures::future::{ok, FutureResult};
 use futures::{Async, Future, Poll};
 use tokio_timer::{clock, Delay};
@@ -80,7 +80,7 @@ impl<E> Clone for Timeout<E> {
     }
 }
 
-impl<S, E> NewTransform<S> for Timeout<E>
+impl<S, E> Transform<S> for Timeout<E>
 where
     S: Service,
 {
@@ -88,11 +88,12 @@ where
     type Response = S::Response;
     type Error = TimeoutError<S::Error>;
     type InitError = E;
-    type Transform = TimeoutService;
+    type Transform = TimeoutService<S>;
     type Future = FutureResult<Self::Transform, Self::InitError>;
 
-    fn new_transform(&self) -> Self::Future {
+    fn new_transform(&self, service: S) -> Self::Future {
         ok(TimeoutService {
+            service,
             timeout: self.timeout,
         })
     }
@@ -100,17 +101,18 @@ where
 
 /// Applies a timeout to requests.
 #[derive(Debug, Clone)]
-pub struct TimeoutService {
+pub struct TimeoutService<S> {
+    service: S,
     timeout: Duration,
 }
 
-impl TimeoutService {
-    pub fn new(timeout: Duration) -> Self {
-        TimeoutService { timeout }
+impl<S> TimeoutService<S> {
+    pub fn new(timeout: Duration, service: S) -> Self {
+        TimeoutService { service, timeout }
     }
 }
 
-impl<S> Transform<S> for TimeoutService
+impl<S> Service for TimeoutService<S>
 where
     S: Service,
 {
@@ -120,12 +122,12 @@ where
     type Future = TimeoutServiceResponse<S>;
 
     fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
+        self.service.poll_ready().map_err(TimeoutError::Service)
     }
 
-    fn call(&mut self, request: S::Request, service: &mut S) -> Self::Future {
+    fn call(&mut self, request: S::Request) -> Self::Future {
         TimeoutServiceResponse {
-            fut: service.call(request),
+            fut: self.service.call(request),
             sleep: Delay::new(clock::now() + self.timeout),
         }
     }
@@ -170,7 +172,8 @@ mod tests {
     use std::time::Duration;
 
     use super::*;
-    use actix_service::{Blank, BlankNewService, NewService, Service, ServiceExt};
+    use actix_service::blank::{Blank, BlankNewService};
+    use actix_service::{NewService, Service, ServiceExt};
 
     struct SleepService(Duration);
 
@@ -196,7 +199,7 @@ mod tests {
 
         let res = actix_rt::System::new("test").block_on(lazy(|| {
             let mut timeout = Blank::default()
-                .apply(TimeoutService::new(resolution), SleepService(wait_time));
+                .and_then(TimeoutService::new(resolution, SleepService(wait_time)));
             timeout.call(())
         }));
         assert_eq!(res, Ok(()));
@@ -209,7 +212,7 @@ mod tests {
 
         let res = actix_rt::System::new("test").block_on(lazy(|| {
             let mut timeout = Blank::default()
-                .apply(TimeoutService::new(resolution), SleepService(wait_time));
+                .and_then(TimeoutService::new(resolution, SleepService(wait_time)));
             timeout.call(())
         }));
         assert_eq!(res, Err(TimeoutError::Timeout));
@@ -221,9 +224,9 @@ mod tests {
         let wait_time = Duration::from_millis(150);
 
         let res = actix_rt::System::new("test").block_on(lazy(|| {
-            let timeout = BlankNewService::<_, _, ()>::default()
+            let timeout = BlankNewService::<(), (), ()>::default()
                 .apply(Timeout::new(resolution), || Ok(SleepService(wait_time)));
-            if let Async::Ready(mut to) = timeout.new_service().poll().unwrap() {
+            if let Async::Ready(mut to) = timeout.new_service(&()).poll().unwrap() {
                 to.call(())
             } else {
                 panic!()

examples/basic.rs

@@ -5,12 +5,12 @@ use std::sync::{
     atomic::{AtomicUsize, Ordering},
     Arc,
 };
-use std::{env, fmt};
+use std::{env, fmt, io};
 
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_rt::System;
-use actix_server::Server;
-use actix_service::{IntoNewService, NewService};
+use actix_server::{Io, Server};
+use actix_service::{fn_service, NewService};
 use futures::{future, Future};
 use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
 use tokio_openssl::SslAcceptorExt;
@@ -23,7 +23,7 @@ fn logger<T: AsyncRead + AsyncWrite + fmt::Debug>(
     future::ok(stream)
 }
 
-fn main() {
+fn main() -> io::Result<()> {
     env::set_var("RUST_LOG", "actix_net=trace");
     env_logger::init();
 
@@ -54,16 +54,14 @@ fn main() {
                 let acceptor = acceptor.clone();
 
                 // service for converting incoming TcpStream to a SslStream<TcpStream>
-                (move |stream| {
-                    SslAcceptorExt::accept_async(&acceptor, stream)
+                fn_service(move |stream: Io<tokio_tcp::TcpStream>| {
+                    SslAcceptorExt::accept_async(&acceptor, stream.into_parts().0)
                         .map_err(|e| println!("Openssl error: {}", e))
                 })
-                // convert closure to a `NewService`
-                .into_new_service()
                 // .and_then() combinator uses other service to convert incoming `Request` to a
                 // `Response` and then uses that response as an input for next
                 // service. in this case, on success we use `logger` service
-                .and_then(logger)
+                .and_then(fn_service(logger))
                 // Next service counts number of connections
                 .and_then(move |_| {
                     let num = num.fetch_add(1, Ordering::Relaxed);
@@ -75,5 +73,5 @@ fn main() {
         .unwrap()
         .start();
 
-    sys.run();
+    sys.run()
 }

examples/ssl.rs

@@ -1,13 +1,13 @@
+use std::io;
 use std::sync::{
     atomic::{AtomicUsize, Ordering},
     Arc,
 };
 
-use actix_codec::{AsyncRead, AsyncWrite};
 use actix_rt::System;
 use actix_server::{ssl, Server};
 use actix_service::NewService;
-use futures::{future, Future};
+use futures::future;
 use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
 
 #[derive(Debug)]
@@ -15,16 +15,7 @@ struct ServiceState {
     num: Arc<AtomicUsize>,
 }
 
-fn service<T: AsyncRead + AsyncWrite>(
-    st: &mut ServiceState,
-    _: T,
-) -> impl Future<Item = (), Error = ()> {
-    let num = st.num.fetch_add(1, Ordering::Relaxed);
-    println!("got ssl connection {:?}", num);
-    future::ok(())
-}
-
-fn main() {
+fn main() -> io::Result<()> {
     let sys = System::new("test");
 
     // load ssl keys
@@ -53,9 +44,8 @@ fn main() {
                     println!("got ssl connection {:?}", num);
                     future::ok(())
                 })
-        })
-        .unwrap()
+        })?
         .start();
 
-    sys.run();
+    sys.run()
 }

router/CHANGES.txt

@@ -0,0 +1,5 @@
+# Changes
+
+## [0.1.0] - 2019-03-09
+
+* Initial release

router/src/lib.rs

@@ -9,6 +9,10 @@ pub use self::path::Path;
 pub use self::resource::ResourceDef;
 pub use self::router::{ResourceInfo, Router, RouterBuilder};
 
+pub trait Resource<T: ResourcePath> {
+    fn resource_path(&mut self) -> &mut Path<T>;
+}
+
 pub trait ResourcePath {
     fn path(&self) -> &str;
 }

router/src/path.rs

@@ -4,7 +4,7 @@ use std::rc::Rc;
 use serde::de;
 
 use crate::de::PathDeserializer;
-use crate::ResourcePath;
+use crate::{Resource, ResourcePath};
 
 #[derive(Debug, Clone, Copy)]
 pub(crate) enum PathItem {
@@ -202,3 +202,9 @@ impl<T: ResourcePath> Index<usize> for Path<T> {
         }
     }
 }
+
+impl<T: ResourcePath> Resource<T> for Path<T> {
+    fn resource_path(&mut self) -> &mut Self {
+        self
+    }
+}

router/src/resource.rs

@@ -14,26 +14,13 @@ const MAX_DYNAMIC_SEGMENTS: usize = 16;
 /// Resource definition can contain only 16 dynamic segments
 #[derive(Clone, Debug)]
 pub struct ResourceDef {
+    id: u16,
     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),
@@ -64,13 +51,25 @@ impl ResourceDef {
         ResourceDef::with_prefix(path, true)
     }
 
-    /// Construct external resource def
+    /// Parse path pattern and create new `Pattern` instance.
+    /// Inserts `/` to begging of the pattern.
     ///
-    /// 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
+    ///
+    /// Use `prefix` type instead of `static`.
+    ///
+    /// Panics if path regex pattern is wrong.
+    pub fn root_prefix(path: &str) -> Self {
+        ResourceDef::with_prefix(&insert_slash(path), true)
+    }
+
+    /// Resource id
+    pub fn id(&self) -> u16 {
+        self.id
+    }
+
+    /// Set resource id
+    pub fn set_id(&mut self, id: u16) {
+        self.id = id;
     }
 
     /// Parse path pattern and create new `Pattern` instance with custom prefix
@@ -98,12 +97,22 @@ impl ResourceDef {
         ResourceDef {
             tp,
             elements,
+            id: 0,
             name: String::new(),
-            rtp: ResourceType::Normal,
             pattern: path.to_owned(),
         }
     }
 
+    /// Resource pattern name
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// Mutable reference to a name of a resource definition.
+    pub fn name_mut(&mut self) -> &mut String {
+        &mut self.name
+    }
+
     /// Path pattern of the resource
     pub fn pattern(&self) -> &str {
         &self.pattern
@@ -118,6 +127,57 @@ impl ResourceDef {
         }
     }
 
+    /// Is prefix path a match against this resource?
+    pub fn is_prefix_match(&self, path: &str) -> Option<usize> {
+        let plen = path.len();
+        let path = if path.is_empty() { "/" } else { path };
+
+        match self.tp {
+            PatternType::Static(ref s) => {
+                if s == path {
+                    Some(plen)
+                } else {
+                    None
+                }
+            }
+            PatternType::Dynamic(ref re, _, len) => {
+                if let Some(captures) = re.captures(path) {
+                    let mut pos = 0;
+                    let mut passed = false;
+                    for capture in captures.iter() {
+                        if let Some(ref m) = capture {
+                            if !passed {
+                                passed = true;
+                                continue;
+                            }
+
+                            pos = m.end();
+                        }
+                    }
+                    Some(pos + len)
+                } else {
+                    None
+                }
+            }
+            PatternType::Prefix(ref s) => {
+                let len = if path == s {
+                    s.len()
+                } else if path.starts_with(s)
+                    && (s.ends_with('/') || path.split_at(s.len()).1.starts_with('/'))
+                {
+                    if s.ends_with('/') {
+                        s.len() - 1
+                    } else {
+                        s.len()
+                    }
+                } else {
+                    return None;
+                };
+                Some(min(plen, len))
+            }
+        }
+    }
+
     /// 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 {
@@ -180,34 +240,32 @@ impl ResourceDef {
         }
     }
 
-    // /// 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(())
-    // }
+    /// Build resource path from elements. Returns `true` on success.
+    pub fn resource_path<U, I>(&self, path: &mut String, elements: &mut U) -> bool
+    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 false;
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        true
+    }
 
     fn parse_param(pattern: &str) -> (PatternElement, String, &str) {
         const DEFAULT_PATTERN: &str = "[^/]+";
@@ -313,6 +371,14 @@ impl From<String> for ResourceDef {
     }
 }
 
+pub(crate) fn insert_slash(path: &str) -> String {
+    let mut path = path.to_owned();
+    if !path.is_empty() && !path.starts_with('/') {
+        path.insert(0, '/');
+    };
+    path
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -330,6 +396,11 @@ mod tests {
         assert!(!re.is_match("/name/"));
         assert!(!re.is_match("/name~"));
 
+        assert_eq!(re.is_prefix_match("/name"), Some(5));
+        assert_eq!(re.is_prefix_match("/name1"), None);
+        assert_eq!(re.is_prefix_match("/name/"), None);
+        assert_eq!(re.is_prefix_match("/name~"), None);
+
         let re = ResourceDef::new("/name/");
         assert!(re.is_match("/name/"));
         assert!(!re.is_match("/name"));
@@ -404,10 +475,21 @@ mod tests {
         assert!(re.is_match("/name1"));
         assert!(re.is_match("/name~"));
 
+        assert_eq!(re.is_prefix_match("/name"), Some(5));
+        assert_eq!(re.is_prefix_match("/name/"), Some(5));
+        assert_eq!(re.is_prefix_match("/name/test/test"), Some(5));
+        assert_eq!(re.is_prefix_match("/name1"), None);
+        assert_eq!(re.is_prefix_match("/name~"), None);
+
         let re = ResourceDef::prefix("/name/");
         assert!(re.is_match("/name/"));
         assert!(re.is_match("/name/gs"));
         assert!(!re.is_match("/name"));
+
+        let re = ResourceDef::root_prefix("name/");
+        assert!(re.is_match("/name/"));
+        assert!(re.is_match("/name/gs"));
+        assert!(!re.is_match("/name"));
     }
 
     #[test]
@@ -417,6 +499,10 @@ mod tests {
         assert!(re.is_match("/name/gs"));
         assert!(!re.is_match("/name"));
 
+        assert_eq!(re.is_prefix_match("/name/"), Some(6));
+        assert_eq!(re.is_prefix_match("/name/gs"), Some(6));
+        assert_eq!(re.is_prefix_match("/name"), None);
+
         let mut path = Path::new("/test2/");
         assert!(re.match_path(&mut path));
         assert_eq!(&path["name"], "test2");

router/src/router.rs

@@ -1,145 +1,97 @@
-use std::collections::HashMap;
-use std::rc::Rc;
-
-use crate::path::Path;
-use crate::resource::ResourceDef;
-use crate::ResourcePath;
+use crate::{Resource, ResourceDef, ResourcePath};
 
 #[derive(Debug, Copy, Clone, PartialEq)]
-pub(crate) enum ResourceId {
-    Default,
-    Normal(u16),
-}
+pub struct ResourceId(pub 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>,
-}
+pub struct Router<T, U = ()>(Vec<(ResourceDef, T, Option<U>)>);
 
-impl<T> Router<T> {
-    pub fn build() -> RouterBuilder<T> {
+impl<T, U> Router<T, U> {
+    pub fn build() -> RouterBuilder<T, U> {
         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));
-                }
+    pub fn recognize<R, P>(&self, path: &mut R) -> Option<(&T, ResourceId)>
+    where
+        R: Resource<P>,
+        P: ResourcePath,
+    {
+        for item in self.0.iter() {
+            if item.0.match_path(path.resource_path()) {
+                return Some((&item.1, ResourceId(item.0.id())));
             }
         }
         None
     }
 
-    pub fn recognize_mut<U: ResourcePath>(
+    pub fn recognize_mut<R, P>(&mut self, res: &mut R) -> Option<(&mut T, ResourceId)>
+    where
+        R: Resource<P>,
+        P: ResourcePath,
+    {
+        for item in self.0.iter_mut() {
+            if item.0.match_path(res.resource_path()) {
+                return Some((&mut item.1, ResourceId(item.0.id())));
+            }
+        }
+        None
+    }
+
+    pub fn recognize_mut_checked<R, P, F>(
         &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));
-                }
+        res: &mut R,
+        check: F,
+    ) -> Option<(&mut T, ResourceId)>
+    where
+        F: Fn(&R, &Option<U>) -> bool,
+        R: Resource<P>,
+        P: ResourcePath,
+    {
+        for item in self.0.iter_mut() {
+            if item.0.match_path(res.resource_path()) && check(res, &item.2) {
+                return Some((&mut item.1, ResourceId(item.0.id())));
             }
         }
         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()
-    }
+pub struct RouterBuilder<T, U = ()> {
+    resources: Vec<(ResourceDef, T, Option<U>)>,
 }
 
-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> {
+impl<T, U> RouterBuilder<T, U> {
     /// Register resource for specified path.
-    pub fn path(&mut self, path: &str, resource: T) {
-        self.rmap.register(ResourceDef::new(path));
-        self.resources.push(resource);
+    pub fn path(&mut self, path: &str, resource: T) -> &mut (ResourceDef, T, Option<U>) {
+        self.resources
+            .push((ResourceDef::new(path), resource, None));
+        self.resources.last_mut().unwrap()
     }
 
     /// 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);
+    pub fn prefix(&mut self, prefix: &str, resource: T) -> &mut (ResourceDef, T, Option<U>) {
+        self.resources
+            .push((ResourceDef::prefix(prefix), resource, None));
+        self.resources.last_mut().unwrap()
     }
 
     /// Register resource for ResourceDef
-    pub fn rdef(&mut self, rdef: ResourceDef, resource: T) {
-        self.rmap.register(rdef);
-        self.resources.push(resource);
+    pub fn rdef(&mut self, rdef: ResourceDef, resource: T) -> &mut (ResourceDef, T, Option<U>) {
+        self.resources.push((rdef, resource, None));
+        self.resources.last_mut().unwrap()
     }
 
     /// Finish configuration and create router instance.
-    pub fn finish(self) -> Router<T> {
-        Router {
-            rmap: Rc::new(self.rmap),
-            named: self.named,
-            resources: self.resources,
-        }
+    pub fn finish(self) -> Router<T, U> {
+        Router(self.resources)
     }
 }
 
@@ -151,14 +103,14 @@ mod tests {
     #[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);
+        router.path("/name", 10).0.set_id(0);
+        router.path("/name/{val}", 11).0.set_id(1);
+        router.path("/name/{val}/index.html", 12).0.set_id(2);
+        router.path("/file/{file}.{ext}", 13).0.set_id(3);
+        router.path("/v{val}/{val2}/index.html", 14).0.set_id(4);
+        router.path("/v/{tail:.*}", 15).0.set_id(5);
+        router.path("/test2/{test}.html", 16).0.set_id(6);
+        router.path("/{test}/index.html", 17).0.set_id(7);
         let mut router = router.finish();
 
         let mut path = Path::new("/unknown");
@@ -167,52 +119,52 @@ mod tests {
         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_eq!(info, ResourceId(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!(info, ResourceId(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!(info, ResourceId(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!(info, ResourceId(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!(info, ResourceId(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!(info, ResourceId(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!(info, ResourceId(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!(info, ResourceId(7));
         assert_eq!(path.get("test").unwrap(), "bbb");
     }
 
@@ -235,8 +187,8 @@ mod tests {
     #[test]
     fn test_recognizer_with_prefix() {
         let mut router = Router::<usize>::build();
-        router.path("/name", 10);
-        router.path("/name/{val}", 11);
+        router.path("/name", 10).0.set_id(0);
+        router.path("/name/{val}", 11).0.set_id(1);
         let mut router = router.finish();
 
         let mut path = Path::new("/name");
@@ -250,9 +202,9 @@ mod tests {
 
         let mut path = Path::new("/test/name/value");
         path.skip(5);
-        let (h, info) = router.recognize_mut(&mut path).unwrap();
+        let (h, id) = router.recognize_mut(&mut path).unwrap();
         assert_eq!(*h, 11);
-        assert_eq!(info.resource, ResourceId::Normal(1));
+        assert_eq!(id, ResourceId(1));
         assert_eq!(path.get("val").unwrap(), "value");
         assert_eq!(&path["val"], "value");
 
@@ -281,134 +233,4 @@ mod tests {
         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"
-    //         );
-    //     }
-    // }
 }