prepare release for rt and service

* intra doc conversion

* rm trailing blank comment

.github/workflows/bench.yml

@@ -1,29 +0,0 @@
-name: Benchmark (Linux)
-
-on:
-  pull_request:
-    types: [opened, synchronize, reopened]
-  push:
-    branches:
-      - master
-      - '1.0'
-
-jobs:
-  check_benchmark:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly
-          profile: minimal
-          override: true
-
-      - name: Check benchmark
-        uses: actions-rs/cargo@v1
-        with:
-          command: bench
-          args: --package=actix-service

.github/workflows/clippy-fmt.yml

@@ -31,4 +31,4 @@ jobs:
         uses: actions-rs/clippy-check@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features --all --tests
+          args: --workspace --tests

.github/workflows/linux.yml

@@ -14,7 +14,7 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - 1.42.0
+          - 1.46.0
           - stable
           - nightly
 
@@ -53,20 +53,20 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: check
-          args: --all --bins --examples --tests
+          args: --workspace --bins --examples --tests
 
       - name: tests
         uses: actions-rs/cargo@v1
         timeout-minutes: 40
         with:
           command: test
-          args: --all --all-features --no-fail-fast -- --nocapture
+          args: --workspace --exclude=actix-tls --no-fail-fast -- --nocapture
 
       - name: Generate coverage file
         if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
         run: |
           cargo install cargo-tarpaulin
-          cargo tarpaulin --out Xml --workspace --all-features
+          cargo tarpaulin --out Xml --workspace
 
       - name: Upload to Codecov
         if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')

.github/workflows/macos.yml

@@ -34,10 +34,10 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: check
-          args: --all --bins --examples --tests
+          args: --workspace --bins --examples --tests
 
       - name: tests
         uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --all --all-features --no-fail-fast -- --nocapture
+          args: --workspace --exclude=actix-tls --no-fail-fast -- --nocapture

.github/workflows/windows-mingw.yml

@@ -42,4 +42,4 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: check
-          args: --all --bins --examples --tests
+          args: --workspace --bins --examples --tests

.github/workflows/windows.yml

@@ -60,10 +60,10 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: check
-          args: --all --bins --examples --tests
+          args: --workspace --bins --examples --tests
 
       - name: tests
         uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --all --all-features --no-fail-fast -- --nocapture
+          args: --workspace --exclude=actix-tls --no-fail-fast -- --nocapture

CODE_OF_CONDUCT.md

@@ -34,10 +34,13 @@ This Code of Conduct applies both within project spaces and in public spaces whe
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at fafhrd91@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at robjtede@icloud.com ([@robjtede]) or huyuumi@neet.club ([@JohnTitor]). The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
 
 Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
 
+[@robjtede]: https://github.com/robjtede
+[@JohnTitor]: https://github.com/JohnTitor
+
 ## Attribution
 
 This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]

Cargo.toml

@@ -18,7 +18,7 @@ members = [
 [patch.crates-io]
 actix-codec = { path = "actix-codec" }
 actix-connect = { path = "actix-connect" }
-actix-rt = { path = "actix-rt" }
+actix-rt = { git = "https://github.com/actix/actix-net.git", rev = "ba44ea7d0bafaf5fccb9a34003d503e1910943ee" }
 actix-macros = { path = "actix-macros" }
 actix-server = { path = "actix-server" }
 actix-service = { path = "actix-service" }

README.md

@@ -14,7 +14,7 @@ Actix net - framework for composable network services
 ## Documentation & community resources
 
 * [Chat on Gitter](https://gitter.im/actix/actix)
-* Minimum supported Rust version: 1.42 or later
+* Minimum supported Rust version: 1.46 or later
 
 ## Example
 

actix-codec/CHANGES.md

@@ -1,6 +1,7 @@
 # Changes
 
 ## Unreleased - 2020-xx-xx
+* Upgrade `pin-project` to `1.0`.
 
 ## 0.3.0 - 2020-08-23
 * No changes from beta 2.

actix-codec/Cargo.toml

@@ -21,6 +21,6 @@ bytes = "0.5.2"
 futures-core = { version = "0.3.4", default-features = false }
 futures-sink = { version = "0.3.4", default-features = false }
 log = "0.4"
-pin-project = "0.4.17"
+pin-project = "1.0.0"
 tokio = { version = "0.2.5", default-features = false }
 tokio-util = { version = "0.3.1", default-features = false, features = ["codec"] }

actix-codec/src/lib.rs

@@ -4,13 +4,13 @@
 //! [`AsyncWrite`], to framed streams implementing [`Sink`] and [`Stream`].
 //! Framed streams are also known as `transports`.
 //!
-//! [`AsyncRead`]: AsyncRead
-//! [`AsyncWrite`]: AsyncWrite
 //! [`Sink`]: futures_sink::Sink
 //! [`Stream`]: futures_core::Stream
 
-#![deny(rust_2018_idioms)]
+#![deny(rust_2018_idioms, nonstandard_style)]
 #![warn(missing_docs)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
 mod bcodec;
 mod framed;

actix-connect/src/connect.rs

@@ -138,7 +138,7 @@ impl<T: Address> fmt::Display for Connect<T> {
     }
 }
 
-/// Iterator over addresses in a [`Connect`](struct.Connect.html) request.
+/// Iterator over addresses in a [`Connect`] request.
 #[derive(Clone)]
 pub struct ConnectAddrsIter<'a> {
     inner: Either<Option<SocketAddr>, vec_deque::Iter<'a, SocketAddr>>,
@@ -173,7 +173,7 @@ impl ExactSizeIterator for ConnectAddrsIter<'_> {}
 
 impl FusedIterator for ConnectAddrsIter<'_> {}
 
-/// Owned iterator over addresses in a [`Connect`](struct.Connect.html) request.
+/// Owned iterator over addresses in a [`Connect`] request.
 #[derive(Debug)]
 pub struct ConnectTakeAddrsIter {
     inner: Either<Option<SocketAddr>, vec_deque::IntoIter<SocketAddr>>,

actix-connect/src/connector.rs

@@ -40,8 +40,7 @@ impl<T> Clone for TcpConnectorFactory<T> {
     }
 }
 
-impl<T: Address> ServiceFactory for TcpConnectorFactory<T> {
+impl<T: Address> ServiceFactory<Connect<T>> for TcpConnectorFactory<T> {
-    type Request = Connect<T>;
     type Response = Connection<T, TcpStream>;
     type Error = ConnectError;
     type Config = ();
@@ -70,16 +69,13 @@ impl<T> Clone for TcpConnector<T> {
     }
 }
 
-impl<T: Address> Service for TcpConnector<T> {
+impl<T: Address> Service<Connect<T>> for TcpConnector<T> {
-    type Request = Connect<T>;
     type Response = Connection<T, TcpStream>;
     type Error = ConnectError;
     #[allow(clippy::type_complexity)]
     type Future = Either<TcpConnectorResponse<T>, Ready<Result<Self::Response, Self::Error>>>;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    actix_service::always_ready!();
-        Poll::Ready(Ok(()))
-    }
 
     fn call(&mut self, req: Connect<T>) -> Self::Future {
         let port = req.port();

actix-connect/src/lib.rs

@@ -5,8 +5,10 @@
 //! * `openssl` - enables TLS support via `openssl` crate
 //! * `rustls` - enables TLS support via `rustls` crate
 
-#![deny(rust_2018_idioms)]
+#![deny(rust_2018_idioms, nonstandard_style)]
 #![recursion_limit = "128"]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
 #[macro_use]
 extern crate log;
@@ -74,8 +76,8 @@ pub async fn start_default_resolver() -> Result<AsyncResolver, ConnectError> {
 /// Create TCP connector service.
 pub fn new_connector<T: Address + 'static>(
     resolver: AsyncResolver,
-) -> impl Service<Request = Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError>
+) -> impl Service<Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError> + Clone
-       + Clone {
+{
     pipeline(Resolver::new(resolver)).and_then(TcpConnector::new())
 }
 
@@ -83,8 +85,8 @@ pub fn new_connector<T: Address + 'static>(
 pub fn new_connector_factory<T: Address + 'static>(
     resolver: AsyncResolver,
 ) -> impl ServiceFactory<
+    Connect<T>,
     Config = (),
-    Request = Connect<T>,
     Response = Connection<T, TcpStream>,
     Error = ConnectError,
     InitError = (),
@@ -94,15 +96,15 @@ pub fn new_connector_factory<T: Address + 'static>(
 
 /// Create connector service with default parameters.
 pub fn default_connector<T: Address + 'static>(
-) -> impl Service<Request = Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError>
+) -> impl Service<Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError> + Clone
-       + Clone {
+{
     pipeline(Resolver::default()).and_then(TcpConnector::new())
 }
 
 /// Create connector service factory with default parameters.
 pub fn default_connector_factory<T: Address + 'static>() -> impl ServiceFactory<
+    Connect<T>,
     Config = (),
-    Request = Connect<T>,
     Response = Connection<T, TcpStream>,
     Error = ConnectError,
     InitError = (),

actix-connect/src/resolve.rs

@@ -54,8 +54,7 @@ impl<T> Clone for ResolverFactory<T> {
     }
 }
 
-impl<T: Address> ServiceFactory for ResolverFactory<T> {
+impl<T: Address> ServiceFactory<Connect<T>> for ResolverFactory<T> {
-    type Request = Connect<T>;
     type Response = Connect<T>;
     type Error = ConnectError;
     type Config = ();
@@ -102,8 +101,7 @@ impl<T> Clone for Resolver<T> {
     }
 }
 
-impl<T: Address> Service for Resolver<T> {
+impl<T: Address> Service<Connect<T>> for Resolver<T> {
-    type Request = Connect<T>;
     type Response = Connect<T>;
     type Error = ConnectError;
     #[allow(clippy::type_complexity)]
@@ -112,9 +110,7 @@ impl<T: Address> Service for Resolver<T> {
         Ready<Result<Connect<T>, Self::Error>>,
     >;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    actix_service::always_ready!();
-        Poll::Ready(Ok(()))
-    }
 
     fn call(&mut self, mut req: Connect<T>) -> Self::Future {
         if req.addr.is_some() {

actix-connect/src/service.rs

@@ -70,8 +70,7 @@ impl<T> Clone for ConnectServiceFactory<T> {
     }
 }
 
-impl<T: Address> ServiceFactory for ConnectServiceFactory<T> {
+impl<T: Address> ServiceFactory<Connect<T>> for ConnectServiceFactory<T> {
-    type Request = Connect<T>;
     type Response = Connection<T, TcpStream>;
     type Error = ConnectError;
     type Config = ();
@@ -90,15 +89,12 @@ pub struct ConnectService<T> {
     resolver: Resolver<T>,
 }
 
-impl<T: Address> Service for ConnectService<T> {
+impl<T: Address> Service<Connect<T>> for ConnectService<T> {
-    type Request = Connect<T>;
     type Response = Connection<T, TcpStream>;
     type Error = ConnectError;
     type Future = ConnectServiceResponse<T>;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    actix_service::always_ready!();
-        Poll::Ready(Ok(()))
-    }
 
     fn call(&mut self, req: Connect<T>) -> Self::Future {
         ConnectServiceResponse {
@@ -109,8 +105,8 @@ impl<T: Address> Service for ConnectService<T> {
 }
 
 enum ConnectState<T: Address> {
-    Resolve(<Resolver<T> as Service>::Future),
+    Resolve(<Resolver<T> as Service<Connect<T>>>::Future),
-    Connect(<TcpConnector<T> as Service>::Future),
+    Connect(<TcpConnector<T> as Service<Connect<T>>>::Future),
 }
 
 impl<T: Address> ConnectState<T> {
@@ -160,15 +156,12 @@ pub struct TcpConnectService<T> {
     resolver: Resolver<T>,
 }
 
-impl<T: Address + 'static> Service for TcpConnectService<T> {
+impl<T: Address + 'static> Service<Connect<T>> for TcpConnectService<T> {
-    type Request = Connect<T>;
     type Response = TcpStream;
     type Error = ConnectError;
     type Future = TcpConnectServiceResponse<T>;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    actix_service::always_ready!();
-        Poll::Ready(Ok(()))
-    }
 
     fn call(&mut self, req: Connect<T>) -> Self::Future {
         TcpConnectServiceResponse {
@@ -179,8 +172,8 @@ impl<T: Address + 'static> Service for TcpConnectService<T> {
 }
 
 enum TcpConnectState<T: Address> {
-    Resolve(<Resolver<T> as Service>::Future),
+    Resolve(<Resolver<T> as Service<Connect<T>>>::Future),
-    Connect(<TcpConnector<T> as Service>::Future),
+    Connect(<TcpConnector<T> as Service<Connect<T>>>::Future),
 }
 
 impl<T: Address> TcpConnectState<T> {

actix-connect/src/ssl/openssl.rs

@@ -100,9 +100,7 @@ where
     #[allow(clippy::type_complexity)]
     type Future = Either<ConnectAsyncExt<T, U>, Ready<Result<Self::Response, Self::Error>>>;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    actix_service::always_ready!();
-        Poll::Ready(Ok(()))
-    }
 
     fn call(&mut self, stream: Connection<T, U>) -> Self::Future {
         trace!("SSL Handshake start for: {:?}", stream.host());
@@ -220,9 +218,7 @@ impl<T: Address + 'static> Service for OpensslConnectService<T> {
     type Error = ConnectError;
     type Future = OpensslConnectServiceResponse<T>;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    actix_service::always_ready!();
-        Poll::Ready(Ok(()))
-    }
 
     fn call(&mut self, req: Connect<T>) -> Self::Future {
         OpensslConnectServiceResponse {

actix-connect/src/ssl/rustls.rs

@@ -96,9 +96,7 @@ where
     type Error = std::io::Error;
     type Future = ConnectAsyncExt<T, U>;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    actix_service::always_ready!();
-        Poll::Ready(Ok(()))
-    }
 
     fn call(&mut self, stream: Connection<T, U>) -> Self::Future {
         trace!("SSL Handshake start for: {:?}", stream.host());

actix-ioframe/README.md

@@ -1,3 +0,0 @@
-# actix-ioframe
-
-**This crate has been deprecated and removed.**

actix-macros/CHANGES.md

@@ -1,5 +1,9 @@
 # CHANGES
 
+## 0.1.3 - 2020-12-3
+
+* Add `actix-reexport` feature
+
 ## 0.1.2 - 2020-05-18
 
 ### Changed

actix-macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-macros"
-version = "0.1.2"
+version = "0.1.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix runtime macros"
 repository = "https://github.com/actix/actix-net"
@@ -16,6 +16,9 @@ proc-macro = true
 quote = "1.0.3"
 syn = { version = "^1", features = ["full"] }
 
+[features]
+actix-reexport = []
+
 [dev-dependencies]
 actix-rt = "1.0"
 

actix-macros/src/lib.rs

@@ -1,5 +1,8 @@
 //! Macros for use with Tokio
-extern crate proc_macro;
+
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
 use proc_macro::TokenStream;
 use quote::quote;
@@ -33,14 +36,25 @@ pub fn main(_: TokenStream, item: TokenStream) -> TokenStream {
 
     sig.asyncness = None;
 
-    (quote! {
+    if cfg!(feature = "actix-reexport") {
-        #(#attrs)*
+        (quote! {
-        #vis #sig {
+            #(#attrs)*
-            actix_rt::System::new(stringify!(#name))
+            #vis #sig {
-                .block_on(async move { #body })
+                actix::System::new(stringify!(#name))
-        }
+                    .block_on(async move { #body })
-    })
+            }
-    .into()
+        })
+        .into()
+    } else {
+        (quote! {
+            #(#attrs)*
+            #vis #sig {
+                actix_rt::System::new(stringify!(#name))
+                    .block_on(async move { #body })
+            }
+        })
+        .into()
+    }
 }
 
 /// Marks async test function to be executed by actix runtime.

actix-rt/CHANGES.md

@@ -2,10 +2,26 @@
 
 ## Unreleased - 2020-xx-xx
 
-### Added
 
+## 2.0.0-beta.1 - 2020-12-28
+### Added
 * Add `System::attach_to_tokio` method. [#173]
 
+### Changed
+* Update `tokio` dependency to `1.0`. [#236]
+* Rename `time` module `delay_for` to `sleep`, `delay_until` to `sleep_until`, `Delay` to `Sleep`
+  to stay aligned with Tokio's naming. [#236]
+* Remove `'static` lifetime requirement for `Runtime::block_on` and `SystemRunner::block_on`.
+  * These methods now accept `&self` when calling. [#236]
+* Remove `'static` lifetime requirement for `System::run` and `Builder::run`. [#236]
+* `Arbiter::spawn` now panics when `System` is not in scope. [#207]
+
+### Fixed
+* Fix work load issue by removing `PENDING` thread local. [#207]
+
+[#207]: https://github.com/actix/actix-net/pull/207
+[#236]: https://github.com/actix/actix-net/pull/236
+
 ## [1.1.1] - 2020-04-30
 
 ### Fixed

actix-rt/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "actix-rt"
-version = "1.1.1"
+version = "2.0.0-beta.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix runtime"
+description = "Tokio-based single-thread async runtime for the Actix ecosystem"
 keywords = ["network", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
@@ -17,12 +17,5 @@ path = "src/lib.rs"
 
 [dependencies]
 actix-macros = "0.1.0"
-actix-threadpool = "0.3"
-futures-channel = { version = "0.3.4", default-features = false }
-futures-util = { version = "0.3.4", default-features = false, features = ["alloc"] }
-copyless = "0.1.4"
-smallvec = "1"
-tokio = { version = "0.2.6", default-features = false, features = ["rt-core", "rt-util", "io-driver", "tcp", "uds", "udp", "time", "signal", "stream"] }
 
-[dev-dependencies]
+tokio = { version = "1", features = ["rt", "net", "signal", "sync", "time"] }
-tokio = { version = "0.2.6", features = ["full"] }

actix-rt/src/arbiter.rs

@@ -1,31 +1,30 @@
 use std::any::{Any, TypeId};
-use std::cell::{Cell, RefCell};
+use std::cell::RefCell;
 use std::collections::HashMap;
+use std::future::Future;
 use std::pin::Pin;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::task::{Context, Poll};
 use std::{fmt, thread};
 
-use futures_channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
+use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
-use futures_channel::oneshot::{channel, Canceled, Sender};
+use tokio::sync::oneshot::{channel, error::RecvError as Canceled, Sender};
-use futures_util::{
+// use futures_util::stream::FuturesUnordered;
-    future::{self, Future, FutureExt},
+// use tokio::task::JoinHandle;
-    stream::Stream,
+// use tokio::stream::StreamExt;
-};
+use tokio::task::LocalSet;
 
 use crate::runtime::Runtime;
 use crate::system::System;
 
-use copyless::BoxHelper;
-
-use smallvec::SmallVec;
-pub use tokio::task::JoinHandle;
-
 thread_local!(
     static ADDR: RefCell<Option<Arbiter>> = RefCell::new(None);
-    static RUNNING: Cell<bool> = Cell::new(false);
+    // TODO: Commented out code are for Arbiter::local_join function.
-    static Q: RefCell<Vec<Pin<Box<dyn Future<Output = ()>>>>> = RefCell::new(Vec::new());
+    // It can be safely removed if this function is not used in actix-*.
-    static PENDING: RefCell<SmallVec<[JoinHandle<()>; 8]>> = RefCell::new(SmallVec::new());
+    //
+    // /// stores join handle for spawned async tasks.
+    // static HANDLE: RefCell<FuturesUnordered<JoinHandle<()>>> =
+    //     RefCell::new(FuturesUnordered::new());
     static STORAGE: RefCell<HashMap<TypeId, Box<dyn Any>>> = RefCell::new(HashMap::new());
 );
 
@@ -69,14 +68,14 @@ impl Default for Arbiter {
 }
 
 impl Arbiter {
-    pub(crate) fn new_system() -> Self {
+    pub(crate) fn new_system(local: &LocalSet) -> Self {
-        let (tx, rx) = unbounded();
+        let (tx, rx) = unbounded_channel();
 
         let arb = Arbiter::with_sender(tx);
         ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
-        RUNNING.with(|cell| cell.set(false));
         STORAGE.with(|cell| cell.borrow_mut().clear());
-        Arbiter::spawn(ArbiterController { stop: None, rx });
+
+        local.spawn_local(ArbiterController { rx });
 
         arb
     }
@@ -91,13 +90,14 @@ impl Arbiter {
     }
 
     /// Check if current arbiter is running.
+    #[deprecated(note = "Thread local variables for running state of Arbiter is removed")]
     pub fn is_running() -> bool {
-        RUNNING.with(|cell| cell.get())
+        false
     }
 
     /// Stop arbiter from continuing it's event loop.
     pub fn stop(&self) {
-        let _ = self.sender.unbounded_send(ArbiterCommand::Stop);
+        let _ = self.sender.send(ArbiterCommand::Stop);
     }
 
     /// Spawn new thread and run event loop in spawned thread.
@@ -106,72 +106,47 @@ impl Arbiter {
         let id = COUNT.fetch_add(1, Ordering::Relaxed);
         let name = format!("actix-rt:worker:{}", id);
         let sys = System::current();
-        let (arb_tx, arb_rx) = unbounded();
+        let (tx, rx) = unbounded_channel();
-        let arb_tx2 = arb_tx.clone();
 
         let handle = thread::Builder::new()
             .name(name.clone())
-            .spawn(move || {
+            .spawn({
-                let mut rt = Runtime::new().expect("Can not create Runtime");
+                let tx = tx.clone();
-                let arb = Arbiter::with_sender(arb_tx);
+                move || {
+                    let rt = Runtime::new().expect("Can not create Runtime");
+                    let arb = Arbiter::with_sender(tx);
 
-                let (stop, stop_rx) = channel();
+                    STORAGE.with(|cell| cell.borrow_mut().clear());
-                RUNNING.with(|cell| cell.set(true));
-                STORAGE.with(|cell| cell.borrow_mut().clear());
 
-                System::set_current(sys);
+                    System::set_current(sys);
 
-                // start arbiter controller
+                    ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
-                rt.spawn(ArbiterController {
-                    stop: Some(stop),
-                    rx: arb_rx,
-                });
-                ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
 
-                // register arbiter
+                    // register arbiter
-                let _ = System::current()
+                    let _ = System::current()
-                    .sys()
+                        .sys()
-                    .unbounded_send(SystemCommand::RegisterArbiter(id, arb));
+                        .send(SystemCommand::RegisterArbiter(id, arb));
 
-                // run loop
+                    // start arbiter controller
-                let _ = match rt.block_on(stop_rx) {
+                    // run loop
-                    Ok(code) => code,
+                    rt.block_on(ArbiterController { rx });
-                    Err(_) => 1,
-                };
 
-                // unregister arbiter
+                    // unregister arbiter
-                let _ = System::current()
+                    let _ = System::current()
-                    .sys()
+                        .sys()
-                    .unbounded_send(SystemCommand::UnregisterArbiter(id));
+                        .send(SystemCommand::UnregisterArbiter(id));
+                }
             })
             .unwrap_or_else(|err| {
                 panic!("Cannot spawn an arbiter's thread {:?}: {:?}", &name, err)
             });
 
         Arbiter {
-            sender: arb_tx2,
+            sender: tx,
             thread_handle: Some(handle),
         }
     }
 
-    pub(crate) fn run_system(rt: Option<&Runtime>) {
-        RUNNING.with(|cell| cell.set(true));
-        Q.with(|cell| {
-            let mut v = cell.borrow_mut();
-            for fut in v.drain(..) {
-                if let Some(rt) = rt {
-                    rt.spawn(fut);
-                } else {
-                    tokio::task::spawn_local(fut);
-                }
-            }
-        });
-    }
-
-    pub(crate) fn stop_system() {
-        RUNNING.with(|cell| cell.set(false));
-    }
-
     /// Spawn a future on the current thread. This does not create a new Arbiter
     /// or Arbiter address, it is simply a helper for spawning futures on the current
     /// thread.
@@ -179,26 +154,12 @@ impl Arbiter {
     where
         F: Future<Output = ()> + 'static,
     {
-        RUNNING.with(move |cell| {
+        // HANDLE.with(|handle| {
-            if cell.get() {
+        //     let handle = handle.borrow();
-                // Spawn the future on running executor
+        //     handle.push(tokio::task::spawn_local(future));
-                let len = PENDING.with(move |cell| {
+        // });
-                    let mut p = cell.borrow_mut();
+        // let _ = tokio::task::spawn_local(CleanupPending);
-                    p.push(tokio::task::spawn_local(future));
+        let _ = tokio::task::spawn_local(future);
-                    p.len()
-                });
-                if len > 7 {
-                    // Before reaching the inline size
-                    tokio::task::spawn_local(CleanupPending);
-                }
-            } else {
-                // Box the future and push it to the queue, this results in double boxing
-                // because the executor boxes the future again, but works for now
-                Q.with(move |cell| {
-                    cell.borrow_mut().push(Pin::from(Box::alloc().init(future)))
-                });
-            }
-        });
     }
 
     /// Executes a future on the current thread. This does not create a new Arbiter
@@ -209,7 +170,9 @@ impl Arbiter {
         F: FnOnce() -> R + 'static,
         R: Future<Output = ()> + 'static,
     {
-        Arbiter::spawn(future::lazy(|_| f()).flatten())
+        Arbiter::spawn(async {
+            f();
+        })
     }
 
     /// Send a future to the Arbiter's thread, and spawn it.
@@ -217,9 +180,7 @@ impl Arbiter {
     where
         F: Future<Output = ()> + Send + Unpin + 'static,
     {
-        let _ = self
+        let _ = self.sender.send(ArbiterCommand::Execute(Box::new(future)));
-            .sender
-            .unbounded_send(ArbiterCommand::Execute(Box::new(future)));
     }
 
     /// Send a function to the Arbiter's thread, and execute it. Any result from the function
@@ -230,7 +191,7 @@ impl Arbiter {
     {
         let _ = self
             .sender
-            .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || {
+            .send(ArbiterCommand::ExecuteFn(Box::new(move || {
                 f();
             })));
     }
@@ -246,8 +207,8 @@ impl Arbiter {
         let (tx, rx) = channel();
         let _ = self
             .sender
-            .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || {
+            .send(ArbiterCommand::ExecuteFn(Box::new(move || {
-                if !tx.is_canceled() {
+                if !tx.is_closed() {
                     let _ = tx.send(f());
                 }
             })));
@@ -316,40 +277,33 @@ impl Arbiter {
 
     /// Returns a future that will be completed once all currently spawned futures
     /// have completed.
-    pub fn local_join() -> impl Future<Output = ()> {
+    #[deprecated(since = "1.2.0", note = "Arbiter::local_join function is removed.")]
-        PENDING.with(move |cell| {
+    pub async fn local_join() {
-            let current = cell.replace(SmallVec::new());
+        // let handle = HANDLE.with(|fut| std::mem::take(&mut *fut.borrow_mut()));
-            future::join_all(current).map(|_| ())
+        // async move {
-        })
+        //     handle.collect::<Vec<_>>().await;
+        // }
+        unimplemented!("Arbiter::local_join function is removed.")
     }
 }
 
-/// Future used for cleaning-up already finished `JoinHandle`s
+// /// Future used for cleaning-up already finished `JoinHandle`s
-/// from the `PENDING` list so the vector doesn't grow indefinitely
+// /// from the `PENDING` list so the vector doesn't grow indefinitely
-struct CleanupPending;
+// struct CleanupPending;
-
+//
-impl Future for CleanupPending {
+// impl Future for CleanupPending {
-    type Output = ();
+//     type Output = ();
-
+//
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+//     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        PENDING.with(move |cell| {
+//         HANDLE.with(move |handle| {
-            let mut pending = cell.borrow_mut();
+//             recycle_join_handle(&mut *handle.borrow_mut(), cx);
-            let mut i = 0;
+//         });
-            while i != pending.len() {
+//
-                if let Poll::Ready(_) = Pin::new(&mut pending[i]).poll(cx) {
+//         Poll::Ready(())
-                    pending.remove(i);
+//     }
-                } else {
+// }
-                    i += 1;
-                }
-            }
-        });
-
-        Poll::Ready(())
-    }
-}
 
 struct ArbiterController {
-    stop: Option<Sender<i32>>,
     rx: UnboundedReceiver<ArbiterCommand>,
 }
 
@@ -371,25 +325,17 @@ impl Future for ArbiterController {
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
-            match Pin::new(&mut self.rx).poll_next(cx) {
+            match Pin::new(&mut self.rx).poll_recv(cx) {
                 Poll::Ready(None) => return Poll::Ready(()),
                 Poll::Ready(Some(item)) => match item {
-                    ArbiterCommand::Stop => {
+                    ArbiterCommand::Stop => return Poll::Ready(()),
-                        if let Some(stop) = self.stop.take() {
-                            let _ = stop.send(0);
-                        };
-                        return Poll::Ready(());
-                    }
                     ArbiterCommand::Execute(fut) => {
-                        let len = PENDING.with(move |cell| {
+                        // HANDLE.with(|handle| {
-                            let mut p = cell.borrow_mut();
+                        //     let mut handle = handle.borrow_mut();
-                            p.push(tokio::task::spawn_local(fut));
+                        //     handle.push(tokio::task::spawn_local(fut));
-                            p.len()
+                        //     recycle_join_handle(&mut *handle, cx);
-                        });
+                        // });
-                        if len > 7 {
+                        tokio::task::spawn_local(fut);
-                            // Before reaching the inline size
-                            tokio::task::spawn_local(CleanupPending);
-                        }
                     }
                     ArbiterCommand::ExecuteFn(f) => {
                         f.call_box();
@@ -401,6 +347,20 @@ impl Future for ArbiterController {
     }
 }
 
+// fn recycle_join_handle(handle: &mut FuturesUnordered<JoinHandle<()>>, cx: &mut Context<'_>) {
+//     let _ = Pin::new(&mut *handle).poll_next(cx);
+//
+//     // Try to recycle more join handles and free up memory.
+//     //
+//     // this is a guess. The yield limit for FuturesUnordered is 32.
+//     // So poll an extra 3 times would make the total poll below 128.
+//     if handle.len() > 64 {
+//         (0..3).for_each(|_| {
+//             let _ = Pin::new(&mut *handle).poll_next(cx);
+//         })
+//     }
+// }
+
 #[derive(Debug)]
 pub(crate) enum SystemCommand {
     Exit(i32),
@@ -430,7 +390,7 @@ impl Future for SystemArbiter {
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         loop {
-            match Pin::new(&mut self.commands).poll_next(cx) {
+            match Pin::new(&mut self.commands).poll_recv(cx) {
                 Poll::Ready(None) => return Poll::Ready(()),
                 Poll::Ready(Some(cmd)) => match cmd {
                     SystemCommand::Exit(code) => {

actix-rt/src/builder.rs

@@ -1,9 +1,9 @@
 use std::borrow::Cow;
+use std::future::Future;
 use std::io;
 
-use futures_channel::mpsc::unbounded;
+use tokio::sync::mpsc::unbounded_channel;
-use futures_channel::oneshot::{channel, Receiver};
+use tokio::sync::oneshot::{channel, Receiver};
-use futures_util::future::{lazy, Future, FutureExt};
 use tokio::task::LocalSet;
 
 use crate::arbiter::{Arbiter, SystemArbiter};
@@ -65,16 +65,17 @@ impl Builder {
     /// Function `f` get called within tokio runtime context.
     pub fn run<F>(self, f: F) -> io::Result<()>
     where
-        F: FnOnce() + 'static,
+        F: FnOnce(),
     {
         self.create_runtime(f).run()
     }
 
     fn create_async_runtime(self, local: &LocalSet) -> AsyncSystemRunner {
         let (stop_tx, stop) = channel();
-        let (sys_sender, sys_receiver) = unbounded();
+        let (sys_sender, sys_receiver) = unbounded_channel();
 
-        let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic);
+        let system =
+            System::construct(sys_sender, Arbiter::new_system(local), self.stop_on_panic);
 
         // system arbiter
         let arb = SystemArbiter::new(stop_tx, sys_receiver);
@@ -87,21 +88,26 @@ impl Builder {
 
     fn create_runtime<F>(self, f: F) -> SystemRunner
     where
-        F: FnOnce() + 'static,
+        F: FnOnce(),
     {
         let (stop_tx, stop) = channel();
-        let (sys_sender, sys_receiver) = unbounded();
+        let (sys_sender, sys_receiver) = unbounded_channel();
 
-        let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic);
+        let rt = Runtime::new().unwrap();
+
+        let system = System::construct(
+            sys_sender,
+            Arbiter::new_system(rt.local()),
+            self.stop_on_panic,
+        );
 
         // system arbiter
         let arb = SystemArbiter::new(stop_tx, sys_receiver);
 
-        let mut rt = Runtime::new().unwrap();
         rt.spawn(arb);
 
         // init system arbiter and run configuration method
-        rt.block_on(lazy(move |_| f()));
+        rt.block_on(async { f() });
 
         SystemRunner { rt, stop, system }
     }
@@ -120,27 +126,21 @@ impl AsyncSystemRunner {
         let AsyncSystemRunner { stop, .. } = self;
 
         // run loop
-        lazy(|_| {
+        async {
-            Arbiter::run_system(None);
+            match stop.await {
-            async {
+                Ok(code) => {
-                let res = match stop.await {
+                    if code != 0 {
-                    Ok(code) => {
+                        Err(io::Error::new(
-                        if code != 0 {
+                            io::ErrorKind::Other,
-                            Err(io::Error::new(
+                            format!("Non-zero exit code: {}", code),
-                                io::ErrorKind::Other,
+                        ))
-                                format!("Non-zero exit code: {}", code),
+                    } else {
-                            ))
+                        Ok(())
-                        } else {
-                            Ok(())
-                        }
                     }
-                    Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
+                }
-                };
+                Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
-                Arbiter::stop_system();
-                res
             }
-        })
+        }
-        .flatten()
     }
 }
 
@@ -157,11 +157,10 @@ impl SystemRunner {
     /// This function will start event loop and will finish once the
     /// `System::stop()` function is called.
     pub fn run(self) -> io::Result<()> {
-        let SystemRunner { mut rt, stop, .. } = self;
+        let SystemRunner { rt, stop, .. } = self;
 
         // run loop
-        Arbiter::run_system(Some(&rt));
+        match rt.block_on(stop) {
-        let result = match rt.block_on(stop) {
             Ok(code) => {
                 if code != 0 {
                     Err(io::Error::new(
@@ -173,19 +172,12 @@ impl SystemRunner {
                 }
             }
             Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
-        };
+        }
-        Arbiter::stop_system();
-        result
     }
 
     /// Execute a future and wait for result.
-    pub fn block_on<F, O>(&mut self, fut: F) -> O
+    #[inline]
-    where
+    pub fn block_on<F: Future>(&self, fut: F) -> F::Output {
-        F: Future<Output = O> + 'static,
+        self.rt.block_on(fut)
-    {
-        Arbiter::run_system(Some(&self.rt));
-        let res = self.rt.block_on(fut);
-        Arbiter::stop_system();
-        res
     }
 }

actix-rt/src/lib.rs

@@ -1,6 +1,11 @@
-//! A runtime implementation that runs everything on the current thread.
+//! Tokio-based single-thread async runtime for the Actix ecosystem.
-#![deny(rust_2018_idioms, warnings)]
+
+#![deny(rust_2018_idioms, nonstandard_style)]
 #![allow(clippy::type_complexity)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
+
+use std::future::Future;
 
 #[cfg(not(test))] // Work around for rust-lang/rust#62127
 pub use actix_macros::{main, test};
@@ -15,23 +20,17 @@ pub use self::builder::{Builder, SystemRunner};
 pub use self::runtime::Runtime;
 pub use self::system::System;
 
-#[doc(hidden)]
-pub use actix_threadpool as blocking;
-
 /// Spawns a future on the current arbiter.
 ///
 /// # Panics
 ///
 /// This function panics if actix system is not running.
+#[inline]
 pub fn spawn<F>(f: F)
 where
-    F: futures_util::future::Future<Output = ()> + 'static,
+    F: Future<Output = ()> + 'static,
 {
-    if !System::is_set() {
+    Arbiter::spawn(f)
-        panic!("System is not running");
-    }
-
-    Arbiter::spawn(f);
 }
 
 /// Asynchronous signal handling
@@ -60,7 +59,7 @@ pub mod net {
 /// Utilities for tracking time.
 pub mod time {
     pub use tokio::time::Instant;
-    pub use tokio::time::{delay_for, delay_until, Delay};
     pub use tokio::time::{interval, interval_at, Interval};
+    pub use tokio::time::{sleep, sleep_until, Sleep};
     pub use tokio::time::{timeout, Timeout};
 }

actix-rt/src/runtime.rs

@@ -7,7 +7,7 @@ use tokio::{runtime, task::LocalSet};
 ///
 /// See [module level][mod] documentation for more details.
 ///
-/// [mod]: index.html
+/// [mod]: crate
 #[derive(Debug)]
 pub struct Runtime {
     local: LocalSet,
@@ -18,10 +18,9 @@ impl Runtime {
     #[allow(clippy::new_ret_no_self)]
     /// Returns a new runtime initialized with default configuration values.
     pub fn new() -> io::Result<Runtime> {
-        let rt = runtime::Builder::new()
+        let rt = runtime::Builder::new_current_thread()
             .enable_io()
             .enable_time()
-            .basic_scheduler()
             .build()?;
 
         Ok(Runtime {
@@ -30,11 +29,15 @@ impl Runtime {
         })
     }
 
+    pub(super) fn local(&self) -> &LocalSet {
+        &self.local
+    }
+
     /// Spawn a future onto the single-threaded runtime.
     ///
     /// See [module level][mod] documentation for more details.
     ///
-    /// [mod]: index.html
+    /// [mod]: crate
     ///
     /// # Examples
     ///
@@ -44,7 +47,7 @@ impl Runtime {
     ///
     /// # fn dox() {
     /// // Create the runtime
-    /// let mut rt = Runtime::new().unwrap();
+    /// let rt = Runtime::new().unwrap();
     ///
     /// // Spawn a future onto the runtime
     /// rt.spawn(future::lazy(|_| {
@@ -82,10 +85,10 @@ impl Runtime {
     ///
     /// The caller is responsible for ensuring that other spawned futures
     /// complete execution by calling `block_on` or `run`.
-    pub fn block_on<F>(&mut self, f: F) -> F::Output
+    pub fn block_on<F>(&self, f: F) -> F::Output
     where
-        F: Future + 'static,
+        F: Future,
     {
-        self.local.block_on(&mut self.rt, f)
+        self.local.block_on(&self.rt, f)
     }
 }

actix-rt/src/system.rs

@@ -3,7 +3,7 @@ use std::future::Future;
 use std::io;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
-use futures_channel::mpsc::UnboundedSender;
+use tokio::sync::mpsc::UnboundedSender;
 use tokio::task::LocalSet;
 
 use crate::arbiter::{Arbiter, SystemCommand};
@@ -66,12 +66,11 @@ impl System {
     /// It means that using this method currently it is impossible to make `actix-rt` work in the
     /// alternative `tokio` `Runtime`s (e.g. provided by [`tokio_compat`]).
     ///
-    /// [`Arbiter`]: struct.Arbiter.html
     /// [`tokio_compat`]: https://crates.io/crates/tokio-compat
     ///
     /// # Examples
     ///
-    /// ```
+    /// ```rust,ignore
     /// use tokio::{runtime::Runtime, task::LocalSet};
     /// use actix_rt::System;
     /// use futures_util::future::try_join_all;
@@ -95,10 +94,9 @@ impl System {
     /// }
     ///
     ///
-    /// let mut runtime = tokio::runtime::Builder::new()
+    /// let runtime = tokio::runtime::Builder::new_multi_thread()
-    ///     .core_threads(2)
+    ///     .worker_threads(2)
     ///     .enable_all()
-    ///     .threaded_scheduler()
     ///     .build()
     ///     .unwrap();
     ///
@@ -131,7 +129,6 @@ impl System {
     /// It means that using this method currently it is impossible to make `actix-rt` work in the
     /// alternative `tokio` `Runtime`s (e.g. provided by `tokio_compat`).
     ///
-    /// [`Arbiter`]: struct.Arbiter.html
     /// [`tokio_compat`]: https://crates.io/crates/tokio-compat
     ///
     /// # Arguments
@@ -142,7 +139,7 @@ impl System {
     ///
     /// # Examples
     ///
-    /// ```
+    /// ```rust,ignore
     /// use tokio::runtime::Runtime;
     /// use actix_rt::System;
     /// use futures_util::future::try_join_all;
@@ -166,10 +163,9 @@ impl System {
     /// }
     ///
     ///
-    /// let runtime = tokio::runtime::Builder::new()
+    /// let runtime = tokio::runtime::Builder::new_multi_thread()
-    ///     .core_threads(2)
+    ///     .worker_threads(2)
     ///     .enable_all()
-    ///     .threaded_scheduler()
     ///     .build()
     ///     .unwrap();
     ///
@@ -178,7 +174,7 @@ impl System {
     /// ```
     pub fn attach_to_tokio<Fut, R>(
         name: impl Into<String>,
-        mut runtime: tokio::runtime::Runtime,
+        runtime: tokio::runtime::Runtime,
         rest_operations: Fut,
     ) -> R
     where
@@ -235,7 +231,7 @@ impl System {
 
     /// Stop the system with a particular exit code.
     pub fn stop_with_code(&self, code: i32) {
-        let _ = self.sys.unbounded_send(SystemCommand::Exit(code));
+        let _ = self.sys.send(SystemCommand::Exit(code));
     }
 
     pub(crate) fn sys(&self) -> &UnboundedSender<SystemCommand> {
@@ -258,7 +254,7 @@ impl System {
     /// Function `f` get called within tokio runtime context.
     pub fn run<F>(f: F) -> io::Result<()>
     where
-        F: FnOnce() + 'static,
+        F: FnOnce(),
     {
         Self::builder().run(f)
     }

actix-rt/tests/integration_tests.rs

@@ -1,25 +1,11 @@
 use std::time::{Duration, Instant};
 
-#[test]
-fn start_and_stop() {
-    actix_rt::System::new("start_and_stop").block_on(async move {
-        assert!(
-            actix_rt::Arbiter::is_running(),
-            "System doesn't seem to have started"
-        );
-    });
-    assert!(
-        !actix_rt::Arbiter::is_running(),
-        "System doesn't seem to have stopped"
-    );
-}
-
 #[test]
 fn await_for_timer() {
     let time = Duration::from_secs(2);
     let instant = Instant::now();
     actix_rt::System::new("test_wait_timer").block_on(async move {
-        tokio::time::delay_for(time).await;
+        tokio::time::sleep(time).await;
     });
     assert!(
         instant.elapsed() >= time,
@@ -34,7 +20,7 @@ fn join_another_arbiter() {
     actix_rt::System::new("test_join_another_arbiter").block_on(async move {
         let mut arbiter = actix_rt::Arbiter::new();
         arbiter.send(Box::pin(async move {
-            tokio::time::delay_for(time).await;
+            tokio::time::sleep(time).await;
             actix_rt::Arbiter::current().stop();
         }));
         arbiter.join().unwrap();
@@ -49,7 +35,7 @@ fn join_another_arbiter() {
         let mut arbiter = actix_rt::Arbiter::new();
         arbiter.exec_fn(move || {
             actix_rt::spawn(async move {
-                tokio::time::delay_for(time).await;
+                tokio::time::sleep(time).await;
                 actix_rt::Arbiter::current().stop();
             });
         });
@@ -64,7 +50,7 @@ fn join_another_arbiter() {
     actix_rt::System::new("test_join_another_arbiter").block_on(async move {
         let mut arbiter = actix_rt::Arbiter::new();
         arbiter.send(Box::pin(async move {
-            tokio::time::delay_for(time).await;
+            tokio::time::sleep(time).await;
             actix_rt::Arbiter::current().stop();
         }));
         arbiter.stop();
@@ -76,39 +62,65 @@ fn join_another_arbiter() {
     );
 }
 
+// #[test]
+// fn join_current_arbiter() {
+//     let time = Duration::from_secs(2);
+//
+//     let instant = Instant::now();
+//     actix_rt::System::new("test_join_current_arbiter").block_on(async move {
+//         actix_rt::spawn(async move {
+//             tokio::time::delay_for(time).await;
+//             actix_rt::Arbiter::current().stop();
+//         });
+//         actix_rt::Arbiter::local_join().await;
+//     });
+//     assert!(
+//         instant.elapsed() >= time,
+//         "Join on current arbiter should wait for all spawned futures"
+//     );
+//
+//     let large_timer = Duration::from_secs(20);
+//     let instant = Instant::now();
+//     actix_rt::System::new("test_join_current_arbiter").block_on(async move {
+//         actix_rt::spawn(async move {
+//             tokio::time::delay_for(time).await;
+//             actix_rt::Arbiter::current().stop();
+//         });
+//         let f = actix_rt::Arbiter::local_join();
+//         actix_rt::spawn(async move {
+//             tokio::time::delay_for(large_timer).await;
+//             actix_rt::Arbiter::current().stop();
+//         });
+//         f.await;
+//     });
+//     assert!(
+//         instant.elapsed() < large_timer,
+//         "local_join should await only for the already spawned futures"
+//     );
+// }
+
 #[test]
-fn join_current_arbiter() {
+fn non_static_block_on() {
-    let time = Duration::from_secs(2);
+    let string = String::from("test_str");
+    let str = string.as_str();
 
-    let instant = Instant::now();
+    let sys = actix_rt::System::new("borrow some");
-    actix_rt::System::new("test_join_current_arbiter").block_on(async move {
-        actix_rt::spawn(async move {
-            tokio::time::delay_for(time).await;
-            actix_rt::Arbiter::current().stop();
-        });
-        actix_rt::Arbiter::local_join().await;
-    });
-    assert!(
-        instant.elapsed() >= time,
-        "Join on current arbiter should wait for all spawned futures"
-    );
 
-    let large_timer = Duration::from_secs(20);
+    sys.block_on(async {
-    let instant = Instant::now();
+        actix_rt::time::sleep(Duration::from_millis(1)).await;
-    actix_rt::System::new("test_join_current_arbiter").block_on(async move {
+        assert_eq!("test_str", str);
-        actix_rt::spawn(async move {
-            tokio::time::delay_for(time).await;
-            actix_rt::Arbiter::current().stop();
-        });
-        let f = actix_rt::Arbiter::local_join();
-        actix_rt::spawn(async move {
-            tokio::time::delay_for(large_timer).await;
-            actix_rt::Arbiter::current().stop();
-        });
-        f.await;
     });
-    assert!(
+
-        instant.elapsed() < large_timer,
+    let rt = actix_rt::Runtime::new().unwrap();
-        "local_join should await only for the already spawned futures"
+
-    );
+    rt.block_on(async {
+        actix_rt::time::sleep(Duration::from_millis(1)).await;
+        assert_eq!("test_str", str);
+    });
+
+    actix_rt::System::run(|| {
+        assert_eq!("test_str", str);
+        actix_rt::System::current().stop();
+    })
+    .unwrap();
 }

actix-server/CHANGES.md

@@ -1,6 +1,11 @@
 # Changes
 
 ## Unreleased - 2020-xx-xx
+* Added explicit info log message on accept queue pause. [#215]
+* Prevent double registration of sockets when back-pressure is resolved. [#223]
+
+[#215]: https://github.com/actix/actix-net/pull/215
+[#223]: https://github.com/actix/actix-net/pull/223
 
 
 ## 1.0.4 - 2020-09-12

actix-server/Cargo.toml

@@ -41,3 +41,4 @@ mio-uds = { version = "0.6.7" }
 bytes = "0.5"
 env_logger = "0.7"
 actix-testing = "1.0.0"
+tokio = { version = "0.2", features = ["io-util"] }

actix-server/examples/basic.rs

@@ -0,0 +1,88 @@
+//! Simple composite-service TCP echo server.
+//!
+//! Using the following command:
+//!
+//! ```sh
+//! nc 127.0.0.1 8080
+//! ```
+//!
+//! Start typing. When you press enter the typed line will be echoed back. The server will log
+//! the length of each line it echos and the total size of data sent when the connection is closed.
+
+use std::sync::{
+    atomic::{AtomicUsize, Ordering},
+    Arc,
+};
+use std::{env, io};
+
+use actix_rt::net::TcpStream;
+use actix_server::Server;
+use actix_service::pipeline_factory;
+use bytes::BytesMut;
+use futures_util::future::ok;
+use log::{error, info};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+#[actix_rt::main]
+async fn main() -> io::Result<()> {
+    env::set_var("RUST_LOG", "actix=trace,basic=trace");
+    env_logger::init();
+
+    let count = Arc::new(AtomicUsize::new(0));
+
+    let addr = ("127.0.0.1", 8080);
+    info!("starting server on port: {}", &addr.0);
+
+    // Bind socket address and start worker(s). By default, the server uses the number of available
+    // logical CPU cores as the worker count. For this reason, the closure passed to bind needs
+    // to return a service *factory*; so it can be created once per worker.
+    Server::build()
+        .bind("echo", addr, move || {
+            let count = Arc::clone(&count);
+            let num2 = Arc::clone(&count);
+
+            pipeline_factory(move |mut stream: TcpStream| {
+                let count = Arc::clone(&count);
+
+                async move {
+                    let num = count.fetch_add(1, Ordering::SeqCst);
+                    let num = num + 1;
+
+                    let mut size = 0;
+                    let mut buf = BytesMut::new();
+
+                    loop {
+                        match stream.read_buf(&mut buf).await {
+                            // end of stream; bail from loop
+                            Ok(0) => break,
+
+                            // more bytes to process
+                            Ok(bytes_read) => {
+                                info!("[{}] read {} bytes", num, bytes_read);
+                                stream.write_all(&buf[size..]).await.unwrap();
+                                size += bytes_read;
+                            }
+
+                            // stream error; bail from loop with error
+                            Err(err) => {
+                                error!("Stream Error: {:?}", err);
+                                return Err(());
+                            }
+                        }
+                    }
+
+                    // send data down service pipeline
+                    Ok((buf.freeze(), size))
+                }
+            })
+            .map_err(|err| error!("Service Error: {:?}", err))
+            .and_then(move |(_, size)| {
+                let num = num2.load(Ordering::SeqCst);
+                info!("[{}] total bytes read: {}", num, size);
+                ok(size)
+            })
+        })?
+        .workers(1)
+        .run()
+        .await
+}

actix-server/src/accept.rs

@@ -370,6 +370,11 @@ impl Accept {
             if !on {
                 self.backpressure = false;
                 for (token, info) in self.sockets.iter() {
+                    if info.timeout.is_some() {
+                        // socket will attempt to re-register itself when its timeout completes
+                        continue;
+                    }
+
                     if let Err(err) = self.register(token, info) {
                         error!("Can not resume socket accept process: {}", err);
                     } else {
@@ -381,6 +386,7 @@ impl Accept {
             self.backpressure = true;
             for (_, info) in self.sockets.iter() {
                 let _ = self.poll.deregister(&info.sock);
+                info!("Accepting connections on {} has been paused", info.addr);
             }
         }
     }

actix-server/src/builder.rs

@@ -286,7 +286,7 @@ impl ServerBuilder {
 
             // handle signals
             if !self.no_signals {
-                Signals::start(self.server.clone()).unwrap();
+                Signals::start(self.server.clone());
             }
 
             // start http server actor

actix-server/src/config.rs

@@ -2,16 +2,18 @@ use std::collections::HashMap;
 use std::{fmt, io, net};
 
 use actix_rt::net::TcpStream;
-use actix_service as actix;
+use actix_service::{
+    fn_service, IntoServiceFactory as IntoBaseServiceFactory,
+    ServiceFactory as BaseServiceFactory,
+};
 use actix_utils::counter::CounterGuard;
 use futures_util::future::{ok, Future, FutureExt, LocalBoxFuture};
 use log::error;
 
 use super::builder::bind_addr;
-use super::service::{
+use super::service::{BoxedServerService, InternalServiceFactory, StreamService};
-    BoxedServerService, InternalServiceFactory, ServerMessage, StreamService,
-};
 use super::Token;
+use crate::socket::StdStream;
 
 pub struct ServiceConfig {
     pub(crate) services: Vec<(String, net::TcpListener)>,
@@ -142,12 +144,10 @@ impl InternalServiceFactory for ConfiguredService {
                     let name = names.remove(&token).unwrap().0;
                     res.push((
                         token,
-                        Box::new(StreamService::new(actix::fn_service(
+                        Box::new(StreamService::new(fn_service(move |_: TcpStream| {
-                            move |_: TcpStream| {
+                            error!("Service {:?} is not configured", name);
-                                error!("Service {:?} is not configured", name);
+                            ok::<_, ()>(())
-                                ok::<_, ()>(())
+                        }))),
-                            },
-                        ))),
                     ));
                 };
             }
@@ -209,8 +209,8 @@ impl ServiceRuntime {
     /// *ServiceConfig::bind()* or *ServiceConfig::listen()* methods.
     pub fn service<T, F>(&mut self, name: &str, service: F)
     where
-        F: actix::IntoServiceFactory<T>,
+        F: IntoBaseServiceFactory<T, TcpStream>,
-        T: actix::ServiceFactory<Config = (), Request = TcpStream> + 'static,
+        T: BaseServiceFactory<TcpStream, Config = ()> + 'static,
         T::Future: 'static,
         T::Service: 'static,
         T::InitError: fmt::Debug,
@@ -238,8 +238,8 @@ impl ServiceRuntime {
 }
 
 type BoxedNewService = Box<
-    dyn actix::ServiceFactory<
+    dyn BaseServiceFactory<
-        Request = (Option<CounterGuard>, ServerMessage),
+        (Option<CounterGuard>, StdStream),
         Response = (),
         Error = (),
         InitError = (),
@@ -253,20 +253,19 @@ struct ServiceFactory<T> {
     inner: T,
 }
 
-impl<T> actix::ServiceFactory for ServiceFactory<T>
+impl<T> BaseServiceFactory<(Option<CounterGuard>, StdStream)> for ServiceFactory<T>
 where
-    T: actix::ServiceFactory<Config = (), Request = TcpStream>,
+    T: BaseServiceFactory<TcpStream, Config = ()>,
     T::Future: 'static,
     T::Service: 'static,
     T::Error: 'static,
     T::InitError: fmt::Debug + 'static,
 {
-    type Request = (Option<CounterGuard>, ServerMessage);
     type Response = ();
     type Error = ();
-    type InitError = ();
     type Config = ();
     type Service = BoxedServerService;
+    type InitError = ();
     type Future = LocalBoxFuture<'static, Result<BoxedServerService, ()>>;
 
     fn new_service(&self, _: ()) -> Self::Future {

actix-server/src/lib.rs

@@ -1,6 +1,8 @@
-//! General purpose tcp server
+//! General purpose TCP server.
-#![deny(rust_2018_idioms, warnings)]
+
-#![allow(clippy::type_complexity)]
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
 mod accept;
 mod builder;
@@ -19,7 +21,7 @@ pub use self::service::ServiceFactory;
 #[doc(hidden)]
 pub use self::socket::FromStream;
 
-/// Socket id token
+/// Socket ID token
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub(crate) struct Token(usize);
 

actix-server/src/service.rs

@@ -1,10 +1,9 @@
 use std::marker::PhantomData;
 use std::net::SocketAddr;
 use std::task::{Context, Poll};
-use std::time::Duration;
 
 use actix_rt::spawn;
-use actix_service::{self as actix, Service, ServiceFactory as ActixServiceFactory};
+use actix_service::{Service, ServiceFactory as BaseServiceFactory};
 use actix_utils::counter::CounterGuard;
 use futures_util::future::{err, ok, LocalBoxFuture, Ready};
 use futures_util::{FutureExt, TryFutureExt};
@@ -13,18 +12,8 @@ use log::error;
 use super::Token;
 use crate::socket::{FromStream, StdStream};
 
-/// Server message
-pub(crate) enum ServerMessage {
-    /// New stream
-    Connect(StdStream),
-    /// Gracefull shutdown
-    Shutdown(Duration),
-    /// Force shutdown
-    ForceShutdown,
-}
-
 pub trait ServiceFactory<Stream: FromStream>: Send + Clone + 'static {
-    type Factory: actix::ServiceFactory<Config = (), Request = Stream>;
+    type Factory: BaseServiceFactory<Stream, Config = ()>;
 
     fn create(&self) -> Self::Factory;
 }
@@ -39,31 +28,34 @@ pub(crate) trait InternalServiceFactory: Send {
 
 pub(crate) type BoxedServerService = Box<
     dyn Service<
-        Request = (Option<CounterGuard>, ServerMessage),
+        (Option<CounterGuard>, StdStream),
         Response = (),
         Error = (),
         Future = Ready<Result<(), ()>>,
     >,
 >;
 
-pub(crate) struct StreamService<T> {
+pub(crate) struct StreamService<S, I> {
-    service: T,
+    service: S,
+    _phantom: PhantomData<I>,
 }
 
-impl<T> StreamService<T> {
+impl<S, I> StreamService<S, I> {
-    pub(crate) fn new(service: T) -> Self {
+    pub(crate) fn new(service: S) -> Self {
-        StreamService { service }
+        StreamService {
+            service,
+            _phantom: PhantomData,
+        }
     }
 }
 
-impl<T, I> Service for StreamService<T>
+impl<S, I> Service<(Option<CounterGuard>, StdStream)> for StreamService<S, I>
 where
-    T: Service<Request = I>,
+    S: Service<I>,
-    T::Future: 'static,
+    S::Future: 'static,
-    T::Error: 'static,
+    S::Error: 'static,
     I: FromStream,
 {
-    type Request = (Option<CounterGuard>, ServerMessage);
     type Response = ();
     type Error = ();
     type Future = Ready<Result<(), ()>>;
@@ -72,25 +64,20 @@ where
         self.service.poll_ready(ctx).map_err(|_| ())
     }
 
-    fn call(&mut self, (guard, req): (Option<CounterGuard>, ServerMessage)) -> Self::Future {
+    fn call(&mut self, (guard, req): (Option<CounterGuard>, StdStream)) -> Self::Future {
-        match req {
+        match FromStream::from_stdstream(req) {
-            ServerMessage::Connect(stream) => {
+            Ok(stream) => {
-                let stream = FromStream::from_stdstream(stream).map_err(|e| {
+                let f = self.service.call(stream);
-                    error!("Can not convert to an async tcp stream: {}", e);
+                spawn(async move {
+                    let _ = f.await;
+                    drop(guard);
                 });
-
+                ok(())
-                if let Ok(stream) = stream {
+            }
-                    let f = self.service.call(stream);
+            Err(e) => {
-                    spawn(async move {
+                error!("Can not convert to an async tcp stream: {}", e);
-                        let _ = f.await;
+                err(())
-                        drop(guard);
-                    });
-                    ok(())
-                } else {
-                    err(())
-                }
             }
-            _ => ok(()),
         }
     }
 }
@@ -157,24 +144,10 @@ where
     }
 }
 
-impl InternalServiceFactory for Box<dyn InternalServiceFactory> {
-    fn name(&self, token: Token) -> &str {
-        self.as_ref().name(token)
-    }
-
-    fn clone_factory(&self) -> Box<dyn InternalServiceFactory> {
-        self.as_ref().clone_factory()
-    }
-
-    fn create(&self) -> LocalBoxFuture<'static, Result<Vec<(Token, BoxedServerService)>, ()>> {
-        self.as_ref().create()
-    }
-}
-
 impl<F, T, I> ServiceFactory<I> for F
 where
     F: Fn() -> T + Send + Clone + 'static,
-    T: actix::ServiceFactory<Config = (), Request = I>,
+    T: BaseServiceFactory<I, Config = ()>,
     I: FromStream,
 {
     type Factory = T;

actix-server/src/signals.rs

@@ -1,5 +1,4 @@
 use std::future::Future;
-use std::io;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
@@ -24,13 +23,13 @@ pub(crate) enum Signal {
 pub(crate) struct Signals {
     srv: Server,
     #[cfg(not(unix))]
-    stream: Pin<Box<dyn Future<Output = io::Result<()>>>>,
+    stream: Pin<Box<dyn Future<Output = std::io::Result<()>>>>,
     #[cfg(unix)]
     streams: Vec<(Signal, actix_rt::signal::unix::Signal)>,
 }
 
 impl Signals {
-    pub(crate) fn start(srv: Server) -> io::Result<()> {
+    pub(crate) fn start(srv: Server) {
         actix_rt::spawn(lazy(|_| {
             #[cfg(not(unix))]
             {
@@ -66,8 +65,6 @@ impl Signals {
                 actix_rt::spawn(Signals { srv, streams })
             }
         }));
-
-        Ok(())
     }
 }
 

actix-server/src/worker.rs

@@ -14,7 +14,7 @@ use futures_util::{future::Future, stream::Stream, FutureExt, TryFutureExt};
 use log::{error, info, trace};
 
 use crate::accept::AcceptNotify;
-use crate::service::{BoxedServerService, InternalServiceFactory, ServerMessage};
+use crate::service::{BoxedServerService, InternalServiceFactory};
 use crate::socket::{SocketAddr, StdStream};
 use crate::Token;
 
@@ -228,23 +228,12 @@ impl Worker {
             self.services.iter_mut().for_each(|srv| {
                 if srv.status == WorkerServiceStatus::Available {
                     srv.status = WorkerServiceStatus::Stopped;
-                    actix_rt::spawn(
-                        srv.service
-                            .call((None, ServerMessage::ForceShutdown))
-                            .map(|_| ()),
-                    );
                 }
             });
         } else {
-            let timeout = self.shutdown_timeout;
             self.services.iter_mut().for_each(move |srv| {
                 if srv.status == WorkerServiceStatus::Available {
                     srv.status = WorkerServiceStatus::Stopping;
-                    actix_rt::spawn(
-                        srv.service
-                            .call((None, ServerMessage::Shutdown(timeout)))
-                            .map(|_| ()),
-                    );
                 }
             });
         }
@@ -303,6 +292,7 @@ enum WorkerState {
     Restarting(
         usize,
         Token,
+        #[allow(clippy::type_complexity)]
         Pin<Box<dyn Future<Output = Result<Vec<(Token, BoxedServerService)>, ()>>>>,
     ),
     Shutdown(
@@ -360,7 +350,7 @@ impl Future for Worker {
                             let guard = self.conns.get();
                             let _ = self.services[conn.token.0]
                                 .service
-                                .call((Some(guard), ServerMessage::Connect(conn.io)));
+                                .call((Some(guard), conn.io));
                         } else {
                             self.state = WorkerState::Available;
                             self.availability.set(true);
@@ -454,7 +444,7 @@ impl Future for Worker {
                                     let guard = self.conns.get();
                                     let _ = self.services[msg.token.0]
                                         .service
-                                        .call((Some(guard), ServerMessage::Connect(msg.io)));
+                                        .call((Some(guard), msg.io));
                                     continue;
                                 }
                                 Ok(false) => {

actix-server/tests/test_server.rs

@@ -22,13 +22,16 @@ fn test_bind() {
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
-        let sys = actix_rt::System::new("test");
+        let mut sys = actix_rt::System::new("test");
-        let srv = Server::build()
+
-            .workers(1)
+        let srv = sys.block_on(lazy(|_| {
-            .disable_signals()
+            Server::build()
-            .bind("test", addr, move || fn_service(|_| ok::<_, ()>(())))
+                .workers(1)
-            .unwrap()
+                .disable_signals()
-            .start();
+                .bind("test", addr, move || fn_service(|_| ok::<_, ()>(())))
+                .unwrap()
+                .start()
+        }));
         let _ = tx.send((srv, actix_rt::System::current()));
         let _ = sys.run();
     });
@@ -46,14 +49,16 @@ fn test_listen() {
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
-        let sys = actix_rt::System::new("test");
+        let mut sys = actix_rt::System::new("test");
         let lst = net::TcpListener::bind(addr).unwrap();
-        Server::build()
+        sys.block_on(lazy(|_| {
-            .disable_signals()
+            Server::build()
-            .workers(1)
+                .disable_signals()
-            .listen("test", lst, move || fn_service(|_| ok::<_, ()>(())))
+                .workers(1)
-            .unwrap()
+                .listen("test", lst, move || fn_service(|_| ok::<_, ()>(())))
-            .start();
+                .unwrap()
+                .start()
+        }));
         let _ = tx.send(actix_rt::System::current());
         let _ = sys.run();
     });
@@ -78,19 +83,21 @@ fn test_start() {
     let (tx, rx) = mpsc::channel();
 
     let h = thread::spawn(move || {
-        let sys = actix_rt::System::new("test");
+        let mut sys = actix_rt::System::new("test");
-        let srv: Server = Server::build()
+        let srv = sys.block_on(lazy(|_| {
-            .backlog(100)
+            Server::build()
-            .disable_signals()
+                .backlog(100)
-            .bind("test", addr, move || {
+                .disable_signals()
-                fn_service(|io: TcpStream| async move {
+                .bind("test", addr, move || {
-                    let mut f = Framed::new(io, BytesCodec);
+                    fn_service(|io: TcpStream| async move {
-                    f.send(Bytes::from_static(b"test")).await.unwrap();
+                        let mut f = Framed::new(io, BytesCodec);
-                    Ok::<_, ()>(())
+                        f.send(Bytes::from_static(b"test")).await.unwrap();
+                        Ok::<_, ()>(())
+                    })
                 })
-            })
+                .unwrap()
-            .unwrap()
+                .start()
-            .start();
+        }));
 
         let _ = tx.send((srv, actix_rt::System::current()));
         let _ = sys.run();
@@ -144,29 +151,31 @@ fn test_configure() {
 
     let h = thread::spawn(move || {
         let num = num2.clone();
-        let sys = actix_rt::System::new("test");
+        let mut sys = actix_rt::System::new("test");
-        let srv = Server::build()
+        let srv = sys.block_on(lazy(|_| {
-            .disable_signals()
+            Server::build()
-            .configure(move |cfg| {
+                .disable_signals()
-                let num = num.clone();
+                .configure(move |cfg| {
-                let lst = net::TcpListener::bind(addr3).unwrap();
+                    let num = num.clone();
-                cfg.bind("addr1", addr1)
+                    let lst = net::TcpListener::bind(addr3).unwrap();
-                    .unwrap()
+                    cfg.bind("addr1", addr1)
-                    .bind("addr2", addr2)
+                        .unwrap()
-                    .unwrap()
+                        .bind("addr2", addr2)
-                    .listen("addr3", lst)
+                        .unwrap()
-                    .apply(move |rt| {
+                        .listen("addr3", lst)
-                        let num = num.clone();
+                        .apply(move |rt| {
-                        rt.service("addr1", fn_service(|_| ok::<_, ()>(())));
+                            let num = num.clone();
-                        rt.service("addr3", fn_service(|_| ok::<_, ()>(())));
+                            rt.service("addr1", fn_service(|_| ok::<_, ()>(())));
-                        rt.on_start(lazy(move |_| {
+                            rt.service("addr3", fn_service(|_| ok::<_, ()>(())));
-                            let _ = num.fetch_add(1, Relaxed);
+                            rt.on_start(lazy(move |_| {
-                        }))
+                                let _ = num.fetch_add(1, Relaxed);
-                    })
+                            }))
-            })
+                        })
-            .unwrap()
+                })
-            .workers(1)
+                .unwrap()
-            .start();
+                .workers(1)
+                .start()
+        }));
         let _ = tx.send((srv, actix_rt::System::current()));
         let _ = sys.run();
     });

actix-service/CHANGES.md

@@ -3,11 +3,29 @@
 ## Unreleased - 2020-xx-xx
 
 
+## 2.0.0-beta.1 - 2020-12-28
+* `Service`, other traits, and many type signatures now take the the request type as a type
+  parameter instead of an associated type. [#232]
+* Add `always_ready!` and `forward_ready!` macros. [#233]
+* Crate is now `no_std`. [#233]
+* Migrate pin projections to `pin-project-lite`. [#233]
+* Remove `AndThenApplyFn` and Pipeline `and_then_apply_fn`. Use the
+  `.and_then(apply_fn(...))` construction. [#233]
+* Move non-vital methods to `ServiceExt` and `ServiceFactoryExt` extension traits. [#235]
+
+[#232]: https://github.com/actix/actix-net/pull/232
+[#233]: https://github.com/actix/actix-net/pull/233
+[#235]: https://github.com/actix/actix-net/pull/235
+
+
 ## 1.0.6 - 2020-08-09
 
 ### Fixed
 
-* Removed unsound custom Cell implementation that allowed obtaining several mutable references to the same data, which is undefined behavior in Rust and could lead to violations of memory safety. External code could obtain several mutable references to the same data through service combinators. Attempts to acquire several mutable references to the same data will instead result in a panic.
+* Removed unsound custom Cell implementation that allowed obtaining several mutable references to
+  the same data, which is undefined behavior in Rust and could lead to violations of memory safety. External code could obtain several mutable references to the same data through
+  service combinators. Attempts to acquire several mutable references to the same data will instead
+  result in a panic.
 
 ## [1.0.5] - 2020-01-16
 

actix-service/Cargo.toml

@@ -1,7 +1,10 @@
 [package]
 name = "actix-service"
-version = "1.0.6"
+version = "2.0.0-beta.1"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+authors = [
+    "Nikolay Kim <fafhrd91@gmail.com>",
+    "Rob Ede <robjtede@icloud.com>",
+]
 description = "Service trait and combinators for representing asynchronous request/response operations."
 keywords = ["network", "framework", "async", "futures", "service"]
 homepage = "https://actix.rs"
@@ -17,17 +20,9 @@ name = "actix_service"
 path = "src/lib.rs"
 
 [dependencies]
-futures-util = "0.3.1"
+futures-core = { version = "0.3.7", default-features = false }
-pin-project = "0.4.17"
+pin-project-lite = "0.2"
 
 [dev-dependencies]
 actix-rt = "1.0.0"
-criterion = "0.3"
+futures-util = { version = "0.3.7", default-features = false }
-
-[[bench]]
-name = "unsafecell_vs_refcell"
-harness = false
-
-[[bench]]
-name = "and_then"
-harness = false

actix-service/benches/and_then.rs

@@ -1,332 +0,0 @@
-use actix_service::boxed::BoxFuture;
-use actix_service::IntoService;
-use actix_service::Service;
-/// Benchmark various implementations of and_then
-use criterion::{criterion_main, Criterion};
-use futures_util::future::join_all;
-use futures_util::future::TryFutureExt;
-use std::cell::{RefCell, UnsafeCell};
-use std::future::Future;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::task::{Context, Poll};
-
-/*
- * Test services A,B for AndThen service implementations
- */
-
-async fn svc1(_: ()) -> Result<usize, ()> {
-    Ok(1)
-}
-
-async fn svc2(req: usize) -> Result<usize, ()> {
-    Ok(req + 1)
-}
-
-/*
- * AndThenUC - original AndThen service based on UnsafeCell
- * Cut down version of actix_service::AndThenService based on actix-service::Cell
- */
-
-struct AndThenUC<A, B>(Rc<UnsafeCell<(A, B)>>);
-
-impl<A, B> AndThenUC<A, B> {
-    fn new(a: A, b: B) -> Self
-    where
-        A: Service,
-        B: Service<Request = A::Response, Error = A::Error>,
-    {
-        Self(Rc::new(UnsafeCell::new((a, b))))
-    }
-}
-
-impl<A, B> Clone for AndThenUC<A, B> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-impl<A, B> Service for AndThenUC<A, B>
-where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
-{
-    type Request = A::Request;
-    type Response = B::Response;
-    type Error = A::Error;
-    type Future = AndThenServiceResponse<A, B>;
-
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, req: A::Request) -> Self::Future {
-        let fut = unsafe { &mut *(*self.0).get() }.0.call(req);
-        AndThenServiceResponse {
-            state: State::A(fut, Some(self.0.clone())),
-        }
-    }
-}
-
-#[pin_project::pin_project]
-pub(crate) struct AndThenServiceResponse<A, B>
-where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
-{
-    #[pin]
-    state: State<A, B>,
-}
-
-#[pin_project::pin_project(project = StateProj)]
-enum State<A, B>
-where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
-{
-    A(#[pin] A::Future, Option<Rc<UnsafeCell<(A, B)>>>),
-    B(#[pin] B::Future),
-    Empty,
-}
-
-impl<A, B> Future for AndThenServiceResponse<A, B>
-where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
-{
-    type Output = Result<B::Response, A::Error>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.as_mut().project();
-
-        match this.state.as_mut().project() {
-            StateProj::A(fut, b) => match fut.poll(cx)? {
-                Poll::Ready(res) => {
-                    let b = b.take().unwrap();
-                    this.state.set(State::Empty); // drop fut A
-                    let fut = unsafe { &mut (*b.get()).1 }.call(res);
-                    this.state.set(State::B(fut));
-                    self.poll(cx)
-                }
-                Poll::Pending => Poll::Pending,
-            },
-            StateProj::B(fut) => fut.poll(cx).map(|r| {
-                this.state.set(State::Empty);
-                r
-            }),
-            StateProj::Empty => {
-                panic!("future must not be polled after it returned `Poll::Ready`")
-            }
-        }
-    }
-}
-
-/*
- * AndThenRC - AndThen service based on RefCell
- */
-
-struct AndThenRC<A, B>(Rc<RefCell<(A, B)>>);
-
-impl<A, B> AndThenRC<A, B> {
-    fn new(a: A, b: B) -> Self
-    where
-        A: Service,
-        B: Service<Request = A::Response, Error = A::Error>,
-    {
-        Self(Rc::new(RefCell::new((a, b))))
-    }
-}
-
-impl<A, B> Clone for AndThenRC<A, B> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-impl<A, B> Service for AndThenRC<A, B>
-where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
-{
-    type Request = A::Request;
-    type Response = B::Response;
-    type Error = A::Error;
-    type Future = AndThenServiceResponseRC<A, B>;
-
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, req: A::Request) -> Self::Future {
-        let fut = self.0.borrow_mut().0.call(req);
-        AndThenServiceResponseRC {
-            state: StateRC::A(fut, Some(self.0.clone())),
-        }
-    }
-}
-
-#[pin_project::pin_project]
-pub(crate) struct AndThenServiceResponseRC<A, B>
-where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
-{
-    #[pin]
-    state: StateRC<A, B>,
-}
-
-#[pin_project::pin_project(project = StateRCProj)]
-enum StateRC<A, B>
-where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
-{
-    A(#[pin] A::Future, Option<Rc<RefCell<(A, B)>>>),
-    B(#[pin] B::Future),
-    Empty,
-}
-
-impl<A, B> Future for AndThenServiceResponseRC<A, B>
-where
-    A: Service,
-    B: Service<Request = A::Response, Error = A::Error>,
-{
-    type Output = Result<B::Response, A::Error>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.as_mut().project();
-
-        match this.state.as_mut().project() {
-            StateRCProj::A(fut, b) => match fut.poll(cx)? {
-                Poll::Ready(res) => {
-                    let b = b.take().unwrap();
-                    this.state.set(StateRC::Empty); // drop fut A
-                    let fut = b.borrow_mut().1.call(res);
-                    this.state.set(StateRC::B(fut));
-                    self.poll(cx)
-                }
-                Poll::Pending => Poll::Pending,
-            },
-            StateRCProj::B(fut) => fut.poll(cx).map(|r| {
-                this.state.set(StateRC::Empty);
-                r
-            }),
-            StateRCProj::Empty => {
-                panic!("future must not be polled after it returned `Poll::Ready`")
-            }
-        }
-    }
-}
-
-/*
- * AndThenRCFuture - AndThen service based on RefCell
- * and standard futures::future::and_then combinator in a Box
- */
-
-struct AndThenRCFuture<A, B>(Rc<RefCell<(A, B)>>);
-
-impl<A, B> AndThenRCFuture<A, B> {
-    fn new(a: A, b: B) -> Self
-    where
-        A: Service,
-        B: Service<Request = A::Response, Error = A::Error>,
-    {
-        Self(Rc::new(RefCell::new((a, b))))
-    }
-}
-
-impl<A, B> Clone for AndThenRCFuture<A, B> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-impl<A, B> Service for AndThenRCFuture<A, B>
-where
-    A: Service + 'static,
-    A::Future: 'static,
-    B: Service<Request = A::Response, Error = A::Error> + 'static,
-    B::Future: 'static,
-{
-    type Request = A::Request;
-    type Response = B::Response;
-    type Error = A::Error;
-    type Future = BoxFuture<Self::Response, Self::Error>;
-
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, req: A::Request) -> Self::Future {
-        let fut = self.0.borrow_mut().0.call(req);
-        let core = self.0.clone();
-        let fut2 = move |res| (*core).borrow_mut().1.call(res);
-        Box::pin(fut.and_then(fut2))
-    }
-}
-
-/// Criterion Benchmark for async Service
-/// Should be used from within criterion group:
-/// ```rust,ignore
-/// let mut criterion: ::criterion::Criterion<_> =
-///     ::criterion::Criterion::default().configure_from_args();
-/// bench_async_service(&mut criterion, ok_service(), "async_service_direct");
-/// ```
-///
-/// Usable for benching Service wrappers:
-/// Using minimum service code implementation we first measure
-/// time to run minimum service, then measure time with wrapper.
-///
-/// Sample output
-/// async_service_direct    time:   [1.0908 us 1.1656 us 1.2613 us]
-pub fn bench_async_service<S>(c: &mut Criterion, srv: S, name: &str)
-where
-    S: Service<Request = (), Response = usize, Error = ()> + Clone + 'static,
-{
-    let mut rt = actix_rt::System::new("test");
-
-    // start benchmark loops
-    c.bench_function(name, move |b| {
-        b.iter_custom(|iters| {
-            let mut srvs: Vec<_> = (1..iters).map(|_| srv.clone()).collect();
-            // exclude request generation, it appears it takes significant time vs call (3us vs 1us)
-            let start = std::time::Instant::now();
-            // benchmark body
-            rt.block_on(async move { join_all(srvs.iter_mut().map(|srv| srv.call(()))).await });
-            // check that at least first request succeeded
-            start.elapsed()
-        })
-    });
-}
-
-pub fn service_benches() {
-    let mut criterion: ::criterion::Criterion<_> =
-        ::criterion::Criterion::default().configure_from_args();
-    bench_async_service(
-        &mut criterion,
-        AndThenUC::new(svc1.into_service(), svc2.into_service()),
-        "AndThen with UnsafeCell",
-    );
-    bench_async_service(
-        &mut criterion,
-        AndThenRC::new(svc1.into_service(), svc2.into_service()),
-        "AndThen with RefCell",
-    );
-    bench_async_service(
-        &mut criterion,
-        AndThenUC::new(svc1.into_service(), svc2.into_service()),
-        "AndThen with UnsafeCell",
-    );
-    bench_async_service(
-        &mut criterion,
-        AndThenRC::new(svc1.into_service(), svc2.into_service()),
-        "AndThen with RefCell",
-    );
-    bench_async_service(
-        &mut criterion,
-        AndThenRCFuture::new(svc1.into_service(), svc2.into_service()),
-        "AndThen with RefCell via future::and_then",
-    );
-}
-
-criterion_main!(service_benches);

actix-service/benches/unsafecell_vs_refcell.rs

@@ -1,112 +0,0 @@
-use actix_service::Service;
-use criterion::{criterion_main, Criterion};
-use futures_util::future::join_all;
-use futures_util::future::{ok, Ready};
-use std::cell::{RefCell, UnsafeCell};
-use std::rc::Rc;
-use std::task::{Context, Poll};
-
-struct SrvUC(Rc<UnsafeCell<usize>>);
-
-impl Default for SrvUC {
-    fn default() -> Self {
-        Self(Rc::new(UnsafeCell::new(0)))
-    }
-}
-
-impl Clone for SrvUC {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-impl Service for SrvUC {
-    type Request = ();
-    type Response = usize;
-    type Error = ();
-    type Future = Ready<Result<Self::Response, ()>>;
-
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, _: ()) -> Self::Future {
-        unsafe { *(*self.0).get() = *(*self.0).get() + 1 };
-        ok(unsafe { *self.0.get() })
-    }
-}
-
-struct SrvRC(Rc<RefCell<usize>>);
-
-impl Default for SrvRC {
-    fn default() -> Self {
-        Self(Rc::new(RefCell::new(0)))
-    }
-}
-
-impl Clone for SrvRC {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-impl Service for SrvRC {
-    type Request = ();
-    type Response = usize;
-    type Error = ();
-    type Future = Ready<Result<Self::Response, ()>>;
-
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, _: ()) -> Self::Future {
-        let prev = *self.0.borrow();
-        *(*self.0).borrow_mut() = prev + 1;
-        ok(*self.0.borrow())
-    }
-}
-
-/// Criterion Benchmark for async Service
-/// Should be used from within criterion group:
-/// ```rust,ignore
-/// let mut criterion: ::criterion::Criterion<_> =
-///     ::criterion::Criterion::default().configure_from_args();
-/// bench_async_service(&mut criterion, ok_service(), "async_service_direct");
-/// ```
-///
-/// Usable for benching Service wrappers:
-/// Using minimum service code implementation we first measure
-/// time to run minimum service, then measure time with wrapper.
-///
-/// Sample output
-/// async_service_direct    time:   [1.0908 us 1.1656 us 1.2613 us]
-pub fn bench_async_service<S>(c: &mut Criterion, srv: S, name: &str)
-where
-    S: Service<Request = (), Response = usize, Error = ()> + Clone + 'static,
-{
-    let mut rt = actix_rt::System::new("test");
-
-    // start benchmark loops
-    c.bench_function(name, move |b| {
-        b.iter_custom(|iters| {
-            let mut srvs: Vec<_> = (1..iters).map(|_| srv.clone()).collect();
-            // exclude request generation, it appears it takes significant time vs call (3us vs 1us)
-            let start = std::time::Instant::now();
-            // benchmark body
-            rt.block_on(async move { join_all(srvs.iter_mut().map(|srv| srv.call(()))).await });
-            // check that at least first request succeeded
-            start.elapsed()
-        })
-    });
-}
-
-pub fn service_benches() {
-    let mut criterion: ::criterion::Criterion<_> =
-        ::criterion::Criterion::default().configure_from_args();
-    bench_async_service(&mut criterion, SrvUC::default(), "Service with UnsafeCell");
-    bench_async_service(&mut criterion, SrvRC::default(), "Service with RefCell");
-    bench_async_service(&mut criterion, SrvUC::default(), "Service with UnsafeCell");
-    bench_async_service(&mut criterion, SrvRC::default(), "Service with RefCell");
-}
-criterion_main!(service_benches);

actix-service/src/and_then.rs

@@ -1,43 +1,47 @@
-use std::cell::RefCell;
+use alloc::rc::Rc;
-use std::future::Future;
+use core::{
-use std::pin::Pin;
+    cell::RefCell,
-use std::rc::Rc;
+    future::Future,
-use std::task::{Context, Poll};
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use super::{Service, ServiceFactory};
 
 /// Service for the `and_then` combinator, chaining a computation onto the end
 /// of another service which completes successfully.
 ///
-/// This is created by the `ServiceExt::and_then` method.
+/// This is created by the `Pipeline::and_then` method.
-pub(crate) struct AndThenService<A, B>(Rc<RefCell<(A, B)>>);
+pub(crate) struct AndThenService<A, B, Req>(Rc<RefCell<(A, B)>>, PhantomData<Req>);
 
-impl<A, B> AndThenService<A, B> {
+impl<A, B, Req> AndThenService<A, B, Req> {
     /// Create new `AndThen` combinator
     pub(crate) fn new(a: A, b: B) -> Self
     where
-        A: Service,
+        A: Service<Req>,
-        B: Service<Request = A::Response, Error = A::Error>,
+        B: Service<A::Response, Error = A::Error>,
     {
-        Self(Rc::new(RefCell::new((a, b))))
+        Self(Rc::new(RefCell::new((a, b))), PhantomData)
     }
 }
 
-impl<A, B> Clone for AndThenService<A, B> {
+impl<A, B, Req> Clone for AndThenService<A, B, Req> {
     fn clone(&self) -> Self {
-        AndThenService(self.0.clone())
+        AndThenService(self.0.clone(), PhantomData)
     }
 }
 
-impl<A, B> Service for AndThenService<A, B>
+impl<A, B, Req> Service<Req> for AndThenService<A, B, Req>
 where
-    A: Service,
+    A: Service<Req>,
-    B: Service<Request = A::Response, Error = A::Error>,
+    B: Service<A::Response, Error = A::Error>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
-    type Future = AndThenServiceResponse<A, B>;
+    type Future = AndThenServiceResponse<A, B, Req>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         let mut srv = self.0.borrow_mut();
@@ -49,38 +53,51 @@ where
         }
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         AndThenServiceResponse {
-            state: State::A(self.0.borrow_mut().0.call(req), Some(self.0.clone())),
+            state: State::A {
+                fut: self.0.borrow_mut().0.call(req),
+                b: Some(self.0.clone()),
+            },
         }
     }
 }
 
-#[pin_project::pin_project]
+pin_project! {
-pub(crate) struct AndThenServiceResponse<A, B>
+    pub(crate) struct AndThenServiceResponse<A, B, Req>
-where
+    where
-    A: Service,
+        A: Service<Req>,
-    B: Service<Request = A::Response, Error = A::Error>,
+        B: Service<A::Response, Error = A::Error>,
-{
+    {
-    #[pin]
+        #[pin]
-    state: State<A, B>,
+        state: State<A, B, Req>,
+    }
 }
 
-#[pin_project::pin_project(project = StateProj)]
+pin_project! {
-enum State<A, B>
+    #[project = StateProj]
-where
+    enum State<A, B, Req>
-    A: Service,
+    where
-    B: Service<Request = A::Response, Error = A::Error>,
+        A: Service<Req>,
-{
+        B: Service<A::Response, Error = A::Error>,
-    A(#[pin] A::Future, Option<Rc<RefCell<(A, B)>>>),
+    {
-    B(#[pin] B::Future),
+        A {
-    Empty,
+            #[pin]
+            fut: A::Future,
+            b: Option<Rc<RefCell<(A, B)>>>,
+        },
+        B {
+            #[pin]
+            fut: B::Future,
+        },
+        Empty,
+    }
 }
 
-impl<A, B> Future for AndThenServiceResponse<A, B>
+impl<A, B, Req> Future for AndThenServiceResponse<A, B, Req>
 where
-    A: Service,
+    A: Service<Req>,
-    B: Service<Request = A::Response, Error = A::Error>,
+    B: Service<A::Response, Error = A::Error>,
 {
     type Output = Result<B::Response, A::Error>;
 
@@ -88,17 +105,17 @@ where
         let mut this = self.as_mut().project();
 
         match this.state.as_mut().project() {
-            StateProj::A(fut, b) => match fut.poll(cx)? {
+            StateProj::A { fut, b } => match fut.poll(cx)? {
                 Poll::Ready(res) => {
                     let b = b.take().unwrap();
                     this.state.set(State::Empty); // drop fut A
                     let fut = b.borrow_mut().1.call(res);
-                    this.state.set(State::B(fut));
+                    this.state.set(State::B { fut });
                     self.poll(cx)
                 }
                 Poll::Pending => Poll::Pending,
             },
-            StateProj::B(fut) => fut.poll(cx).map(|r| {
+            StateProj::B { fut } => fut.poll(cx).map(|r| {
                 this.state.set(State::Empty);
                 r
             }),
@@ -110,27 +127,28 @@ where
 }
 
 /// `.and_then()` service factory combinator
-pub(crate) struct AndThenServiceFactory<A, B>
+pub(crate) struct AndThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        A::Response,
         Config = A::Config,
-        Request = A::Response,
         Error = A::Error,
         InitError = A::InitError,
     >,
 {
     inner: Rc<(A, B)>,
+    _phantom: PhantomData<Req>,
 }
 
-impl<A, B> AndThenServiceFactory<A, B>
+impl<A, B, Req> AndThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        A::Response,
         Config = A::Config,
-        Request = A::Response,
         Error = A::Error,
         InitError = A::InitError,
     >,
@@ -139,29 +157,29 @@ where
     pub(crate) fn new(a: A, b: B) -> Self {
         Self {
             inner: Rc::new((a, b)),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<A, B> ServiceFactory for AndThenServiceFactory<A, B>
+impl<A, B, Req> ServiceFactory<Req> for AndThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        A::Response,
         Config = A::Config,
-        Request = A::Response,
         Error = A::Error,
         InitError = A::InitError,
     >,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
 
     type Config = A::Config;
-    type Service = AndThenService<A::Service, B::Service>;
+    type Service = AndThenService<A::Service, B::Service, Req>;
     type InitError = A::InitError;
-    type Future = AndThenServiceFactoryResponse<A, B>;
+    type Future = AndThenServiceFactoryResponse<A, B, Req>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
         let inner = &*self.inner;
@@ -172,13 +190,13 @@ where
     }
 }
 
-impl<A, B> Clone for AndThenServiceFactory<A, B>
+impl<A, B, Req> Clone for AndThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        A::Response,
         Config = A::Config,
-        Request = A::Response,
         Error = A::Error,
         InitError = A::InitError,
     >,
@@ -186,29 +204,31 @@ where
     fn clone(&self) -> Self {
         Self {
             inner: self.inner.clone(),
+            _phantom: PhantomData,
         }
     }
 }
 
-#[pin_project::pin_project]
+pin_project! {
-pub(crate) struct AndThenServiceFactoryResponse<A, B>
+    pub(crate) struct AndThenServiceFactoryResponse<A, B, Req>
-where
+    where
-    A: ServiceFactory,
+        A: ServiceFactory<Req>,
-    B: ServiceFactory<Request = A::Response>,
+        B: ServiceFactory<A::Response>,
-{
+    {
-    #[pin]
+        #[pin]
-    fut_a: A::Future,
+        fut_a: A::Future,
-    #[pin]
+        #[pin]
-    fut_b: B::Future,
+        fut_b: B::Future,
 
-    a: Option<A::Service>,
+        a: Option<A::Service>,
-    b: Option<B::Service>,
+        b: Option<B::Service>,
+    }
 }
 
-impl<A, B> AndThenServiceFactoryResponse<A, B>
+impl<A, B, Req> AndThenServiceFactoryResponse<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
-    B: ServiceFactory<Request = A::Response>,
+    B: ServiceFactory<A::Response>,
 {
     fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
         AndThenServiceFactoryResponse {
@@ -220,12 +240,12 @@ where
     }
 }
 
-impl<A, B> Future for AndThenServiceFactoryResponse<A, B>
+impl<A, B, Req> Future for AndThenServiceFactoryResponse<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
-    B: ServiceFactory<Request = A::Response, Error = A::Error, InitError = A::InitError>,
+    B: ServiceFactory<A::Response, Error = A::Error, InitError = A::InitError>,
 {
-    type Output = Result<AndThenService<A::Service, B::Service>, A::InitError>;
+    type Output = Result<AndThenService<A::Service, B::Service, Req>, A::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -253,18 +273,21 @@ where
 
 #[cfg(test)]
 mod tests {
-    use std::cell::Cell;
+    use alloc::rc::Rc;
-    use std::rc::Rc;
+    use core::{
-    use std::task::{Context, Poll};
+        cell::Cell,
+        task::{Context, Poll},
+    };
 
-    use futures_util::future::{lazy, ok, ready, Ready};
+    use futures_util::future::lazy;
 
-    use crate::{fn_factory, pipeline, pipeline_factory, Service, ServiceFactory};
+    use crate::{
+        fn_factory, ok, pipeline, pipeline_factory, ready, Ready, Service, ServiceFactory,
+    };
 
     struct Srv1(Rc<Cell<usize>>);
 
-    impl Service for Srv1 {
+    impl Service<&'static str> for Srv1 {
-        type Request = &'static str;
         type Response = &'static str;
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;
@@ -282,8 +305,7 @@ mod tests {
     #[derive(Clone)]
     struct Srv2(Rc<Cell<usize>>);
 
-    impl Service for Srv2 {
+    impl Service<&'static str> for Srv2 {
-        type Request = &'static str;
         type Response = (&'static str, &'static str);
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;

actix-service/src/and_then_apply_fn.rs

@@ -1,326 +0,0 @@
-use std::cell::RefCell;
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::task::{Context, Poll};
-
-use crate::{Service, ServiceFactory};
-
-/// `Apply` service combinator
-pub(crate) struct AndThenApplyFn<A, B, F, Fut, Res, Err>
-where
-    A: Service,
-    B: Service,
-    F: FnMut(A::Response, &mut B) -> Fut,
-    Fut: Future<Output = Result<Res, Err>>,
-    Err: From<A::Error> + From<B::Error>,
-{
-    srv: Rc<RefCell<(A, B, F)>>,
-    r: PhantomData<(Fut, Res, Err)>,
-}
-
-impl<A, B, F, Fut, Res, Err> AndThenApplyFn<A, B, F, Fut, Res, Err>
-where
-    A: Service,
-    B: Service,
-    F: FnMut(A::Response, &mut B) -> Fut,
-    Fut: Future<Output = Result<Res, Err>>,
-    Err: From<A::Error> + From<B::Error>,
-{
-    /// Create new `Apply` combinator
-    pub(crate) fn new(a: A, b: B, f: F) -> Self {
-        Self {
-            srv: Rc::new(RefCell::new((a, b, f))),
-            r: PhantomData,
-        }
-    }
-}
-
-impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFn<A, B, F, Fut, Res, Err>
-where
-    A: Service,
-    B: Service,
-    F: FnMut(A::Response, &mut B) -> Fut,
-    Fut: Future<Output = Result<Res, Err>>,
-    Err: From<A::Error> + From<B::Error>,
-{
-    fn clone(&self) -> Self {
-        AndThenApplyFn {
-            srv: self.srv.clone(),
-            r: PhantomData,
-        }
-    }
-}
-
-impl<A, B, F, Fut, Res, Err> Service for AndThenApplyFn<A, B, F, Fut, Res, Err>
-where
-    A: Service,
-    B: Service,
-    F: FnMut(A::Response, &mut B) -> Fut,
-    Fut: Future<Output = Result<Res, Err>>,
-    Err: From<A::Error> + From<B::Error>,
-{
-    type Request = A::Request;
-    type Response = Res;
-    type Error = Err;
-    type Future = AndThenApplyFnFuture<A, B, F, Fut, Res, Err>;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        let mut inner = self.srv.borrow_mut();
-        let not_ready = inner.0.poll_ready(cx)?.is_pending();
-        if inner.1.poll_ready(cx)?.is_pending() || not_ready {
-            Poll::Pending
-        } else {
-            Poll::Ready(Ok(()))
-        }
-    }
-
-    fn call(&mut self, req: A::Request) -> Self::Future {
-        let fut = self.srv.borrow_mut().0.call(req);
-        AndThenApplyFnFuture {
-            state: State::A(fut, Some(self.srv.clone())),
-        }
-    }
-}
-
-#[pin_project::pin_project]
-pub(crate) struct AndThenApplyFnFuture<A, B, F, Fut, Res, Err>
-where
-    A: Service,
-    B: Service,
-    F: FnMut(A::Response, &mut B) -> Fut,
-    Fut: Future<Output = Result<Res, Err>>,
-    Err: From<A::Error>,
-    Err: From<B::Error>,
-{
-    #[pin]
-    state: State<A, B, F, Fut, Res, Err>,
-}
-
-#[pin_project::pin_project(project = StateProj)]
-enum State<A, B, F, Fut, Res, Err>
-where
-    A: Service,
-    B: Service,
-    F: FnMut(A::Response, &mut B) -> Fut,
-    Fut: Future<Output = Result<Res, Err>>,
-    Err: From<A::Error>,
-    Err: From<B::Error>,
-{
-    A(#[pin] A::Future, Option<Rc<RefCell<(A, B, F)>>>),
-    B(#[pin] Fut),
-    Empty,
-}
-
-impl<A, B, F, Fut, Res, Err> Future for AndThenApplyFnFuture<A, B, F, Fut, Res, Err>
-where
-    A: Service,
-    B: Service,
-    F: FnMut(A::Response, &mut B) -> Fut,
-    Fut: Future<Output = Result<Res, Err>>,
-    Err: From<A::Error> + From<B::Error>,
-{
-    type Output = Result<Res, Err>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.as_mut().project();
-
-        match this.state.as_mut().project() {
-            StateProj::A(fut, b) => match fut.poll(cx)? {
-                Poll::Ready(res) => {
-                    let b = b.take().unwrap();
-                    this.state.set(State::Empty);
-                    let (_, b, f) = &mut *b.borrow_mut();
-                    let fut = f(res, b);
-                    this.state.set(State::B(fut));
-                    self.poll(cx)
-                }
-                Poll::Pending => Poll::Pending,
-            },
-            StateProj::B(fut) => fut.poll(cx).map(|r| {
-                this.state.set(State::Empty);
-                r
-            }),
-            StateProj::Empty => {
-                panic!("future must not be polled after it returned `Poll::Ready`")
-            }
-        }
-    }
-}
-
-/// `AndThenApplyFn` service factory
-pub(crate) struct AndThenApplyFnFactory<A, B, F, Fut, Res, Err> {
-    srv: Rc<(A, B, F)>,
-    r: PhantomData<(Fut, Res, Err)>,
-}
-
-impl<A, B, F, Fut, Res, Err> AndThenApplyFnFactory<A, B, F, Fut, Res, Err>
-where
-    A: ServiceFactory,
-    B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
-    F: FnMut(A::Response, &mut B::Service) -> Fut + Clone,
-    Fut: Future<Output = Result<Res, Err>>,
-    Err: From<A::Error> + From<B::Error>,
-{
-    /// Create new `ApplyNewService` new service instance
-    pub(crate) fn new(a: A, b: B, f: F) -> Self {
-        Self {
-            srv: Rc::new((a, b, f)),
-            r: PhantomData,
-        }
-    }
-}
-
-impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFnFactory<A, B, F, Fut, Res, Err> {
-    fn clone(&self) -> Self {
-        Self {
-            srv: self.srv.clone(),
-            r: PhantomData,
-        }
-    }
-}
-
-impl<A, B, F, Fut, Res, Err> ServiceFactory for AndThenApplyFnFactory<A, B, F, Fut, Res, Err>
-where
-    A: ServiceFactory,
-    A::Config: Clone,
-    B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
-    F: FnMut(A::Response, &mut B::Service) -> Fut + Clone,
-    Fut: Future<Output = Result<Res, Err>>,
-    Err: From<A::Error> + From<B::Error>,
-{
-    type Request = A::Request;
-    type Response = Res;
-    type Error = Err;
-    type Service = AndThenApplyFn<A::Service, B::Service, F, Fut, Res, Err>;
-    type Config = A::Config;
-    type InitError = A::InitError;
-    type Future = AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>;
-
-    fn new_service(&self, cfg: A::Config) -> Self::Future {
-        let srv = &*self.srv;
-        AndThenApplyFnFactoryResponse {
-            a: None,
-            b: None,
-            f: srv.2.clone(),
-            fut_a: srv.0.new_service(cfg.clone()),
-            fut_b: srv.1.new_service(cfg),
-        }
-    }
-}
-
-#[pin_project::pin_project]
-pub(crate) struct AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>
-where
-    A: ServiceFactory,
-    B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
-    F: FnMut(A::Response, &mut B::Service) -> Fut + Clone,
-    Fut: Future<Output = Result<Res, Err>>,
-    Err: From<A::Error>,
-    Err: From<B::Error>,
-{
-    #[pin]
-    fut_b: B::Future,
-    #[pin]
-    fut_a: A::Future,
-    f: F,
-    a: Option<A::Service>,
-    b: Option<B::Service>,
-}
-
-impl<A, B, F, Fut, Res, Err> Future for AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>
-where
-    A: ServiceFactory,
-    B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
-    F: FnMut(A::Response, &mut B::Service) -> Fut + Clone,
-    Fut: Future<Output = Result<Res, Err>>,
-    Err: From<A::Error> + From<B::Error>,
-{
-    type Output =
-        Result<AndThenApplyFn<A::Service, B::Service, F, Fut, Res, Err>, A::InitError>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-
-        if this.a.is_none() {
-            if let Poll::Ready(service) = this.fut_a.poll(cx)? {
-                *this.a = Some(service);
-            }
-        }
-
-        if this.b.is_none() {
-            if let Poll::Ready(service) = this.fut_b.poll(cx)? {
-                *this.b = Some(service);
-            }
-        }
-
-        if this.a.is_some() && this.b.is_some() {
-            Poll::Ready(Ok(AndThenApplyFn {
-                srv: Rc::new(RefCell::new((
-                    this.a.take().unwrap(),
-                    this.b.take().unwrap(),
-                    this.f.clone(),
-                ))),
-                r: PhantomData,
-            }))
-        } else {
-            Poll::Pending
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use futures_util::future::{lazy, ok, Ready, TryFutureExt};
-
-    use crate::{fn_service, pipeline, pipeline_factory, Service, ServiceFactory};
-
-    #[derive(Clone)]
-    struct Srv;
-    impl Service for Srv {
-        type Request = ();
-        type Response = ();
-        type Error = ();
-        type Future = Ready<Result<(), ()>>;
-
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-
-        #[allow(clippy::unit_arg)]
-        fn call(&mut self, req: Self::Request) -> Self::Future {
-            ok(req)
-        }
-    }
-
-    #[actix_rt::test]
-    async fn test_service() {
-        let mut srv = pipeline(ok).and_then_apply_fn(Srv, |req: &'static str, s| {
-            s.call(()).map_ok(move |res| (req, res))
-        });
-        let res = lazy(|cx| srv.poll_ready(cx)).await;
-        assert_eq!(res, Poll::Ready(Ok(())));
-
-        let res = srv.call("srv").await;
-        assert!(res.is_ok());
-        assert_eq!(res.unwrap(), ("srv", ()));
-    }
-
-    #[actix_rt::test]
-    async fn test_service_factory() {
-        let new_srv = pipeline_factory(|| ok::<_, ()>(fn_service(ok))).and_then_apply_fn(
-            || ok(Srv),
-            |req: &'static str, s| s.call(()).map_ok(move |res| (req, res)),
-        );
-        let mut srv = new_srv.new_service(()).await.unwrap();
-        let res = lazy(|cx| srv.poll_ready(cx)).await;
-        assert_eq!(res, Poll::Ready(Ok(())));
-
-        let res = srv.call("srv").await;
-        assert!(res.is_ok());
-        assert_eq!(res.unwrap(), ("srv", ()));
-    }
-}

actix-service/src/apply.rs

@@ -1,227 +1,230 @@
-use std::future::Future;
+use core::{
-use std::marker::PhantomData;
+    future::Future,
-use std::pin::Pin;
+    marker::PhantomData,
-use std::task::{Context, Poll};
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use futures_core::ready;
+use pin_project_lite::pin_project;
 
 use super::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
-/// Apply tranform function to a service.
+/// Apply transform function to a service.
-pub fn apply_fn<T, F, R, In, Out, Err, U>(service: U, f: F) -> Apply<T, F, R, In, Out, Err>
+///
+/// The In and Out type params refer to the request and response types for the wrapped service.
+pub fn apply_fn<I, S, F, Fut, Req, In, Res, Err>(
+    service: I,
+    wrap_fn: F,
+) -> Apply<S, F, Req, In, Res, Err>
 where
-    T: Service<Error = Err>,
+    I: IntoService<S, In>,
-    F: FnMut(In, &mut T) -> R,
+    S: Service<In, Error = Err>,
-    R: Future<Output = Result<Out, Err>>,
+    F: FnMut(Req, &mut S) -> Fut,
-    U: IntoService<T>,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    Apply::new(service.into_service(), f)
+    Apply::new(service.into_service(), wrap_fn)
 }
 
-/// Service factory that prodices `apply_fn` service.
+/// Service factory that produces `apply_fn` service.
-pub fn apply_fn_factory<T, F, R, In, Out, Err, U>(
+///
-    service: U,
+/// The In and Out type params refer to the request and response types for the wrapped service.
+pub fn apply_fn_factory<I, SF, F, Fut, Req, In, Res, Err>(
+    service: I,
     f: F,
-) -> ApplyServiceFactory<T, F, R, In, Out, Err>
+) -> ApplyFactory<SF, F, Req, In, Res, Err>
 where
-    T: ServiceFactory<Error = Err>,
+    I: IntoServiceFactory<SF, In>,
-    F: FnMut(In, &mut T::Service) -> R + Clone,
+    SF: ServiceFactory<In, Error = Err>,
-    R: Future<Output = Result<Out, Err>>,
+    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
-    U: IntoServiceFactory<T>,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    ApplyServiceFactory::new(service.into_factory(), f)
+    ApplyFactory::new(service.into_factory(), f)
 }
 
-/// `Apply` service combinator
+/// `Apply` service combinator.
-pub struct Apply<T, F, R, In, Out, Err>
+///
+/// The In and Out type params refer to the request and response types for the wrapped service.
+pub struct Apply<S, F, Req, In, Res, Err>
 where
-    T: Service<Error = Err>,
+    S: Service<In, Error = Err>,
 {
-    service: T,
+    service: S,
-    f: F,
+    wrap_fn: F,
-    r: PhantomData<(In, Out, R)>,
+    _phantom: PhantomData<(Req, In, Res, Err)>,
 }
 
-impl<T, F, R, In, Out, Err> Apply<T, F, R, In, Out, Err>
+impl<S, F, Fut, Req, In, Res, Err> Apply<S, F, Req, In, Res, Err>
 where
-    T: Service<Error = Err>,
+    S: Service<In, Error = Err>,
-    F: FnMut(In, &mut T) -> R,
+    F: FnMut(Req, &mut S) -> Fut,
-    R: Future<Output = Result<Out, Err>>,
+    Fut: Future<Output = Result<Res, Err>>,
 {
     /// Create new `Apply` combinator
-    fn new(service: T, f: F) -> Self {
+    fn new(service: S, wrap_fn: F) -> Self {
         Self {
             service,
-            f,
+            wrap_fn,
-            r: PhantomData,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, F, R, In, Out, Err> Clone for Apply<T, F, R, In, Out, Err>
+impl<S, F, Fut, Req, In, Res, Err> Clone for Apply<S, F, Req, In, Res, Err>
 where
-    T: Service<Error = Err> + Clone,
+    S: Service<In, Error = Err> + Clone,
-    F: FnMut(In, &mut T) -> R + Clone,
+    F: FnMut(Req, &mut S) -> Fut + Clone,
-    R: Future<Output = Result<Out, Err>>,
+    Fut: Future<Output = Result<Res, Err>>,
 {
     fn clone(&self) -> Self {
         Apply {
             service: self.service.clone(),
-            f: self.f.clone(),
+            wrap_fn: self.wrap_fn.clone(),
-            r: PhantomData,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, F, R, In, Out, Err> Service for Apply<T, F, R, In, Out, Err>
+impl<S, F, Fut, Req, In, Res, Err> Service<Req> for Apply<S, F, Req, In, Res, Err>
 where
-    T: Service<Error = Err>,
+    S: Service<In, Error = Err>,
-    F: FnMut(In, &mut T) -> R,
+    F: FnMut(Req, &mut S) -> Fut,
-    R: Future<Output = Result<Out, Err>>,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    type Request = In;
+    type Response = Res;
-    type Response = Out;
     type Error = Err;
-    type Future = R;
+    type Future = Fut;
 
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    crate::forward_ready!(service);
-        Poll::Ready(futures_util::ready!(self.service.poll_ready(cx)))
-    }
 
-    fn call(&mut self, req: In) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
-        (self.f)(req, &mut self.service)
+        (self.wrap_fn)(req, &mut self.service)
     }
 }
 
-/// `apply()` service factory
+/// `ApplyFactory` service factory combinator.
-pub struct ApplyServiceFactory<T, F, R, In, Out, Err>
+pub struct ApplyFactory<SF, F, Req, In, Res, Err> {
-where
+    factory: SF,
-    T: ServiceFactory<Error = Err>,
+    wrap_fn: F,
-    F: FnMut(In, &mut T::Service) -> R + Clone,
+    _phantom: PhantomData<(Req, In, Res, Err)>,
-    R: Future<Output = Result<Out, Err>>,
-{
-    service: T,
-    f: F,
-    r: PhantomData<(R, In, Out)>,
 }
 
-impl<T, F, R, In, Out, Err> ApplyServiceFactory<T, F, R, In, Out, Err>
+impl<SF, F, Fut, Req, In, Res, Err> ApplyFactory<SF, F, Req, In, Res, Err>
 where
-    T: ServiceFactory<Error = Err>,
+    SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R + Clone,
+    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
-    R: Future<Output = Result<Out, Err>>,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    /// Create new `ApplyNewService` new service instance
+    /// Create new `ApplyFactory` new service instance
-    fn new(service: T, f: F) -> Self {
+    fn new(factory: SF, wrap_fn: F) -> Self {
         Self {
-            f,
+            factory,
-            service,
+            wrap_fn,
-            r: PhantomData,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, F, R, In, Out, Err> Clone for ApplyServiceFactory<T, F, R, In, Out, Err>
+impl<SF, F, Fut, Req, In, Res, Err> Clone for ApplyFactory<SF, F, Req, In, Res, Err>
 where
-    T: ServiceFactory<Error = Err> + Clone,
+    SF: ServiceFactory<In, Error = Err> + Clone,
-    F: FnMut(In, &mut T::Service) -> R + Clone,
+    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
-    R: Future<Output = Result<Out, Err>>,
+    Fut: Future<Output = Result<Res, Err>>,
 {
     fn clone(&self) -> Self {
         Self {
-            service: self.service.clone(),
+            factory: self.factory.clone(),
-            f: self.f.clone(),
+            wrap_fn: self.wrap_fn.clone(),
-            r: PhantomData,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, F, R, In, Out, Err> ServiceFactory for ApplyServiceFactory<T, F, R, In, Out, Err>
+impl<SF, F, Fut, Req, In, Res, Err> ServiceFactory<Req>
+    for ApplyFactory<SF, F, Req, In, Res, Err>
 where
-    T: ServiceFactory<Error = Err>,
+    SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R + Clone,
+    F: FnMut(Req, &mut SF::Service) -> Fut + Clone,
-    R: Future<Output = Result<Out, Err>>,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    type Request = In;
+    type Response = Res;
-    type Response = Out;
     type Error = Err;
 
-    type Config = T::Config;
+    type Config = SF::Config;
-    type Service = Apply<T::Service, F, R, In, Out, Err>;
+    type Service = Apply<SF::Service, F, Req, In, Res, Err>;
-    type InitError = T::InitError;
+    type InitError = SF::InitError;
-    type Future = ApplyServiceFactoryResponse<T, F, R, In, Out, Err>;
+    type Future = ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>;
 
-    fn new_service(&self, cfg: T::Config) -> Self::Future {
+    fn new_service(&self, cfg: SF::Config) -> Self::Future {
-        ApplyServiceFactoryResponse::new(self.service.new_service(cfg), self.f.clone())
+        let svc = self.factory.new_service(cfg);
+        ApplyServiceFactoryResponse::new(svc, self.wrap_fn.clone())
     }
 }
 
-#[pin_project::pin_project]
+pin_project! {
-pub struct ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
+    pub struct ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>
-where
+    where
-    T: ServiceFactory<Error = Err>,
+        SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R,
+        F: FnMut(Req, &mut SF::Service) -> Fut,
-    R: Future<Output = Result<Out, Err>>,
+        Fut: Future<Output = Result<Res, Err>>,
-{
+    {
-    #[pin]
+        #[pin]
-    fut: T::Future,
+        fut: SF::Future,
-    f: Option<F>,
+        wrap_fn: Option<F>,
-    r: PhantomData<(In, Out)>,
+        _phantom: PhantomData<(Req, Res)>,
+    }
 }
 
-impl<T, F, R, In, Out, Err> ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
+impl<SF, F, Fut, Req, In, Res, Err> ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>
 where
-    T: ServiceFactory<Error = Err>,
+    SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R,
+    F: FnMut(Req, &mut SF::Service) -> Fut,
-    R: Future<Output = Result<Out, Err>>,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    fn new(fut: T::Future, f: F) -> Self {
+    fn new(fut: SF::Future, wrap_fn: F) -> Self {
         Self {
-            f: Some(f),
             fut,
-            r: PhantomData,
+            wrap_fn: Some(wrap_fn),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, F, R, In, Out, Err> Future for ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
+impl<SF, F, Fut, Req, In, Res, Err> Future
+    for ApplyServiceFactoryResponse<SF, F, Fut, Req, In, Res, Err>
 where
-    T: ServiceFactory<Error = Err>,
+    SF: ServiceFactory<In, Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R,
+    F: FnMut(Req, &mut SF::Service) -> Fut,
-    R: Future<Output = Result<Out, Err>>,
+    Fut: Future<Output = Result<Res, Err>>,
 {
-    type Output = Result<Apply<T::Service, F, R, In, Out, Err>, T::InitError>;
+    type Output = Result<Apply<SF::Service, F, Req, In, Res, Err>, SF::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
 
-        if let Poll::Ready(svc) = this.fut.poll(cx)? {
+        let svc = ready!(this.fut.poll(cx))?;
-            Poll::Ready(Ok(Apply::new(svc, this.f.take().unwrap())))
+        Poll::Ready(Ok(Apply::new(svc, this.wrap_fn.take().unwrap())))
-        } else {
-            Poll::Pending
-        }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use std::task::{Context, Poll};
+    use core::task::Poll;
 
-    use futures_util::future::{lazy, ok, Ready};
+    use futures_util::future::lazy;
 
     use super::*;
-    use crate::{pipeline, pipeline_factory, Service, ServiceFactory};
+    use crate::{ok, pipeline, pipeline_factory, Ready, Service, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv;
 
-    impl Service for Srv {
+    impl Service<()> for Srv {
-        type Request = ();
         type Response = ();
         type Error = ();
         type Future = Ready<Result<(), ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        crate::always_ready!();
-            Poll::Ready(Ok(()))
-        }
 
         fn call(&mut self, _: ()) -> Self::Future {
             ok(())

actix-service/src/apply_cfg.rs

@@ -1,227 +1,237 @@
-use std::cell::RefCell;
+use alloc::rc::Rc;
-use std::future::Future;
+use core::{
-use std::marker::PhantomData;
+    cell::RefCell,
-use std::pin::Pin;
+    future::Future,
-use std::rc::Rc;
+    marker::PhantomData,
-use std::task::{Context, Poll};
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use crate::{Service, ServiceFactory};
 
-/// Convert `Fn(Config, &mut Service1) -> Future<Service2>` fn to a service factory
+/// Convert `Fn(Config, &mut Service1) -> Future<Service2>` fn to a service factory.
-pub fn apply_cfg<F, C, T, R, S, E>(
+pub fn apply_cfg<S1, Req, F, Cfg, Fut, S2, Err>(
-    srv: T,
+    srv: S1,
     f: F,
 ) -> impl ServiceFactory<
-    Config = C,
+    Req,
-    Request = S::Request,
+    Config = Cfg,
-    Response = S::Response,
+    Response = S2::Response,
-    Error = S::Error,
+    Error = S2::Error,
-    Service = S,
+    Service = S2,
-    InitError = E,
+    InitError = Err,
-    Future = R,
+    Future = Fut,
 > + Clone
 where
-    F: FnMut(C, &mut T) -> R,
+    S1: Service<Req>,
-    T: Service,
+    F: FnMut(Cfg, &mut S1) -> Fut,
-    R: Future<Output = Result<S, E>>,
+    Fut: Future<Output = Result<S2, Err>>,
-    S: Service,
+    S2: Service<Req>,
 {
     ApplyConfigService {
         srv: Rc::new(RefCell::new((srv, f))),
-        _t: PhantomData,
+        _phantom: PhantomData,
     }
 }
 
-/// Convert `Fn(Config, &mut Service1) -> Future<Service2>` fn to a service factory
+/// Convert `Fn(Config, &mut ServiceFactory1) -> Future<ServiceFactory2>` fn to a service factory.
 ///
 /// Service1 get constructed from `T` factory.
-pub fn apply_cfg_factory<F, C, T, R, S>(
+pub fn apply_cfg_factory<SF, Req, F, Cfg, Fut, S>(
-    factory: T,
+    factory: SF,
     f: F,
 ) -> impl ServiceFactory<
-    Config = C,
+    Req,
-    Request = S::Request,
+    Config = Cfg,
     Response = S::Response,
     Error = S::Error,
     Service = S,
-    InitError = T::InitError,
+    InitError = SF::InitError,
 > + Clone
 where
-    F: FnMut(C, &mut T::Service) -> R,
+    SF: ServiceFactory<Req, Config = ()>,
-    T: ServiceFactory<Config = ()>,
+    F: FnMut(Cfg, &mut SF::Service) -> Fut,
-    T::InitError: From<T::Error>,
+    SF::InitError: From<SF::Error>,
-    R: Future<Output = Result<S, T::InitError>>,
+    Fut: Future<Output = Result<S, SF::InitError>>,
-    S: Service,
+    S: Service<Req>,
 {
     ApplyConfigServiceFactory {
         srv: Rc::new(RefCell::new((factory, f))),
-        _t: PhantomData,
+        _phantom: PhantomData,
     }
 }
 
 /// Convert `Fn(Config, &mut Server) -> Future<Service>` fn to NewService\
-struct ApplyConfigService<F, C, T, R, S, E>
+struct ApplyConfigService<S1, Req, F, Cfg, Fut, S2, Err>
 where
-    F: FnMut(C, &mut T) -> R,
+    S1: Service<Req>,
-    T: Service,
+    F: FnMut(Cfg, &mut S1) -> Fut,
-    R: Future<Output = Result<S, E>>,
+    Fut: Future<Output = Result<S2, Err>>,
-    S: Service,
+    S2: Service<Req>,
 {
-    srv: Rc<RefCell<(T, F)>>,
+    srv: Rc<RefCell<(S1, F)>>,
-    _t: PhantomData<(C, R, S)>,
+    _phantom: PhantomData<(Cfg, Req, Fut, S2)>,
 }
 
-impl<F, C, T, R, S, E> Clone for ApplyConfigService<F, C, T, R, S, E>
+impl<S1, Req, F, Cfg, Fut, S2, Err> Clone for ApplyConfigService<S1, Req, F, Cfg, Fut, S2, Err>
 where
-    F: FnMut(C, &mut T) -> R,
+    S1: Service<Req>,
-    T: Service,
+    F: FnMut(Cfg, &mut S1) -> Fut,
-    R: Future<Output = Result<S, E>>,
+    Fut: Future<Output = Result<S2, Err>>,
-    S: Service,
+    S2: Service<Req>,
 {
     fn clone(&self) -> Self {
         ApplyConfigService {
             srv: self.srv.clone(),
-            _t: PhantomData,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<F, C, T, R, S, E> ServiceFactory for ApplyConfigService<F, C, T, R, S, E>
+impl<S1, Req, F, Cfg, Fut, S2, Err> ServiceFactory<Req>
+    for ApplyConfigService<S1, Req, F, Cfg, Fut, S2, Err>
 where
-    F: FnMut(C, &mut T) -> R,
+    S1: Service<Req>,
-    T: Service,
+    F: FnMut(Cfg, &mut S1) -> Fut,
-    R: Future<Output = Result<S, E>>,
+    Fut: Future<Output = Result<S2, Err>>,
-    S: Service,
+    S2: Service<Req>,
 {
-    type Config = C;
+    type Config = Cfg;
-    type Request = S::Request;
+    type Response = S2::Response;
-    type Response = S::Response;
+    type Error = S2::Error;
-    type Error = S::Error;
+    type Service = S2;
-    type Service = S;
 
-    type InitError = E;
+    type InitError = Err;
-    type Future = R;
+    type Future = Fut;
 
-    fn new_service(&self, cfg: C) -> Self::Future {
+    fn new_service(&self, cfg: Cfg) -> Self::Future {
         let (t, f) = &mut *self.srv.borrow_mut();
         f(cfg, t)
     }
 }
 
 /// Convert `Fn(&Config) -> Future<Service>` fn to NewService
-struct ApplyConfigServiceFactory<F, C, T, R, S>
+struct ApplyConfigServiceFactory<SF, Req, F, Cfg, Fut, S>
 where
-    F: FnMut(C, &mut T::Service) -> R,
+    SF: ServiceFactory<Req, Config = ()>,
-    T: ServiceFactory<Config = ()>,
+    F: FnMut(Cfg, &mut SF::Service) -> Fut,
-    R: Future<Output = Result<S, T::InitError>>,
+    Fut: Future<Output = Result<S, SF::InitError>>,
-    S: Service,
+    S: Service<Req>,
 {
-    srv: Rc<RefCell<(T, F)>>,
+    srv: Rc<RefCell<(SF, F)>>,
-    _t: PhantomData<(C, R, S)>,
+    _phantom: PhantomData<(Cfg, Req, Fut, S)>,
 }
 
-impl<F, C, T, R, S> Clone for ApplyConfigServiceFactory<F, C, T, R, S>
+impl<SF, Req, F, Cfg, Fut, S> Clone for ApplyConfigServiceFactory<SF, Req, F, Cfg, Fut, S>
 where
-    F: FnMut(C, &mut T::Service) -> R,
+    SF: ServiceFactory<Req, Config = ()>,
-    T: ServiceFactory<Config = ()>,
+    F: FnMut(Cfg, &mut SF::Service) -> Fut,
-    R: Future<Output = Result<S, T::InitError>>,
+    Fut: Future<Output = Result<S, SF::InitError>>,
-    S: Service,
+    S: Service<Req>,
 {
     fn clone(&self) -> Self {
         Self {
             srv: self.srv.clone(),
-            _t: PhantomData,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<F, C, T, R, S> ServiceFactory for ApplyConfigServiceFactory<F, C, T, R, S>
+impl<SF, Req, F, Cfg, Fut, S> ServiceFactory<Req>
+    for ApplyConfigServiceFactory<SF, Req, F, Cfg, Fut, S>
 where
-    F: FnMut(C, &mut T::Service) -> R,
+    SF: ServiceFactory<Req, Config = ()>,
-    T: ServiceFactory<Config = ()>,
+    SF::InitError: From<SF::Error>,
-    T::InitError: From<T::Error>,
+    F: FnMut(Cfg, &mut SF::Service) -> Fut,
-    R: Future<Output = Result<S, T::InitError>>,
+    Fut: Future<Output = Result<S, SF::InitError>>,
-    S: Service,
+    S: Service<Req>,
 {
-    type Config = C;
+    type Config = Cfg;
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Service = S;
 
-    type InitError = T::InitError;
+    type InitError = SF::InitError;
-    type Future = ApplyConfigServiceFactoryResponse<F, C, T, R, S>;
+    type Future = ApplyConfigServiceFactoryResponse<SF, Req, F, Cfg, Fut, S>;
 
-    fn new_service(&self, cfg: C) -> Self::Future {
+    fn new_service(&self, cfg: Cfg) -> Self::Future {
         ApplyConfigServiceFactoryResponse {
             cfg: Some(cfg),
             store: self.srv.clone(),
-            state: State::A(self.srv.borrow().0.new_service(())),
+            state: State::A {
+                fut: self.srv.borrow().0.new_service(()),
+            },
         }
     }
 }
 
-#[pin_project::pin_project]
+pin_project! {
-struct ApplyConfigServiceFactoryResponse<F, C, T, R, S>
+    struct ApplyConfigServiceFactoryResponse<SF, Req, F, Cfg, Fut, S>
-where
+    where
-    F: FnMut(C, &mut T::Service) -> R,
+        SF: ServiceFactory<Req, Config = ()>,
-    T: ServiceFactory<Config = ()>,
+        SF::InitError: From<SF::Error>,
-    T::InitError: From<T::Error>,
+        F: FnMut(Cfg, &mut SF::Service) -> Fut,
-    R: Future<Output = Result<S, T::InitError>>,
+        Fut: Future<Output = Result<S, SF::InitError>>,
-    S: Service,
+        S: Service<Req>,
-{
+    {
-    cfg: Option<C>,
+        cfg: Option<Cfg>,
-    store: Rc<RefCell<(T, F)>>,
+        store: Rc<RefCell<(SF, F)>>,
-    #[pin]
+        #[pin]
-    state: State<T, R, S>,
+        state: State<SF, Fut, S, Req>,
+    }
 }
 
-#[pin_project::pin_project(project = StateProj)]
+pin_project! {
-enum State<T, R, S>
+    #[project = StateProj]
-where
+    enum State<SF, Fut, S, Req>
-    T: ServiceFactory<Config = ()>,
+    where
-    T::InitError: From<T::Error>,
+        SF: ServiceFactory<Req, Config = ()>,
-    R: Future<Output = Result<S, T::InitError>>,
+        SF::InitError: From<SF::Error>,
-    S: Service,
+        Fut: Future<Output = Result<S, SF::InitError>>,
-{
+        S: Service<Req>,
-    A(#[pin] T::Future),
+    {
-    B(T::Service),
+        A { #[pin] fut: SF::Future },
-    C(#[pin] R),
+        B { svc: SF::Service },
+        C { #[pin] fut: Fut },
+    }
 }
 
-impl<F, C, T, R, S> Future for ApplyConfigServiceFactoryResponse<F, C, T, R, S>
+impl<SF, Req, F, Cfg, Fut, S> Future
+    for ApplyConfigServiceFactoryResponse<SF, Req, F, Cfg, Fut, S>
 where
-    F: FnMut(C, &mut T::Service) -> R,
+    SF: ServiceFactory<Req, Config = ()>,
-    T: ServiceFactory<Config = ()>,
+    SF::InitError: From<SF::Error>,
-    T::InitError: From<T::Error>,
+    F: FnMut(Cfg, &mut SF::Service) -> Fut,
-    R: Future<Output = Result<S, T::InitError>>,
+    Fut: Future<Output = Result<S, SF::InitError>>,
-    S: Service,
+    S: Service<Req>,
 {
-    type Output = Result<S, T::InitError>;
+    type Output = Result<S, SF::InitError>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.as_mut().project();
 
         match this.state.as_mut().project() {
-            StateProj::A(fut) => match fut.poll(cx)? {
+            StateProj::A { fut } => match fut.poll(cx)? {
                 Poll::Pending => Poll::Pending,
-                Poll::Ready(srv) => {
+                Poll::Ready(svc) => {
-                    this.state.set(State::B(srv));
+                    this.state.set(State::B { svc });
                     self.poll(cx)
                 }
             },
-            StateProj::B(srv) => match srv.poll_ready(cx)? {
+            StateProj::B { svc } => match svc.poll_ready(cx)? {
                 Poll::Ready(_) => {
                     {
                         let (_, f) = &mut *this.store.borrow_mut();
-                        let fut = f(this.cfg.take().unwrap(), srv);
+                        let fut = f(this.cfg.take().unwrap(), svc);
-                        this.state.set(State::C(fut));
+                        this.state.set(State::C { fut });
                     }
                     self.poll(cx)
                 }
                 Poll::Pending => Poll::Pending,
             },
-            StateProj::C(fut) => fut.poll(cx),
+            StateProj::C { fut } => fut.poll(cx),
         }
     }
 }

actix-service/src/boxed.rs

@@ -1,145 +1,141 @@
-use std::future::Future;
+use alloc::boxed::Box;
-use std::pin::Pin;
+use core::{
-use std::task::{Context, Poll};
+    future::Future,
-
+    marker::PhantomData,
-use futures_util::future::FutureExt;
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 use crate::{Service, ServiceFactory};
 
-pub type BoxFuture<I, E> = Pin<Box<dyn Future<Output = Result<I, E>>>>;
+pub type BoxFuture<T> = Pin<Box<dyn Future<Output = T>>>;
 
 pub type BoxService<Req, Res, Err> =
-    Box<dyn Service<Request = Req, Response = Res, Error = Err, Future = BoxFuture<Res, Err>>>;
+    Box<dyn Service<Req, Response = Res, Error = Err, Future = BoxFuture<Result<Res, Err>>>>;
 
-pub struct BoxServiceFactory<C, Req, Res, Err, InitErr>(Inner<C, Req, Res, Err, InitErr>);
+pub struct BoxServiceFactory<Cfg, Req, Res, Err, InitErr>(Inner<Cfg, Req, Res, Err, InitErr>);
 
 /// Create boxed service factory
-pub fn factory<T>(
+pub fn factory<SF, Req>(
-    factory: T,
+    factory: SF,
-) -> BoxServiceFactory<T::Config, T::Request, T::Response, T::Error, T::InitError>
+) -> BoxServiceFactory<SF::Config, Req, SF::Response, SF::Error, SF::InitError>
 where
-    T: ServiceFactory + 'static,
+    SF: ServiceFactory<Req> + 'static,
-    T::Request: 'static,
+    Req: 'static,
-    T::Response: 'static,
+    SF::Response: 'static,
-    T::Service: 'static,
+    SF::Service: 'static,
-    T::Future: 'static,
+    SF::Future: 'static,
-    T::Error: 'static,
+    SF::Error: 'static,
-    T::InitError: 'static,
+    SF::InitError: 'static,
 {
     BoxServiceFactory(Box::new(FactoryWrapper {
         factory,
-        _t: std::marker::PhantomData,
+        _t: PhantomData,
     }))
 }
 
 /// Create boxed service
-pub fn service<T>(service: T) -> BoxService<T::Request, T::Response, T::Error>
+pub fn service<S, Req>(service: S) -> BoxService<Req, S::Response, S::Error>
 where
-    T: Service + 'static,
+    S: Service<Req> + 'static,
-    T::Future: 'static,
+    Req: 'static,
+    S::Future: 'static,
 {
-    Box::new(ServiceWrapper(service))
+    Box::new(ServiceWrapper(service, PhantomData))
 }
 
 type Inner<C, Req, Res, Err, InitErr> = Box<
     dyn ServiceFactory<
+        Req,
         Config = C,
-        Request = Req,
         Response = Res,
         Error = Err,
         InitError = InitErr,
         Service = BoxService<Req, Res, Err>,
-        Future = BoxFuture<BoxService<Req, Res, Err>, InitErr>,
+        Future = BoxFuture<Result<BoxService<Req, Res, Err>, InitErr>>,
     >,
 >;
 
-impl<C, Req, Res, Err, InitErr> ServiceFactory for BoxServiceFactory<C, Req, Res, Err, InitErr>
+impl<C, Req, Res, Err, InitErr> ServiceFactory<Req>
+    for BoxServiceFactory<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 Config = C;
     type Service = BoxService<Req, Res, Err>;
 
-    type Future = BoxFuture<Self::Service, InitErr>;
+    type Future = BoxFuture<Result<Self::Service, InitErr>>;
 
     fn new_service(&self, cfg: C) -> Self::Future {
         self.0.new_service(cfg)
     }
 }
 
-struct FactoryWrapper<C, T: ServiceFactory> {
+struct FactoryWrapper<SF, Req, Cfg> {
-    factory: T,
+    factory: SF,
-    _t: std::marker::PhantomData<C>,
+    _t: PhantomData<(Req, Cfg)>,
 }
 
-impl<C, T, Req, Res, Err, InitErr> ServiceFactory for FactoryWrapper<C, T>
+impl<SF, Req, Cfg, Res, Err, InitErr> ServiceFactory<Req> for FactoryWrapper<SF, Req, Cfg>
 where
     Req: 'static,
     Res: 'static,
     Err: 'static,
     InitErr: 'static,
-    T: ServiceFactory<
+    SF: ServiceFactory<Req, Config = Cfg, Response = Res, Error = Err, InitError = InitErr>,
-        Config = C,
+    SF::Future: 'static,
-        Request = Req,
+    SF::Service: 'static,
-        Response = Res,
+    <SF::Service as Service<Req>>::Future: 'static,
-        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 Config = C;
+    type Config = Cfg;
     type Service = BoxService<Req, Res, Err>;
-    type Future = BoxFuture<Self::Service, Self::InitError>;
+    type Future = BoxFuture<Result<Self::Service, Self::InitError>>;
 
-    fn new_service(&self, cfg: C) -> Self::Future {
+    fn new_service(&self, cfg: Cfg) -> Self::Future {
-        Box::pin(
+        let fut = self.factory.new_service(cfg);
-            self.factory
+        Box::pin(async {
-                .new_service(cfg)
+            let res = fut.await;
-                .map(|res| res.map(ServiceWrapper::boxed)),
+            res.map(ServiceWrapper::boxed)
-        )
+        })
     }
 }
 
-struct ServiceWrapper<T: Service>(T);
+struct ServiceWrapper<S: Service<Req>, Req>(S, PhantomData<Req>);
 
-impl<T> ServiceWrapper<T>
+impl<S, Req> ServiceWrapper<S, Req>
 where
-    T: Service + 'static,
+    S: Service<Req> + 'static,
-    T::Future: 'static,
+    Req: 'static,
+    S::Future: 'static,
 {
-    fn boxed(service: T) -> BoxService<T::Request, T::Response, T::Error> {
+    fn boxed(service: S) -> BoxService<Req, S::Response, S::Error> {
-        Box::new(ServiceWrapper(service))
+        Box::new(ServiceWrapper(service, PhantomData))
     }
 }
 
-impl<T, Req, Res, Err> Service for ServiceWrapper<T>
+impl<S, Req, Res, Err> Service<Req> for ServiceWrapper<S, Req>
 where
-    T: Service<Request = Req, Response = Res, Error = Err>,
+    S: Service<Req, Response = Res, Error = Err>,
-    T::Future: 'static,
+    S::Future: 'static,
 {
-    type Request = Req;
     type Response = Res;
     type Error = Err;
-    type Future = BoxFuture<Res, Err>;
+    type Future = BoxFuture<Result<Res, Err>>;
 
     fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.0.poll_ready(ctx)
     }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         Box::pin(self.0.call(req))
     }
 }

actix-service/src/ext.rs

@@ -0,0 +1,70 @@
+use crate::{dev, Service, ServiceFactory};
+
+pub trait ServiceExt<Req>: Service<Req> {
+    /// Map this service's output to a different type, returning a new service
+    /// of the resulting type.
+    ///
+    /// This function is similar to the `Option::map` or `Iterator::map` where
+    /// it will change the type of the underlying service.
+    ///
+    /// Note that this function consumes the receiving service and returns a
+    /// wrapped version of it, similar to the existing `map` methods in the
+    /// standard library.
+    fn map<F, R>(self, f: F) -> dev::Map<Self, F, Req, R>
+    where
+        Self: Sized,
+        F: FnMut(Self::Response) -> R,
+    {
+        dev::Map::new(self, f)
+    }
+
+    /// Map this service's error to a different error, returning a new service.
+    ///
+    /// This function is similar to the `Result::map_err` where it will change
+    /// the error type of the underlying service. For example, this can be useful to
+    /// ensure that services have the same error type.
+    ///
+    /// Note that this function consumes the receiving service and returns a
+    /// wrapped version of it.
+    fn map_err<F, E>(self, f: F) -> dev::MapErr<Self, Req, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::Error) -> E,
+    {
+        dev::MapErr::new(self, f)
+    }
+}
+
+impl<S, Req> ServiceExt<Req> for S where S: Service<Req> {}
+
+pub trait ServiceFactoryExt<Req>: ServiceFactory<Req> {
+    /// Map this service's output to a different type, returning a new service
+    /// of the resulting type.
+    fn map<F, R>(self, f: F) -> crate::map::MapServiceFactory<Self, F, Req, R>
+    where
+        Self: Sized,
+        F: FnMut(Self::Response) -> R + Clone,
+    {
+        crate::map::MapServiceFactory::new(self, f)
+    }
+
+    /// Map this service's error to a different error, returning a new service.
+    fn map_err<F, E>(self, f: F) -> crate::map_err::MapErrServiceFactory<Self, Req, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::Error) -> E + Clone,
+    {
+        crate::map_err::MapErrServiceFactory::new(self, f)
+    }
+
+    /// Map this factory's init error to a different error, returning a new service.
+    fn map_init_err<F, E>(self, f: F) -> crate::map_init_err::MapInitErr<Self, F, Req, E>
+    where
+        Self: Sized,
+        F: Fn(Self::InitError) -> E + Clone,
+    {
+        crate::map_init_err::MapInitErr::new(self, f)
+    }
+}
+
+impl<S, Req> ServiceFactoryExt<Req> for S where S: ServiceFactory<Req> {}

actix-service/src/fn_service.rs

@@ -1,10 +1,6 @@
-use std::future::Future;
+use core::{future::Future, marker::PhantomData, task::Poll};
-use std::marker::PhantomData;
-use std::task::{Context, Poll};
 
-use futures_util::future::{ok, Ready};
+use crate::{ok, IntoService, IntoServiceFactory, Ready, Service, ServiceFactory};
-
-use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
 /// Create `ServiceFactory` for function that can act as a `Service`
 pub fn fn_service<F, Fut, Req, Res, Err, Cfg>(
@@ -53,9 +49,11 @@ where
 ///     Ok(())
 /// }
 /// ```
-pub fn fn_factory<F, Cfg, Srv, Fut, Err>(f: F) -> FnServiceNoConfig<F, Cfg, Srv, Fut, Err>
+pub fn fn_factory<F, Cfg, Srv, Req, Fut, Err>(
+    f: F,
+) -> FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    Srv: Service,
+    Srv: Service<Req>,
     F: Fn() -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
 {
@@ -92,13 +90,13 @@ where
 ///     Ok(())
 /// }
 /// ```
-pub fn fn_factory_with_config<F, Fut, Cfg, Srv, Err>(
+pub fn fn_factory_with_config<F, Fut, Cfg, Srv, Req, Err>(
     f: F,
-) -> FnServiceConfig<F, Fut, Cfg, Srv, Err>
+) -> FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
     FnServiceConfig::new(f)
 }
@@ -132,26 +130,23 @@ where
     }
 }
 
-impl<F, Fut, Req, Res, Err> Service for FnService<F, Fut, Req, Res, Err>
+impl<F, Fut, Req, Res, Err> Service<Req> for FnService<F, Fut, Req, Res, Err>
 where
     F: FnMut(Req) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
 {
-    type Request = Req;
     type Response = Res;
     type Error = Err;
     type Future = Fut;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    crate::always_ready!();
-        Poll::Ready(Ok(()))
-    }
 
     fn call(&mut self, req: Req) -> Self::Future {
         (self.f)(req)
     }
 }
 
-impl<F, Fut, Req, Res, Err> IntoService<FnService<F, Fut, Req, Res, Err>> for F
+impl<F, Fut, Req, Res, Err> IntoService<FnService<F, Fut, Req, Res, Err>, Req> for F
 where
     F: FnMut(Req) -> Fut,
     Fut: Future<Output = Result<Res, Err>>,
@@ -190,31 +185,28 @@ where
     }
 }
 
-impl<F, Fut, Req, Res, Err> Service for FnServiceFactory<F, Fut, Req, Res, Err, ()>
+impl<F, Fut, Req, Res, Err> Service<Req> for FnServiceFactory<F, Fut, Req, Res, Err, ()>
 where
     F: FnMut(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
-    type Request = Req;
     type Response = Res;
     type Error = Err;
     type Future = Fut;
 
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    crate::always_ready!();
-        Poll::Ready(Ok(()))
-    }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         (self.f)(req)
     }
 }
 
-impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
+impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory<Req>
+    for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
     F: FnMut(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
 {
-    type Request = Req;
     type Response = Res;
     type Error = Err;
 
@@ -229,7 +221,7 @@ where
 }
 
 impl<F, Fut, Req, Res, Err, Cfg>
-    IntoServiceFactory<FnServiceFactory<F, Fut, Req, Res, Err, Cfg>> for F
+    IntoServiceFactory<FnServiceFactory<F, Fut, Req, Res, Err, Cfg>, Req> for F
 where
     F: Fn(Req) -> Fut + Clone,
     Fut: Future<Output = Result<Res, Err>>,
@@ -240,32 +232,32 @@ where
 }
 
 /// Convert `Fn(&Config) -> Future<Service>` fn to NewService
-pub struct FnServiceConfig<F, Fut, Cfg, Srv, Err>
+pub struct FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
     f: F,
-    _t: PhantomData<(Fut, Cfg, Srv, Err)>,
+    _t: PhantomData<(Fut, Cfg, Req, Srv, Err)>,
 }
 
-impl<F, Fut, Cfg, Srv, Err> FnServiceConfig<F, Fut, Cfg, Srv, Err>
+impl<F, Fut, Cfg, Srv, Req, Err> FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
     fn new(f: F) -> Self {
         FnServiceConfig { f, _t: PhantomData }
     }
 }
 
-impl<F, Fut, Cfg, Srv, Err> Clone for FnServiceConfig<F, Fut, Cfg, Srv, Err>
+impl<F, Fut, Cfg, Srv, Req, Err> Clone for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut + Clone,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
     fn clone(&self) -> Self {
         FnServiceConfig {
@@ -275,13 +267,13 @@ where
     }
 }
 
-impl<F, Fut, Cfg, Srv, Err> ServiceFactory for FnServiceConfig<F, Fut, Cfg, Srv, Err>
+impl<F, Fut, Cfg, Srv, Req, Err> ServiceFactory<Req>
+    for FnServiceConfig<F, Fut, Cfg, Srv, Req, Err>
 where
     F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
-    Srv: Service,
+    Srv: Service<Req>,
 {
-    type Request = Srv::Request;
     type Response = Srv::Response;
     type Error = Srv::Error;
 
@@ -296,76 +288,77 @@ where
 }
 
 /// Converter for `Fn() -> Future<Service>` fn
-pub struct FnServiceNoConfig<F, C, S, R, E>
+pub struct FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    F: Fn() -> R,
+    F: Fn() -> Fut,
-    S: Service,
+    Srv: Service<Req>,
-    R: Future<Output = Result<S, E>>,
+    Fut: Future<Output = Result<Srv, Err>>,
 {
     f: F,
-    _t: PhantomData<C>,
+    _t: PhantomData<(Cfg, Req)>,
 }
 
-impl<F, C, S, R, E> FnServiceNoConfig<F, C, S, R, E>
+impl<F, Cfg, Srv, Req, Fut, Err> FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    F: Fn() -> R,
+    F: Fn() -> Fut,
-    R: Future<Output = Result<S, E>>,
+    Fut: Future<Output = Result<Srv, Err>>,
-    S: Service,
+    Srv: Service<Req>,
 {
     fn new(f: F) -> Self {
         Self { f, _t: PhantomData }
     }
 }
 
-impl<F, C, S, R, E> ServiceFactory for FnServiceNoConfig<F, C, S, R, E>
+impl<F, Cfg, Srv, Req, Fut, Err> ServiceFactory<Req>
+    for FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    F: Fn() -> R,
+    F: Fn() -> Fut,
-    R: Future<Output = Result<S, E>>,
+    Fut: Future<Output = Result<Srv, Err>>,
-    S: Service,
+    Srv: Service<Req>,
 {
-    type Request = S::Request;
+    type Response = Srv::Response;
-    type Response = S::Response;
+    type Error = Srv::Error;
-    type Error = S::Error;
+    type Service = Srv;
-    type Service = S;
+    type Config = Cfg;
-    type Config = C;
+    type InitError = Err;
-    type InitError = E;
+    type Future = Fut;
-    type Future = R;
 
-    fn new_service(&self, _: C) -> Self::Future {
+    fn new_service(&self, _: Cfg) -> Self::Future {
         (self.f)()
     }
 }
 
-impl<F, C, S, R, E> Clone for FnServiceNoConfig<F, C, S, R, E>
+impl<F, Cfg, Srv, Req, Fut, Err> Clone for FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>
 where
-    F: Fn() -> R + Clone,
+    F: Fn() -> Fut + Clone,
-    R: Future<Output = Result<S, E>>,
+    Fut: Future<Output = Result<Srv, Err>>,
-    S: Service,
+    Srv: Service<Req>,
 {
     fn clone(&self) -> Self {
         Self::new(self.f.clone())
     }
 }
 
-impl<F, C, S, R, E> IntoServiceFactory<FnServiceNoConfig<F, C, S, R, E>> for F
+impl<F, Cfg, Srv, Req, Fut, Err>
+    IntoServiceFactory<FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err>, Req> for F
 where
-    F: Fn() -> R,
+    F: Fn() -> Fut,
-    R: Future<Output = Result<S, E>>,
+    Fut: Future<Output = Result<Srv, Err>>,
-    S: Service,
+    Srv: Service<Req>,
 {
-    fn into_factory(self) -> FnServiceNoConfig<F, C, S, R, E> {
+    fn into_factory(self) -> FnServiceNoConfig<F, Cfg, Srv, Req, Fut, Err> {
         FnServiceNoConfig::new(self)
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use std::task::Poll;
+    use core::task::Poll;
 
-    use futures_util::future::{lazy, ok};
+    use futures_util::future::lazy;
 
     use super::*;
-    use crate::{Service, ServiceFactory};
+    use crate::{ok, Service, ServiceFactory};
 
     #[actix_rt::test]
     async fn test_fn_service() {

actix-service/src/lib.rs

@@ -1,36 +1,47 @@
-//! See [`Service`](trait.Service.html) docs for information on this crate's foundational trait.
+//! See [`Service`] docs for information on this crate's foundational trait.
 
-#![deny(rust_2018_idioms, warnings)]
+#![no_std]
+#![deny(rust_2018_idioms, nonstandard_style)]
 #![allow(clippy::type_complexity)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
-use std::cell::RefCell;
+extern crate alloc;
-use std::future::Future;
+
-use std::rc::Rc;
+use alloc::{boxed::Box, rc::Rc, sync::Arc};
-use std::sync::Arc;
+use core::{
-use std::task::{self, Context, Poll};
+    cell::RefCell,
+    future::Future,
+    task::{self, Context, Poll},
+};
 
 mod and_then;
-mod and_then_apply_fn;
 mod apply;
 mod apply_cfg;
 pub mod boxed;
+mod ext;
 mod fn_service;
 mod map;
 mod map_config;
 mod map_err;
 mod map_init_err;
 mod pipeline;
+mod ready;
 mod then;
 mod transform;
 mod transform_err;
 
 pub use self::apply::{apply_fn, apply_fn_factory};
 pub use self::apply_cfg::{apply_cfg, apply_cfg_factory};
+pub use self::ext::{ServiceExt, ServiceFactoryExt};
 pub use self::fn_service::{fn_factory, fn_factory_with_config, fn_service};
 pub use self::map_config::{map_config, unit_config};
 pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory};
 pub use self::transform::{apply, Transform};
 
+#[allow(unused_imports)]
+use self::ready::{err, ok, ready, Ready};
+
 /// An asynchronous operation from `Request` to a `Response`.
 ///
 /// The `Service` trait models a request/response interaction, receiving requests and returning
@@ -65,19 +76,16 @@ pub use self::transform::{apply, Transform};
 /// ```
 ///
 /// Sometimes it is not necessary to implement the Service trait. For example, the above service
-/// could be rewritten as a simple function and passed to [fn_service](fn.fn_service.html).
+/// could be rewritten as a simple function and passed to [fn_service](fn_service()).
 ///
 /// ```rust,ignore
 /// async fn my_service(req: u8) -> Result<u64, MyError>;
 /// ```
-pub trait Service {
+pub trait Service<Req> {
-    /// Requests handled by the service.
-    type Request;
-
     /// Responses given by the service.
     type Response;
 
-    /// Errors produced by the service.
+    /// Errors produced by the service when polling readiness or executing call.
     type Error;
 
     /// The future response value.
@@ -107,40 +115,7 @@ pub trait Service {
     ///
     /// Calling `call` without calling `poll_ready` is permitted. The
     /// implementation must be resilient to this fact.
-    fn call(&mut self, req: Self::Request) -> Self::Future;
+    fn call(&mut self, req: Req) -> Self::Future;
-
-    /// Map this service's output to a different type, returning a new service
-    /// of the resulting type.
-    ///
-    /// This function is similar to the `Option::map` or `Iterator::map` where
-    /// it will change the type of the underlying service.
-    ///
-    /// Note that this function consumes the receiving service and returns a
-    /// wrapped version of it, similar to the existing `map` methods in the
-    /// standard library.
-    fn map<F, R>(self, f: F) -> crate::dev::Map<Self, F, R>
-    where
-        Self: Sized,
-        F: FnMut(Self::Response) -> R,
-    {
-        crate::dev::Map::new(self, f)
-    }
-
-    /// Map this service's error to a different error, returning a new service.
-    ///
-    /// This function is similar to the `Result::map_err` where it will change
-    /// the error type of the underlying service. For example, this can be useful to
-    /// ensure that services have the same error type.
-    ///
-    /// Note that this function consumes the receiving service and returns a
-    /// wrapped version of it.
-    fn map_err<F, E>(self, f: F) -> crate::dev::MapErr<Self, F, E>
-    where
-        Self: Sized,
-        F: Fn(Self::Error) -> E,
-    {
-        crate::dev::MapErr::new(self, f)
-    }
 }
 
 /// Factory for creating `Service`s.
@@ -152,10 +127,7 @@ pub trait Service {
 /// requests on that new TCP stream.
 ///
 /// `Config` is a service factory configuration type.
-pub trait ServiceFactory {
+pub trait ServiceFactory<Req> {
-    /// Requests handled by the created services.
-    type Request;
-
     /// Responses given by the created services.
     type Response;
 
@@ -166,11 +138,7 @@ pub trait ServiceFactory {
     type Config;
 
     /// The kind of `Service` created by this factory.
-    type Service: Service<
+    type Service: Service<Req, Response = Self::Response, Error = Self::Error>;
-        Request = Self::Request,
-        Response = Self::Response,
-        Error = Self::Error,
-    >;
 
     /// Errors potentially raised while building a service.
     type InitError;
@@ -180,41 +148,12 @@ pub trait ServiceFactory {
 
     /// Create and return a new service asynchronously.
     fn new_service(&self, cfg: Self::Config) -> Self::Future;
-
-    /// Map this service's output to a different type, returning a new service
-    /// of the resulting type.
-    fn map<F, R>(self, f: F) -> crate::map::MapServiceFactory<Self, F, R>
-    where
-        Self: Sized,
-        F: FnMut(Self::Response) -> R + Clone,
-    {
-        crate::map::MapServiceFactory::new(self, f)
-    }
-
-    /// Map this service's error to a different error, returning a new service.
-    fn map_err<F, E>(self, f: F) -> crate::map_err::MapErrServiceFactory<Self, F, E>
-    where
-        Self: Sized,
-        F: Fn(Self::Error) -> E + Clone,
-    {
-        crate::map_err::MapErrServiceFactory::new(self, f)
-    }
-
-    /// Map this factory's init error to a different error, returning a new service.
-    fn map_init_err<F, E>(self, f: F) -> crate::map_init_err::MapInitErr<Self, F, E>
-    where
-        Self: Sized,
-        F: Fn(Self::InitError) -> E + Clone,
-    {
-        crate::map_init_err::MapInitErr::new(self, f)
-    }
 }
 
-impl<'a, S> Service for &'a mut S
+impl<'a, S, Req> Service<Req> for &'a mut S
 where
-    S: Service + 'a,
+    S: Service<Req> + 'a,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -223,16 +162,15 @@ where
         (**self).poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Self::Request) -> S::Future {
+    fn call(&mut self, request: Req) -> S::Future {
         (**self).call(request)
     }
 }
 
-impl<S> Service for Box<S>
+impl<S, Req> Service<Req> for Box<S>
 where
-    S: Service + ?Sized,
+    S: Service<Req> + ?Sized,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -241,16 +179,15 @@ where
         (**self).poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Self::Request) -> S::Future {
+    fn call(&mut self, request: Req) -> S::Future {
         (**self).call(request)
     }
 }
 
-impl<S> Service for RefCell<S>
+impl<S, Req> Service<Req> for RefCell<S>
 where
-    S: Service,
+    S: Service<Req>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -259,16 +196,15 @@ where
         self.borrow_mut().poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Self::Request) -> S::Future {
+    fn call(&mut self, request: Req) -> S::Future {
         self.borrow_mut().call(request)
     }
 }
 
-impl<S> Service for Rc<RefCell<S>>
+impl<S, Req> Service<Req> for Rc<RefCell<S>>
 where
-    S: Service,
+    S: Service<Req>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = S::Future;
@@ -277,16 +213,15 @@ where
         self.borrow_mut().poll_ready(ctx)
     }
 
-    fn call(&mut self, request: Self::Request) -> S::Future {
+    fn call(&mut self, request: Req) -> S::Future {
         (&mut (**self).borrow_mut()).call(request)
     }
 }
 
-impl<S> ServiceFactory for Rc<S>
+impl<S, Req> ServiceFactory<Req> for Rc<S>
 where
-    S: ServiceFactory,
+    S: ServiceFactory<Req>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Config = S::Config;
@@ -299,11 +234,10 @@ where
     }
 }
 
-impl<S> ServiceFactory for Arc<S>
+impl<S, Req> ServiceFactory<Req> for Arc<S>
 where
-    S: ServiceFactory,
+    S: ServiceFactory<Req>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Config = S::Config;
@@ -317,52 +251,52 @@ where
 }
 
 /// Trait for types that can be converted to a `Service`
-pub trait IntoService<T>
+pub trait IntoService<S, Req>
 where
-    T: Service,
+    S: Service<Req>,
 {
     /// Convert to a `Service`
-    fn into_service(self) -> T;
+    fn into_service(self) -> S;
 }
 
 /// Trait for types that can be converted to a `ServiceFactory`
-pub trait IntoServiceFactory<T>
+pub trait IntoServiceFactory<SF, Req>
 where
-    T: ServiceFactory,
+    SF: ServiceFactory<Req>,
 {
     /// Convert `Self` to a `ServiceFactory`
-    fn into_factory(self) -> T;
+    fn into_factory(self) -> SF;
 }
 
-impl<T> IntoService<T> for T
+impl<S, Req> IntoService<S, Req> for S
 where
-    T: Service,
+    S: Service<Req>,
 {
-    fn into_service(self) -> T {
+    fn into_service(self) -> S {
         self
     }
 }
 
-impl<T> IntoServiceFactory<T> for T
+impl<SF, Req> IntoServiceFactory<SF, Req> for SF
 where
-    T: ServiceFactory,
+    SF: ServiceFactory<Req>,
 {
-    fn into_factory(self) -> T {
+    fn into_factory(self) -> SF {
         self
     }
 }
 
-/// Convert object of type `T` to a service `S`
+/// Convert object of type `U` to a service `S`
-pub fn into_service<T, S>(tp: T) -> S
+pub fn into_service<I, S, Req>(tp: I) -> S
 where
-    S: Service,
+    I: IntoService<S, Req>,
-    T: IntoService<S>,
+    S: Service<Req>,
 {
     tp.into_service()
 }
 
 pub mod dev {
-    pub use crate::apply::{Apply, ApplyServiceFactory};
+    pub use crate::apply::{Apply, ApplyFactory};
     pub use crate::fn_service::{
         FnService, FnServiceConfig, FnServiceFactory, FnServiceNoConfig,
     };
@@ -373,3 +307,27 @@ pub mod dev {
     pub use crate::transform::ApplyTransform;
     pub use crate::transform_err::TransformMapInitErr;
 }
+
+#[macro_export]
+macro_rules! always_ready {
+    () => {
+        fn poll_ready(
+            &mut self,
+            _: &mut ::core::task::Context<'_>,
+        ) -> ::core::task::Poll<Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! forward_ready {
+    ($field:ident) => {
+        fn poll_ready(
+            &mut self,
+            cx: &mut ::core::task::Context<'_>,
+        ) -> ::core::task::Poll<Result<(), Self::Error>> {
+            self.$field.poll_ready(cx)
+        }
+    };
+}

actix-service/src/map.rs

@@ -1,25 +1,29 @@
-use std::future::Future;
+use core::{
-use std::marker::PhantomData;
+    future::Future,
-use std::pin::Pin;
+    marker::PhantomData,
-use std::task::{Context, Poll};
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use super::{Service, ServiceFactory};
 
 /// Service for the `map` combinator, changing the type of a service's response.
 ///
 /// This is created by the `ServiceExt::map` method.
-pub struct Map<A, F, Response> {
+pub struct Map<A, F, Req, Res> {
     service: A,
     f: F,
-    _t: PhantomData<Response>,
+    _t: PhantomData<(Req, Res)>,
 }
 
-impl<A, F, Response> Map<A, F, Response> {
+impl<A, F, Req, Res> Map<A, F, Req, Res> {
     /// Create new `Map` combinator
     pub(crate) fn new(service: A, f: F) -> Self
     where
-        A: Service,
+        A: Service<Req>,
-        F: FnMut(A::Response) -> Response,
+        F: FnMut(A::Response) -> Res,
     {
         Self {
             service,
@@ -29,7 +33,7 @@ impl<A, F, Response> Map<A, F, Response> {
     }
 }
 
-impl<A, F, Response> Clone for Map<A, F, Response>
+impl<A, F, Req, Res> Clone for Map<A, F, Req, Res>
 where
     A: Clone,
     F: Clone,
@@ -43,52 +47,50 @@ where
     }
 }
 
-impl<A, F, Response> Service for Map<A, F, Response>
+impl<A, F, Req, Res> Service<Req> for Map<A, F, Req, Res>
 where
-    A: Service,
+    A: Service<Req>,
-    F: FnMut(A::Response) -> Response + Clone,
+    F: FnMut(A::Response) -> Res + Clone,
 {
-    type Request = A::Request;
+    type Response = Res;
-    type Response = Response;
     type Error = A::Error;
-    type Future = MapFuture<A, F, Response>;
+    type Future = MapFuture<A, F, Req, Res>;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    crate::forward_ready!(service);
-        self.service.poll_ready(ctx)
-    }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         MapFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
-#[pin_project::pin_project]
+pin_project! {
-pub struct MapFuture<A, F, Response>
+    pub struct MapFuture<A, F, Req, Res>
-where
+    where
-    A: Service,
+        A: Service<Req>,
-    F: FnMut(A::Response) -> Response,
+        F: FnMut(A::Response) -> Res,
-{
+    {
-    f: F,
+        f: F,
-    #[pin]
+        #[pin]
-    fut: A::Future,
+        fut: A::Future,
+    }
 }
 
-impl<A, F, Response> MapFuture<A, F, Response>
+impl<A, F, Req, Res> MapFuture<A, F, Req, Res>
 where
-    A: Service,
+    A: Service<Req>,
-    F: FnMut(A::Response) -> Response,
+    F: FnMut(A::Response) -> Res,
 {
     fn new(fut: A::Future, f: F) -> Self {
         MapFuture { f, fut }
     }
 }
 
-impl<A, F, Response> Future for MapFuture<A, F, Response>
+impl<A, F, Req, Res> Future for MapFuture<A, F, Req, Res>
 where
-    A: Service,
+    A: Service<Req>,
-    F: FnMut(A::Response) -> Response,
+    F: FnMut(A::Response) -> Res,
 {
-    type Output = Result<Response, A::Error>;
+    type Output = Result<Res, A::Error>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -102,17 +104,17 @@ where
 }
 
 /// `MapNewService` new service combinator
-pub struct MapServiceFactory<A, F, Res> {
+pub struct MapServiceFactory<A, F, Req, Res> {
     a: A,
     f: F,
-    r: PhantomData<Res>,
+    r: PhantomData<(Res, Req)>,
 }
 
-impl<A, F, Res> MapServiceFactory<A, F, Res> {
+impl<A, F, Req, Res> MapServiceFactory<A, F, Req, Res> {
     /// Create new `Map` new service instance
     pub(crate) fn new(a: A, f: F) -> Self
     where
-        A: ServiceFactory,
+        A: ServiceFactory<Req>,
         F: FnMut(A::Response) -> Res,
     {
         Self {
@@ -123,7 +125,7 @@ impl<A, F, Res> MapServiceFactory<A, F, Res> {
     }
 }
 
-impl<A, F, Res> Clone for MapServiceFactory<A, F, Res>
+impl<A, F, Req, Res> Clone for MapServiceFactory<A, F, Req, Res>
 where
     A: Clone,
     F: Clone,
@@ -137,39 +139,39 @@ where
     }
 }
 
-impl<A, F, Res> ServiceFactory for MapServiceFactory<A, F, Res>
+impl<A, F, Req, Res> ServiceFactory<Req> for MapServiceFactory<A, F, Req, Res>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: FnMut(A::Response) -> Res + Clone,
 {
-    type Request = A::Request;
     type Response = Res;
     type Error = A::Error;
 
     type Config = A::Config;
-    type Service = Map<A::Service, F, Res>;
+    type Service = Map<A::Service, F, Req, Res>;
     type InitError = A::InitError;
-    type Future = MapServiceFuture<A, F, Res>;
+    type Future = MapServiceFuture<A, F, Req, Res>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
         MapServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-#[pin_project::pin_project]
+pin_project! {
-pub struct MapServiceFuture<A, F, Res>
+    pub struct MapServiceFuture<A, F, Req, Res>
-where
+    where
-    A: ServiceFactory,
+        A: ServiceFactory<Req>,
-    F: FnMut(A::Response) -> Res,
+        F: FnMut(A::Response) -> Res,
-{
+    {
-    #[pin]
+        #[pin]
-    fut: A::Future,
+        fut: A::Future,
-    f: Option<F>,
+        f: Option<F>,
+    }
 }
 
-impl<A, F, Res> MapServiceFuture<A, F, Res>
+impl<A, F, Req, Res> MapServiceFuture<A, F, Req, Res>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: FnMut(A::Response) -> Res,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -177,12 +179,12 @@ where
     }
 }
 
-impl<A, F, Res> Future for MapServiceFuture<A, F, Res>
+impl<A, F, Req, Res> Future for MapServiceFuture<A, F, Req, Res>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: FnMut(A::Response) -> Res,
 {
-    type Output = Result<Map<A::Service, F, Res>, A::InitError>;
+    type Output = Result<Map<A::Service, F, Req, Res>, A::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -197,22 +199,21 @@ where
 
 #[cfg(test)]
 mod tests {
-    use futures_util::future::{lazy, ok, Ready};
+    use futures_util::future::lazy;
 
     use super::*;
-    use crate::{IntoServiceFactory, Service, ServiceFactory};
+    use crate::{
+        ok, IntoServiceFactory, Ready, Service, ServiceExt, ServiceFactory, ServiceFactoryExt,
+    };
 
     struct Srv;
 
-    impl Service for Srv {
+    impl Service<()> for Srv {
-        type Request = ();
         type Response = ();
         type Error = ();
         type Future = Ready<Result<(), ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        crate::always_ready!();
-            Poll::Ready(Ok(()))
-        }
 
         fn call(&mut self, _: ()) -> Self::Future {
             ok(())

actix-service/src/map_config.rs

@@ -1,4 +1,4 @@
-use std::marker::PhantomData;
+use core::marker::PhantomData;
 
 use super::{IntoServiceFactory, ServiceFactory};
 
@@ -6,121 +6,123 @@ use super::{IntoServiceFactory, ServiceFactory};
 ///
 /// Note that this function consumes the receiving service factory and returns
 /// a wrapped version of it.
-pub fn map_config<T, U, F, C>(factory: U, f: F) -> MapConfig<T, F, C>
+pub fn map_config<I, SF, S, Req, F, Cfg>(factory: I, f: F) -> MapConfig<SF, Req, F, Cfg>
 where
-    T: ServiceFactory,
+    I: IntoServiceFactory<SF, Req>,
-    U: IntoServiceFactory<T>,
+    SF: ServiceFactory<Req>,
-    F: Fn(C) -> T::Config,
+    F: Fn(Cfg) -> SF::Config,
 {
     MapConfig::new(factory.into_factory(), f)
 }
 
-/// Replace config with unit
+/// Replace config with unit.
-pub fn unit_config<T, U, C>(factory: U) -> UnitConfig<T, C>
+pub fn unit_config<I, SF, Cfg, Req>(factory: I) -> UnitConfig<SF, Cfg, Req>
 where
-    T: ServiceFactory<Config = ()>,
+    I: IntoServiceFactory<SF, Req>,
-    U: IntoServiceFactory<T>,
+    SF: ServiceFactory<Req, Config = ()>,
 {
     UnitConfig::new(factory.into_factory())
 }
 
 /// `map_config()` adapter service factory
-pub struct MapConfig<A, F, C> {
+pub struct MapConfig<SF, Req, F, Cfg> {
-    a: A,
+    factory: SF,
-    f: F,
+    cfg_mapper: F,
-    e: PhantomData<C>,
+    e: PhantomData<(Cfg, Req)>,
 }
 
-impl<A, F, C> MapConfig<A, F, C> {
+impl<SF, Req, F, Cfg> MapConfig<SF, Req, F, Cfg> {
     /// Create new `MapConfig` combinator
-    pub(crate) fn new(a: A, f: F) -> Self
+    pub(crate) fn new(factory: SF, cfg_mapper: F) -> Self
     where
-        A: ServiceFactory,
+        SF: ServiceFactory<Req>,
-        F: Fn(C) -> A::Config,
+        F: Fn(Cfg) -> SF::Config,
     {
         Self {
-            a,
+            factory,
-            f,
+            cfg_mapper,
             e: PhantomData,
         }
     }
 }
 
-impl<A, F, C> Clone for MapConfig<A, F, C>
+impl<SF, Req, F, Cfg> Clone for MapConfig<SF, Req, F, Cfg>
 where
-    A: Clone,
+    SF: Clone,
     F: Clone,
 {
     fn clone(&self) -> Self {
         Self {
-            a: self.a.clone(),
+            factory: self.factory.clone(),
-            f: self.f.clone(),
+            cfg_mapper: self.cfg_mapper.clone(),
             e: PhantomData,
         }
     }
 }
 
-impl<A, F, C> ServiceFactory for MapConfig<A, F, C>
+impl<SF, Req, F, Cfg> ServiceFactory<Req> for MapConfig<SF, Req, F, Cfg>
 where
-    A: ServiceFactory,
+    SF: ServiceFactory<Req>,
-    F: Fn(C) -> A::Config,
+    F: Fn(Cfg) -> SF::Config,
 {
-    type Request = A::Request;
+    type Response = SF::Response;
-    type Response = A::Response;
+    type Error = SF::Error;
-    type Error = A::Error;
 
-    type Config = C;
+    type Config = Cfg;
-    type Service = A::Service;
+    type Service = SF::Service;
-    type InitError = A::InitError;
+    type InitError = SF::InitError;
-    type Future = A::Future;
+    type Future = SF::Future;
 
-    fn new_service(&self, cfg: C) -> Self::Future {
+    fn new_service(&self, cfg: Self::Config) -> Self::Future {
-        self.a.new_service((self.f)(cfg))
+        let mapped_cfg = (self.cfg_mapper)(cfg);
+        self.factory.new_service(mapped_cfg)
     }
 }
 
 /// `unit_config()` config combinator
-pub struct UnitConfig<A, C> {
+pub struct UnitConfig<SF, Cfg, Req> {
-    a: A,
+    factory: SF,
-    e: PhantomData<C>,
+    _phantom: PhantomData<(Cfg, Req)>,
 }
 
-impl<A, C> UnitConfig<A, C>
+impl<SF, Cfg, Req> UnitConfig<SF, Cfg, Req>
 where
-    A: ServiceFactory<Config = ()>,
+    SF: ServiceFactory<Req, Config = ()>,
 {
     /// Create new `UnitConfig` combinator
-    pub(crate) fn new(a: A) -> Self {
+    pub(crate) fn new(factory: SF) -> Self {
-        Self { a, e: PhantomData }
-    }
-}
-
-impl<A, C> Clone for UnitConfig<A, C>
-where
-    A: Clone,
-{
-    fn clone(&self) -> Self {
         Self {
-            a: self.a.clone(),
+            factory,
-            e: PhantomData,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<A, C> ServiceFactory for UnitConfig<A, C>
+impl<SF, Cfg, Req> Clone for UnitConfig<SF, Cfg, Req>
 where
-    A: ServiceFactory<Config = ()>,
+    SF: Clone,
 {
-    type Request = A::Request;
+    fn clone(&self) -> Self {
-    type Response = A::Response;
+        Self {
-    type Error = A::Error;
+            factory: self.factory.clone(),
-
+            _phantom: PhantomData,
-    type Config = C;
+        }
-    type Service = A::Service;
+    }
-    type InitError = A::InitError;
+}
-    type Future = A::Future;
+
-
+impl<SF, Cfg, Req> ServiceFactory<Req> for UnitConfig<SF, Cfg, Req>
-    fn new_service(&self, _: C) -> Self::Future {
+where
-        self.a.new_service(())
+    SF: ServiceFactory<Req, Config = ()>,
+{
+    type Response = SF::Response;
+    type Error = SF::Error;
+
+    type Config = Cfg;
+    type Service = SF::Service;
+    type InitError = SF::InitError;
+    type Future = SF::Future;
+
+    fn new_service(&self, _: Cfg) -> Self::Future {
+        self.factory.new_service(())
     }
 }

actix-service/src/map_err.rs

@@ -1,7 +1,11 @@
-use std::future::Future;
+use core::{
-use std::marker::PhantomData;
+    future::Future,
-use std::pin::Pin;
+    marker::PhantomData,
-use std::task::{Context, Poll};
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use super::{Service, ServiceFactory};
 
@@ -9,18 +13,18 @@ use super::{Service, ServiceFactory};
 /// error.
 ///
 /// This is created by the `ServiceExt::map_err` method.
-pub struct MapErr<A, F, E> {
+pub struct MapErr<S, Req, F, E> {
-    service: A,
+    service: S,
     f: F,
-    _t: PhantomData<E>,
+    _t: PhantomData<(E, Req)>,
 }
 
-impl<A, F, E> MapErr<A, F, E> {
+impl<S, Req, F, E> MapErr<S, Req, F, E> {
     /// Create new `MapErr` combinator
-    pub(crate) fn new(service: A, f: F) -> Self
+    pub(crate) fn new(service: S, f: F) -> Self
     where
-        A: Service,
+        S: Service<Req>,
-        F: Fn(A::Error) -> E,
+        F: Fn(S::Error) -> E,
     {
         Self {
             service,
@@ -30,9 +34,9 @@ impl<A, F, E> MapErr<A, F, E> {
     }
 }
 
-impl<A, F, E> Clone for MapErr<A, F, E>
+impl<S, Req, F, E> Clone for MapErr<S, Req, F, E>
 where
-    A: Clone,
+    S: Clone,
     F: Clone,
 {
     fn clone(&self) -> Self {
@@ -44,39 +48,39 @@ where
     }
 }
 
-impl<A, F, E> Service for MapErr<A, F, E>
+impl<A, Req, F, E> Service<Req> for MapErr<A, Req, F, E>
 where
-    A: Service,
+    A: Service<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
-    type Future = MapErrFuture<A, F, E>;
+    type Future = MapErrFuture<A, Req, F, E>;
 
     fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.service.poll_ready(ctx).map_err(&self.f)
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         MapErrFuture::new(self.service.call(req), self.f.clone())
     }
 }
 
-#[pin_project::pin_project]
+pin_project! {
-pub struct MapErrFuture<A, F, E>
+    pub struct MapErrFuture<A, Req, F, E>
-where
+    where
-    A: Service,
+        A: Service<Req>,
-    F: Fn(A::Error) -> E,
+        F: Fn(A::Error) -> E,
-{
+    {
-    f: F,
+        f: F,
-    #[pin]
+        #[pin]
-    fut: A::Future,
+        fut: A::Future,
+    }
 }
 
-impl<A, F, E> MapErrFuture<A, F, E>
+impl<A, Req, F, E> MapErrFuture<A, Req, F, E>
 where
-    A: Service,
+    A: Service<Req>,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -84,9 +88,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapErrFuture<A, F, E>
+impl<A, Req, F, E> Future for MapErrFuture<A, Req, F, E>
 where
-    A: Service,
+    A: Service<Req>,
     F: Fn(A::Error) -> E,
 {
     type Output = Result<A::Response, E>;
@@ -101,19 +105,19 @@ where
 /// service's error.
 ///
 /// This is created by the `NewServiceExt::map_err` method.
-pub struct MapErrServiceFactory<A, F, E>
+pub struct MapErrServiceFactory<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
     a: A,
     f: F,
-    e: PhantomData<E>,
+    e: PhantomData<(E, Req)>,
 }
 
-impl<A, F, E> MapErrServiceFactory<A, F, E>
+impl<A, Req, F, E> MapErrServiceFactory<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
     /// Create new `MapErr` new service instance
@@ -126,9 +130,9 @@ where
     }
 }
 
-impl<A, F, E> Clone for MapErrServiceFactory<A, F, E>
+impl<A, Req, F, E> Clone for MapErrServiceFactory<A, Req, F, E>
 where
-    A: ServiceFactory + Clone,
+    A: ServiceFactory<Req> + Clone,
     F: Fn(A::Error) -> E + Clone,
 {
     fn clone(&self) -> Self {
@@ -140,39 +144,39 @@ where
     }
 }
 
-impl<A, F, E> ServiceFactory for MapErrServiceFactory<A, F, E>
+impl<A, Req, F, E> ServiceFactory<Req> for MapErrServiceFactory<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = E;
 
     type Config = A::Config;
-    type Service = MapErr<A::Service, F, E>;
+    type Service = MapErr<A::Service, Req, F, E>;
     type InitError = A::InitError;
-    type Future = MapErrServiceFuture<A, F, E>;
+    type Future = MapErrServiceFuture<A, Req, F, E>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
         MapErrServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-#[pin_project::pin_project]
+pin_project! {
-pub struct MapErrServiceFuture<A, F, E>
+    pub struct MapErrServiceFuture<A, Req, F, E>
-where
+    where
-    A: ServiceFactory,
+        A: ServiceFactory<Req>,
-    F: Fn(A::Error) -> E,
+        F: Fn(A::Error) -> E,
-{
+    {
-    #[pin]
+        #[pin]
-    fut: A::Future,
+        fut: A::Future,
-    f: F,
+        f: F,
+    }
 }
 
-impl<A, F, E> MapErrServiceFuture<A, F, E>
+impl<A, Req, F, E> MapErrServiceFuture<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -180,12 +184,12 @@ where
     }
 }
 
-impl<A, F, E> Future for MapErrServiceFuture<A, F, E>
+impl<A, Req, F, E> Future for MapErrServiceFuture<A, Req, F, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::Error) -> E + Clone,
 {
-    type Output = Result<MapErr<A::Service, F, E>, A::InitError>;
+    type Output = Result<MapErr<A::Service, Req, F, E>, A::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -199,15 +203,17 @@ where
 
 #[cfg(test)]
 mod tests {
-    use futures_util::future::{err, lazy, ok, Ready};
+    use futures_util::future::lazy;
 
     use super::*;
-    use crate::{IntoServiceFactory, Service, ServiceFactory};
+    use crate::{
+        err, ok, IntoServiceFactory, Ready, Service, ServiceExt, ServiceFactory,
+        ServiceFactoryExt,
+    };
 
     struct Srv;
 
-    impl Service for Srv {
+    impl Service<()> for Srv {
-        type Request = ();
         type Response = ();
         type Error = ();
         type Future = Ready<Result<(), ()>>;

actix-service/src/map_init_err.rs

@@ -1,21 +1,25 @@
-use std::future::Future;
+use core::{
-use std::marker::PhantomData;
+    future::Future,
-use std::pin::Pin;
+    marker::PhantomData,
-use std::task::{Context, Poll};
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use super::ServiceFactory;
 
 /// `MapInitErr` service combinator
-pub struct MapInitErr<A, F, E> {
+pub struct MapInitErr<A, F, Req, Err> {
     a: A,
     f: F,
-    e: PhantomData<E>,
+    e: PhantomData<(Req, Err)>,
 }
 
-impl<A, F, E> MapInitErr<A, F, E>
+impl<A, F, Req, Err> MapInitErr<A, F, Req, Err>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
-    F: Fn(A::InitError) -> E,
+    F: Fn(A::InitError) -> Err,
 {
     /// Create new `MapInitErr` combinator
     pub(crate) fn new(a: A, f: F) -> Self {
@@ -27,7 +31,7 @@ where
     }
 }
 
-impl<A, F, E> Clone for MapInitErr<A, F, E>
+impl<A, F, Req, E> Clone for MapInitErr<A, F, Req, E>
 where
     A: Clone,
     F: Clone,
@@ -41,39 +45,39 @@ where
     }
 }
 
-impl<A, F, E> ServiceFactory for MapInitErr<A, F, E>
+impl<A, F, Req, E> ServiceFactory<Req> for MapInitErr<A, F, Req, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::InitError) -> E + Clone,
 {
-    type Request = A::Request;
     type Response = A::Response;
     type Error = A::Error;
 
     type Config = A::Config;
     type Service = A::Service;
     type InitError = E;
-    type Future = MapInitErrFuture<A, F, E>;
+    type Future = MapInitErrFuture<A, F, Req, E>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
         MapInitErrFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
 
-#[pin_project::pin_project]
+pin_project! {
-pub struct MapInitErrFuture<A, F, E>
+    pub struct MapInitErrFuture<A, F, Req, E>
-where
+    where
-    A: ServiceFactory,
+        A: ServiceFactory<Req>,
-    F: Fn(A::InitError) -> E,
+        F: Fn(A::InitError) -> E,
-{
+    {
-    f: F,
+        f: F,
-    #[pin]
+        #[pin]
-    fut: A::Future,
+        fut: A::Future,
+    }
 }
 
-impl<A, F, E> MapInitErrFuture<A, F, E>
+impl<A, F, Req, E> MapInitErrFuture<A, F, Req, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::InitError) -> E,
 {
     fn new(fut: A::Future, f: F) -> Self {
@@ -81,9 +85,9 @@ where
     }
 }
 
-impl<A, F, E> Future for MapInitErrFuture<A, F, E>
+impl<A, F, Req, E> Future for MapInitErrFuture<A, F, Req, E>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     F: Fn(A::InitError) -> E,
 {
     type Output = Result<A::Service, E>;

actix-service/src/pipeline.rs

@@ -1,42 +1,49 @@
-use std::future::Future;
+use core::{
-use std::task::{Context, Poll};
+    marker::PhantomData,
+    task::{Context, Poll},
+};
 
 use crate::and_then::{AndThenService, AndThenServiceFactory};
-use crate::and_then_apply_fn::{AndThenApplyFn, AndThenApplyFnFactory};
 use crate::map::{Map, MapServiceFactory};
 use crate::map_err::{MapErr, MapErrServiceFactory};
 use crate::map_init_err::MapInitErr;
 use crate::then::{ThenService, ThenServiceFactory};
 use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
-/// Contruct new pipeline with one service in pipeline chain.
+/// Construct new pipeline with one service in pipeline chain.
-pub fn pipeline<F, T>(service: F) -> Pipeline<T>
+pub fn pipeline<I, S, Req>(service: I) -> Pipeline<S, Req>
 where
-    F: IntoService<T>,
+    I: IntoService<S, Req>,
-    T: Service,
+    S: Service<Req>,
 {
     Pipeline {
         service: service.into_service(),
+        _phantom: PhantomData,
     }
 }
 
-/// Contruct new pipeline factory with one service factory.
+/// Construct new pipeline factory with one service factory.
-pub fn pipeline_factory<T, F>(factory: F) -> PipelineFactory<T>
+pub fn pipeline_factory<I, SF, Req>(factory: I) -> PipelineFactory<SF, Req>
 where
-    T: ServiceFactory,
+    I: IntoServiceFactory<SF, Req>,
-    F: IntoServiceFactory<T>,
+    SF: ServiceFactory<Req>,
 {
     PipelineFactory {
         factory: factory.into_factory(),
+        _phantom: PhantomData,
     }
 }
 
 /// Pipeline service - pipeline allows to compose multiple service into one service.
-pub struct Pipeline<T> {
+pub struct Pipeline<S, Req> {
-    service: T,
+    service: S,
+    _phantom: PhantomData<Req>,
 }
 
-impl<T: Service> Pipeline<T> {
+impl<S, Req> Pipeline<S, Req>
+where
+    S: Service<Req>,
+{
     /// Call another service after call to this one has resolved successfully.
     ///
     /// This function can be used to chain two services together and ensure that
@@ -46,41 +53,18 @@ impl<T: Service> Pipeline<T> {
     ///
     /// Note that this function consumes the receiving service and returns a
     /// wrapped version of it.
-    pub fn and_then<F, U>(
+    pub fn and_then<I, S1>(
         self,
-        service: F,
+        service: I,
-    ) -> Pipeline<
+    ) -> Pipeline<impl Service<Req, Response = S1::Response, Error = S::Error> + Clone, Req>
-        impl Service<Request = T::Request, Response = U::Response, Error = T::Error> + Clone,
-    >
     where
         Self: Sized,
-        F: IntoService<U>,
+        I: IntoService<S1, S::Response>,
-        U: Service<Request = T::Response, Error = T::Error>,
+        S1: Service<S::Response, Error = S::Error>,
     {
         Pipeline {
             service: AndThenService::new(self.service, service.into_service()),
-        }
+            _phantom: PhantomData,
-    }
-
-    /// Apply function to specified service and use it as a next service in
-    /// chain.
-    ///
-    /// Short version of `pipeline_factory(...).and_then(apply_fn_factory(...))`
-    pub fn and_then_apply_fn<U, I, F, Fut, Res, Err>(
-        self,
-        service: I,
-        f: F,
-    ) -> Pipeline<impl Service<Request = T::Request, Response = Res, Error = Err> + Clone>
-    where
-        Self: Sized,
-        I: IntoService<U>,
-        U: Service,
-        F: FnMut(T::Response, &mut U) -> Fut,
-        Fut: Future<Output = Result<Res, Err>>,
-        Err: From<T::Error> + From<U::Error>,
-    {
-        Pipeline {
-            service: AndThenApplyFn::new(self.service, service.into_service(), f),
         }
     }
 
@@ -89,19 +73,18 @@ impl<T: Service> Pipeline<T> {
     ///
     /// Note that this function consumes the receiving pipeline and returns a
     /// wrapped version of it.
-    pub fn then<F, U>(
+    pub fn then<F, S1>(
         self,
         service: F,
-    ) -> Pipeline<
+    ) -> Pipeline<impl Service<Req, Response = S1::Response, Error = S::Error> + Clone, Req>
-        impl Service<Request = T::Request, Response = U::Response, Error = T::Error> + Clone,
-    >
     where
         Self: Sized,
-        F: IntoService<U>,
+        F: IntoService<S1, Result<S::Response, S::Error>>,
-        U: Service<Request = Result<T::Response, T::Error>, Error = T::Error>,
+        S1: Service<Result<S::Response, S::Error>, Error = S::Error>,
     {
         Pipeline {
             service: ThenService::new(self.service, service.into_service()),
+            _phantom: PhantomData,
         }
     }
 
@@ -114,13 +97,14 @@ impl<T: Service> Pipeline<T> {
     /// Note that this function consumes the receiving service and returns a
     /// wrapped version of it, similar to the existing `map` methods in the
     /// standard library.
-    pub fn map<F, R>(self, f: F) -> Pipeline<Map<T, F, R>>
+    pub fn map<F, R>(self, f: F) -> Pipeline<Map<S, F, Req, R>, Req>
     where
         Self: Sized,
-        F: FnMut(T::Response) -> R,
+        F: FnMut(S::Response) -> R,
     {
         Pipeline {
             service: Map::new(self.service, f),
+            _phantom: PhantomData,
         }
     }
 
@@ -132,114 +116,85 @@ impl<T: Service> Pipeline<T> {
     ///
     /// Note that this function consumes the receiving service and returns a
     /// wrapped version of it.
-    pub fn map_err<F, E>(self, f: F) -> Pipeline<MapErr<T, F, E>>
+    pub fn map_err<F, E>(self, f: F) -> Pipeline<MapErr<S, Req, F, E>, Req>
     where
         Self: Sized,
-        F: Fn(T::Error) -> E,
+        F: Fn(S::Error) -> E,
     {
         Pipeline {
             service: MapErr::new(self.service, f),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T> Clone for Pipeline<T>
+impl<T, Req> Clone for Pipeline<T, Req>
 where
     T: Clone,
 {
     fn clone(&self) -> Self {
         Pipeline {
             service: self.service.clone(),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T: Service> Service for Pipeline<T> {
+impl<S: Service<Req>, Req> Service<Req> for Pipeline<S, Req> {
-    type Request = T::Request;
+    type Response = S::Response;
-    type Response = T::Response;
+    type Error = S::Error;
-    type Error = T::Error;
+    type Future = S::Future;
-    type Future = T::Future;
 
     #[inline]
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), T::Error>> {
+    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
         self.service.poll_ready(ctx)
     }
 
     #[inline]
-    fn call(&mut self, req: T::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         self.service.call(req)
     }
 }
 
 /// Pipeline factory
-pub struct PipelineFactory<T> {
+pub struct PipelineFactory<SF, Req> {
-    factory: T,
+    factory: SF,
+    _phantom: PhantomData<Req>,
 }
 
-impl<T: ServiceFactory> PipelineFactory<T> {
+impl<SF, Req> PipelineFactory<SF, Req>
+where
+    SF: ServiceFactory<Req>,
+{
     /// Call another service after call to this one has resolved successfully.
-    pub fn and_then<F, U>(
+    pub fn and_then<I, SF1>(
         self,
-        factory: F,
+        factory: I,
     ) -> PipelineFactory<
         impl ServiceFactory<
-                Request = T::Request,
+                Req,
-                Response = U::Response,
+                Response = SF1::Response,
-                Error = T::Error,
+                Error = SF::Error,
-                Config = T::Config,
+                Config = SF::Config,
-                InitError = T::InitError,
+                InitError = SF::InitError,
-                Service = impl Service<
+                Service = impl Service<Req, Response = SF1::Response, Error = SF::Error> + Clone,
-                    Request = T::Request,
-                    Response = U::Response,
-                    Error = T::Error,
-                > + Clone,
             > + Clone,
+        Req,
     >
     where
         Self: Sized,
-        T::Config: Clone,
+        SF::Config: Clone,
-        F: IntoServiceFactory<U>,
+        I: IntoServiceFactory<SF1, SF::Response>,
-        U: ServiceFactory<
+        SF1: ServiceFactory<
-            Config = T::Config,
+            SF::Response,
-            Request = T::Response,
+            Config = SF::Config,
-            Error = T::Error,
+            Error = SF::Error,
-            InitError = T::InitError,
+            InitError = SF::InitError,
         >,
     {
         PipelineFactory {
             factory: AndThenServiceFactory::new(self.factory, factory.into_factory()),
-        }
+            _phantom: PhantomData,
-    }
-
-    /// Apply function to specified service and use it as a next service in
-    /// chain.
-    ///
-    /// Short version of `pipeline_factory(...).and_then(apply_fn_factory(...))`
-    pub fn and_then_apply_fn<U, I, F, Fut, Res, Err>(
-        self,
-        factory: I,
-        f: F,
-    ) -> PipelineFactory<
-        impl ServiceFactory<
-                Request = T::Request,
-                Response = Res,
-                Error = Err,
-                Config = T::Config,
-                InitError = T::InitError,
-                Service = impl Service<Request = T::Request, Response = Res, Error = Err> + Clone,
-            > + Clone,
-    >
-    where
-        Self: Sized,
-        T::Config: Clone,
-        I: IntoServiceFactory<U>,
-        U: ServiceFactory<Config = T::Config, InitError = T::InitError>,
-        F: FnMut(T::Response, &mut U::Service) -> Fut + Clone,
-        Fut: Future<Output = Result<Res, Err>>,
-        Err: From<T::Error> + From<U::Error>,
-    {
-        PipelineFactory {
-            factory: AndThenApplyFnFactory::new(self.factory, factory.into_factory(), f),
         }
     }
 
@@ -249,96 +204,103 @@ impl<T: ServiceFactory> PipelineFactory<T> {
     ///
     /// Note that this function consumes the receiving pipeline and returns a
     /// wrapped version of it.
-    pub fn then<F, U>(
+    pub fn then<I, SF1>(
         self,
-        factory: F,
+        factory: I,
     ) -> PipelineFactory<
         impl ServiceFactory<
-                Request = T::Request,
+                Req,
-                Response = U::Response,
+                Response = SF1::Response,
-                Error = T::Error,
+                Error = SF::Error,
-                Config = T::Config,
+                Config = SF::Config,
-                InitError = T::InitError,
+                InitError = SF::InitError,
-                Service = impl Service<
+                Service = impl Service<Req, Response = SF1::Response, Error = SF::Error> + Clone,
-                    Request = T::Request,
-                    Response = U::Response,
-                    Error = T::Error,
-                > + Clone,
             > + Clone,
+        Req,
     >
     where
         Self: Sized,
-        T::Config: Clone,
+        SF::Config: Clone,
-        F: IntoServiceFactory<U>,
+        I: IntoServiceFactory<SF1, Result<SF::Response, SF::Error>>,
-        U: ServiceFactory<
+        SF1: ServiceFactory<
-            Config = T::Config,
+            Result<SF::Response, SF::Error>,
-            Request = Result<T::Response, T::Error>,
+            Config = SF::Config,
-            Error = T::Error,
+            Error = SF::Error,
-            InitError = T::InitError,
+            InitError = SF::InitError,
         >,
     {
         PipelineFactory {
             factory: ThenServiceFactory::new(self.factory, factory.into_factory()),
+            _phantom: PhantomData,
         }
     }
 
     /// Map this service's output to a different type, returning a new service
     /// of the resulting type.
-    pub fn map<F, R>(self, f: F) -> PipelineFactory<MapServiceFactory<T, F, R>>
+    pub fn map<F, R>(self, f: F) -> PipelineFactory<MapServiceFactory<SF, F, Req, R>, Req>
     where
         Self: Sized,
-        F: FnMut(T::Response) -> R + Clone,
+        F: FnMut(SF::Response) -> R + Clone,
     {
         PipelineFactory {
             factory: MapServiceFactory::new(self.factory, f),
+            _phantom: PhantomData,
         }
     }
 
     /// Map this service's error to a different error, returning a new service.
-    pub fn map_err<F, E>(self, f: F) -> PipelineFactory<MapErrServiceFactory<T, F, E>>
+    pub fn map_err<F, E>(
+        self,
+        f: F,
+    ) -> PipelineFactory<MapErrServiceFactory<SF, Req, F, E>, Req>
     where
         Self: Sized,
-        F: Fn(T::Error) -> E + Clone,
+        F: Fn(SF::Error) -> E + Clone,
     {
         PipelineFactory {
             factory: MapErrServiceFactory::new(self.factory, f),
+            _phantom: PhantomData,
         }
     }
 
     /// Map this factory's init error to a different error, returning a new service.
-    pub fn map_init_err<F, E>(self, f: F) -> PipelineFactory<MapInitErr<T, F, E>>
+    pub fn map_init_err<F, E>(self, f: F) -> PipelineFactory<MapInitErr<SF, F, Req, E>, Req>
     where
         Self: Sized,
-        F: Fn(T::InitError) -> E + Clone,
+        F: Fn(SF::InitError) -> E + Clone,
     {
         PipelineFactory {
             factory: MapInitErr::new(self.factory, f),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T> Clone for PipelineFactory<T>
+impl<T, Req> Clone for PipelineFactory<T, Req>
 where
     T: Clone,
 {
     fn clone(&self) -> Self {
         PipelineFactory {
             factory: self.factory.clone(),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T: ServiceFactory> ServiceFactory for PipelineFactory<T> {
+impl<SF, Req> ServiceFactory<Req> for PipelineFactory<SF, Req>
-    type Config = T::Config;
+where
-    type Request = T::Request;
+    SF: ServiceFactory<Req>,
-    type Response = T::Response;
+{
-    type Error = T::Error;
+    type Config = SF::Config;
-    type Service = T::Service;
+    type Response = SF::Response;
-    type InitError = T::InitError;
+    type Error = SF::Error;
-    type Future = T::Future;
+    type Service = SF::Service;
+    type InitError = SF::InitError;
+    type Future = SF::Future;
 
     #[inline]
-    fn new_service(&self, cfg: T::Config) -> Self::Future {
+    fn new_service(&self, cfg: SF::Config) -> Self::Future {
         self.factory.new_service(cfg)
     }
 }

actix-service/src/ready.rs

@@ -0,0 +1,54 @@
+//! When MSRV is 1.48, replace with `core::future::Ready` and `core::future::ready()`.
+
+use core::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+/// Future for the [`ready`](ready()) function.
+#[derive(Debug, Clone)]
+#[must_use = "futures do nothing unless you `.await` or poll them"]
+pub struct Ready<T> {
+    val: Option<T>,
+}
+
+impl<T> Ready<T> {
+    /// Unwraps the value from this immediately ready future.
+    #[inline]
+    pub fn into_inner(mut self) -> T {
+        self.val.take().unwrap()
+    }
+}
+
+impl<T> Unpin for Ready<T> {}
+
+impl<T> Future for Ready<T> {
+    type Output = T;
+
+    #[inline]
+    fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<T> {
+        let val = self.val.take().expect("Ready can not be polled twice.");
+        Poll::Ready(val)
+    }
+}
+
+/// Creates a future that is immediately ready with a value.
+#[allow(dead_code)]
+pub(crate) fn ready<T>(val: T) -> Ready<T> {
+    Ready { val: Some(val) }
+}
+
+/// Create a future that is immediately ready with a success value.
+#[allow(dead_code)]
+pub(crate) fn ok<T, E>(val: T) -> Ready<Result<T, E>> {
+    Ready { val: Some(Ok(val)) }
+}
+
+/// Create a future that is immediately ready with an error value.
+#[allow(dead_code)]
+pub(crate) fn err<T, E>(err: E) -> Ready<Result<T, E>> {
+    Ready {
+        val: Some(Err(err)),
+    }
+}

actix-service/src/then.rs

@@ -1,8 +1,13 @@
-use std::cell::RefCell;
+use alloc::rc::Rc;
-use std::future::Future;
+use core::{
-use std::pin::Pin;
+    cell::RefCell,
-use std::rc::Rc;
+    future::Future,
-use std::task::{Context, Poll};
+    marker::PhantomData,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use super::{Service, ServiceFactory};
 
@@ -10,34 +15,33 @@ use super::{Service, ServiceFactory};
 /// another service.
 ///
 /// This is created by the `Pipeline::then` method.
-pub(crate) struct ThenService<A, B>(Rc<RefCell<(A, B)>>);
+pub(crate) struct ThenService<A, B, Req>(Rc<RefCell<(A, B)>>, PhantomData<Req>);
 
-impl<A, B> ThenService<A, B> {
+impl<A, B, Req> ThenService<A, B, Req> {
     /// Create new `.then()` combinator
-    pub(crate) fn new(a: A, b: B) -> ThenService<A, B>
+    pub(crate) fn new(a: A, b: B) -> ThenService<A, B, Req>
     where
-        A: Service,
+        A: Service<Req>,
-        B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
+        B: Service<Result<A::Response, A::Error>, Error = A::Error>,
     {
-        Self(Rc::new(RefCell::new((a, b))))
+        Self(Rc::new(RefCell::new((a, b))), PhantomData)
     }
 }
 
-impl<A, B> Clone for ThenService<A, B> {
+impl<A, B, Req> Clone for ThenService<A, B, Req> {
     fn clone(&self) -> Self {
-        ThenService(self.0.clone())
+        ThenService(self.0.clone(), PhantomData)
     }
 }
 
-impl<A, B> Service for ThenService<A, B>
+impl<A, B, Req> Service<Req> for ThenService<A, B, Req>
 where
-    A: Service,
+    A: Service<Req>,
-    B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
+    B: Service<Result<A::Response, A::Error>, Error = A::Error>,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = B::Error;
-    type Future = ThenServiceResponse<A, B>;
+    type Future = ThenServiceResponse<A, B, Req>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         let mut srv = self.0.borrow_mut();
@@ -49,38 +53,44 @@ where
         }
     }
 
-    fn call(&mut self, req: A::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         ThenServiceResponse {
-            state: State::A(self.0.borrow_mut().0.call(req), Some(self.0.clone())),
+            state: State::A {
+                fut: self.0.borrow_mut().0.call(req),
+                b: Some(self.0.clone()),
+            },
         }
     }
 }
 
-#[pin_project::pin_project]
+pin_project! {
-pub(crate) struct ThenServiceResponse<A, B>
+    pub(crate) struct ThenServiceResponse<A, B, Req>
-where
+    where
-    A: Service,
+        A: Service<Req>,
-    B: Service<Request = Result<A::Response, A::Error>>,
+        B: Service<Result<A::Response, A::Error>>,
-{
+    {
-    #[pin]
+        #[pin]
-    state: State<A, B>,
+        state: State<A, B, Req>,
+    }
 }
 
-#[pin_project::pin_project(project = StateProj)]
+pin_project! {
-enum State<A, B>
+    #[project = StateProj]
-where
+    enum State<A, B, Req>
-    A: Service,
+    where
-    B: Service<Request = Result<A::Response, A::Error>>,
+        A: Service<Req>,
-{
+        B: Service<Result<A::Response, A::Error>>,
-    A(#[pin] A::Future, Option<Rc<RefCell<(A, B)>>>),
+    {
-    B(#[pin] B::Future),
+        A { #[pin] fut: A::Future, b: Option<Rc<RefCell<(A, B)>>> },
-    Empty,
+        B { #[pin] fut: B::Future },
+        Empty,
+    }
 }
 
-impl<A, B> Future for ThenServiceResponse<A, B>
+impl<A, B, Req> Future for ThenServiceResponse<A, B, Req>
 where
-    A: Service,
+    A: Service<Req>,
-    B: Service<Request = Result<A::Response, A::Error>>,
+    B: Service<Result<A::Response, A::Error>>,
 {
     type Output = Result<B::Response, B::Error>;
 
@@ -88,17 +98,17 @@ where
         let mut this = self.as_mut().project();
 
         match this.state.as_mut().project() {
-            StateProj::A(fut, b) => match fut.poll(cx) {
+            StateProj::A { fut, b } => match fut.poll(cx) {
                 Poll::Ready(res) => {
                     let b = b.take().unwrap();
                     this.state.set(State::Empty); // drop fut A
                     let fut = b.borrow_mut().1.call(res);
-                    this.state.set(State::B(fut));
+                    this.state.set(State::B { fut });
                     self.poll(cx)
                 }
                 Poll::Pending => Poll::Pending,
             },
-            StateProj::B(fut) => fut.poll(cx).map(|r| {
+            StateProj::B { fut } => fut.poll(cx).map(|r| {
                 this.state.set(State::Empty);
                 r
             }),
@@ -110,44 +120,43 @@ where
 }
 
 /// `.then()` service factory combinator
-pub(crate) struct ThenServiceFactory<A, B>(Rc<(A, B)>);
+pub(crate) struct ThenServiceFactory<A, B, Req>(Rc<(A, B)>, PhantomData<Req>);
 
-impl<A, B> ThenServiceFactory<A, B>
+impl<A, B, Req> ThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        Result<A::Response, A::Error>,
         Config = A::Config,
-        Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
     >,
 {
     /// Create new `AndThen` combinator
     pub(crate) fn new(a: A, b: B) -> Self {
-        Self(Rc::new((a, b)))
+        Self(Rc::new((a, b)), PhantomData)
     }
 }
 
-impl<A, B> ServiceFactory for ThenServiceFactory<A, B>
+impl<A, B, Req> ServiceFactory<Req> for ThenServiceFactory<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     A::Config: Clone,
     B: ServiceFactory<
+        Result<A::Response, A::Error>,
         Config = A::Config,
-        Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
     >,
 {
-    type Request = A::Request;
     type Response = B::Response;
     type Error = A::Error;
 
     type Config = A::Config;
-    type Service = ThenService<A::Service, B::Service>;
+    type Service = ThenService<A::Service, B::Service, Req>;
     type InitError = A::InitError;
-    type Future = ThenServiceFactoryResponse<A, B>;
+    type Future = ThenServiceFactoryResponse<A, B, Req>;
 
     fn new_service(&self, cfg: A::Config) -> Self::Future {
         let srv = &*self.0;
@@ -155,37 +164,38 @@ where
     }
 }
 
-impl<A, B> Clone for ThenServiceFactory<A, B> {
+impl<A, B, Req> Clone for ThenServiceFactory<A, B, Req> {
     fn clone(&self) -> Self {
-        Self(self.0.clone())
+        Self(self.0.clone(), PhantomData)
     }
 }
 
-#[pin_project::pin_project]
+pin_project! {
-pub(crate) struct ThenServiceFactoryResponse<A, B>
+    pub(crate) struct ThenServiceFactoryResponse<A, B, Req>
-where
+    where
-    A: ServiceFactory,
+        A: ServiceFactory<Req>,
-    B: ServiceFactory<
+        B: ServiceFactory<
-        Config = A::Config,
+            Result<A::Response, A::Error>,
-        Request = Result<A::Response, A::Error>,
+            Config = A::Config,
-        Error = A::Error,
+            Error = A::Error,
-        InitError = A::InitError,
+            InitError = A::InitError,
-    >,
+        >,
-{
+    {
-    #[pin]
+        #[pin]
-    fut_b: B::Future,
+        fut_b: B::Future,
-    #[pin]
+        #[pin]
-    fut_a: A::Future,
+        fut_a: A::Future,
-    a: Option<A::Service>,
+        a: Option<A::Service>,
-    b: Option<B::Service>,
+        b: Option<B::Service>,
+    }
 }
 
-impl<A, B> ThenServiceFactoryResponse<A, B>
+impl<A, B, Req> ThenServiceFactoryResponse<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     B: ServiceFactory<
+        Result<A::Response, A::Error>,
         Config = A::Config,
-        Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
     >,
@@ -200,17 +210,17 @@ where
     }
 }
 
-impl<A, B> Future for ThenServiceFactoryResponse<A, B>
+impl<A, B, Req> Future for ThenServiceFactoryResponse<A, B, Req>
 where
-    A: ServiceFactory,
+    A: ServiceFactory<Req>,
     B: ServiceFactory<
+        Result<A::Response, A::Error>,
         Config = A::Config,
-        Request = Result<A::Response, A::Error>,
         Error = A::Error,
         InitError = A::InitError,
     >,
 {
-    type Output = Result<ThenService<A::Service, B::Service>, A::InitError>;
+    type Output = Result<ThenService<A::Service, B::Service, Req>, A::InitError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.project();
@@ -238,19 +248,20 @@ where
 
 #[cfg(test)]
 mod tests {
-    use std::cell::Cell;
+    use alloc::rc::Rc;
-    use std::rc::Rc;
+    use core::{
-    use std::task::{Context, Poll};
+        cell::Cell,
+        task::{Context, Poll},
+    };
 
-    use futures_util::future::{err, lazy, ok, ready, Ready};
+    use futures_util::future::lazy;
 
-    use crate::{pipeline, pipeline_factory, Service, ServiceFactory};
+    use crate::{err, ok, pipeline, pipeline_factory, ready, Ready, Service, ServiceFactory};
 
     #[derive(Clone)]
     struct Srv1(Rc<Cell<usize>>);
 
-    impl Service for Srv1 {
+    impl Service<Result<&'static str, &'static str>> for Srv1 {
-        type Request = Result<&'static str, &'static str>;
         type Response = &'static str;
         type Error = ();
         type Future = Ready<Result<Self::Response, Self::Error>>;
@@ -270,8 +281,7 @@ mod tests {
 
     struct Srv2(Rc<Cell<usize>>);
 
-    impl Service for Srv2 {
+    impl Service<Result<&'static str, ()>> for Srv2 {
-        type Request = Result<&'static str, ()>;
         type Response = (&'static str, &'static str);
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;

actix-service/src/transform.rs

@@ -1,18 +1,22 @@
-use std::future::Future;
+use alloc::{rc::Rc, sync::Arc};
-use std::pin::Pin;
+use core::{
-use std::rc::Rc;
+    future::Future,
-use std::sync::Arc;
+    marker::PhantomData,
-use std::task::{Context, Poll};
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use crate::transform_err::TransformMapInitErr;
 use crate::{IntoServiceFactory, Service, ServiceFactory};
 
 /// Apply transform to a service.
-pub fn apply<T, S, U>(t: T, factory: U) -> ApplyTransform<T, S>
+pub fn apply<T, S, I, Req>(t: T, factory: I) -> ApplyTransform<T, S, Req>
 where
-    S: ServiceFactory,
+    I: IntoServiceFactory<S, Req>,
-    T: Transform<S::Service, InitError = S::InitError>,
+    S: ServiceFactory<Req>,
-    U: IntoServiceFactory<S>,
+    T: Transform<S::Service, Req, InitError = S::InitError>,
 {
     ApplyTransform::new(t, factory.into_factory())
 }
@@ -70,7 +74,7 @@ where
 ///     timeout: Duration,
 /// }
 ///
-/// impl<S> Transform<S> for TimeoutTransform<E>
+/// impl<S> Transform<S> for TimeoutTransform
 /// where
 ///     S: Service,
 /// {
@@ -89,10 +93,7 @@ where
 ///     }
 /// }
 /// ```
-pub trait Transform<S> {
+pub trait Transform<S, Req> {
-    /// Requests handled by the service.
-    type Request;
-
     /// Responses given by the service.
     type Response;
 
@@ -100,11 +101,7 @@ pub trait Transform<S> {
     type Error;
 
     /// The `TransformService` value created by this factory
-    type Transform: Service<
+    type Transform: Service<Req, Response = Self::Response, Error = Self::Error>;
-        Request = Self::Request,
-        Response = Self::Response,
-        Error = Self::Error,
-    >;
 
     /// Errors produced while building a transform service.
     type InitError;
@@ -115,9 +112,9 @@ pub trait Transform<S> {
     /// Creates and returns a new Transform component, asynchronously
     fn new_transform(&self, service: S) -> Self::Future;
 
-    /// Map this transforms's factory error to a different error,
+    /// Map this transform's factory 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>
+    fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, Req, F, E>
     where
         Self: Sized,
         F: Fn(Self::InitError) -> E + Clone,
@@ -126,11 +123,10 @@ pub trait Transform<S> {
     }
 }
 
-impl<T, S> Transform<S> for Rc<T>
+impl<T, S, Req> Transform<S, Req> for Rc<T>
 where
-    T: Transform<S>,
+    T: Transform<S, Req>,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
     type InitError = T::InitError;
@@ -142,11 +138,10 @@ where
     }
 }
 
-impl<T, S> Transform<S> for Arc<T>
+impl<T, S, Req> Transform<S, Req> for Arc<T>
 where
-    T: Transform<S>,
+    T: Transform<S, Req>,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
     type InitError = T::InitError;
@@ -159,72 +154,76 @@ where
 }
 
 /// `Apply` transform to new service
-pub struct ApplyTransform<T, S>(Rc<(T, S)>);
+pub struct ApplyTransform<T, S, Req>(Rc<(T, S)>, PhantomData<Req>);
 
-impl<T, S> ApplyTransform<T, S>
+impl<T, S, Req> ApplyTransform<T, S, Req>
 where
-    S: ServiceFactory,
+    S: ServiceFactory<Req>,
-    T: Transform<S::Service, InitError = S::InitError>,
+    T: Transform<S::Service, Req, InitError = S::InitError>,
 {
     /// Create new `ApplyTransform` new service instance
     fn new(t: T, service: S) -> Self {
-        Self(Rc::new((t, service)))
+        Self(Rc::new((t, service)), PhantomData)
     }
 }
 
-impl<T, S> Clone for ApplyTransform<T, S> {
+impl<T, S, Req> Clone for ApplyTransform<T, S, Req> {
     fn clone(&self) -> Self {
-        ApplyTransform(self.0.clone())
+        ApplyTransform(self.0.clone(), PhantomData)
     }
 }
 
-impl<T, S> ServiceFactory for ApplyTransform<T, S>
+impl<T, S, Req> ServiceFactory<Req> for ApplyTransform<T, S, Req>
 where
-    S: ServiceFactory,
+    S: ServiceFactory<Req>,
-    T: Transform<S::Service, InitError = S::InitError>,
+    T: Transform<S::Service, Req, InitError = S::InitError>,
 {
-    type Request = T::Request;
     type Response = T::Response;
     type Error = T::Error;
 
     type Config = S::Config;
     type Service = T::Transform;
     type InitError = T::InitError;
-    type Future = ApplyTransformFuture<T, S>;
+    type Future = ApplyTransformFuture<T, S, Req>;
 
     fn new_service(&self, cfg: S::Config) -> Self::Future {
         ApplyTransformFuture {
             store: self.0.clone(),
-            state: ApplyTransformFutureState::A(self.0.as_ref().1.new_service(cfg)),
+            state: ApplyTransformFutureState::A {
+                fut: self.0.as_ref().1.new_service(cfg),
+            },
         }
     }
 }
 
-#[pin_project::pin_project]
+pin_project! {
-pub struct ApplyTransformFuture<T, S>
+    pub struct ApplyTransformFuture<T, S, Req>
-where
+    where
-    S: ServiceFactory,
+        S: ServiceFactory<Req>,
-    T: Transform<S::Service, InitError = S::InitError>,
+        T: Transform<S::Service, Req, InitError = S::InitError>,
-{
+    {
-    store: Rc<(T, S)>,
+        store: Rc<(T, S)>,
-    #[pin]
+        #[pin]
-    state: ApplyTransformFutureState<T, S>,
+        state: ApplyTransformFutureState<T, S, Req>,
+    }
 }
 
-#[pin_project::pin_project(project = ApplyTransformFutureStateProj)]
+pin_project! {
-pub enum ApplyTransformFutureState<T, S>
+    #[project = ApplyTransformFutureStateProj]
-where
+    pub enum ApplyTransformFutureState<T, S, Req>
-    S: ServiceFactory,
+    where
-    T: Transform<S::Service, InitError = S::InitError>,
+        S: ServiceFactory<Req>,
-{
+        T: Transform<S::Service, Req, InitError = S::InitError>,
-    A(#[pin] S::Future),
+    {
-    B(#[pin] T::Future),
+        A { #[pin] fut: S::Future },
+        B { #[pin] fut: T::Future },
+    }
 }
 
-impl<T, S> Future for ApplyTransformFuture<T, S>
+impl<T, S, Req> Future for ApplyTransformFuture<T, S, Req>
 where
-    S: ServiceFactory,
+    S: ServiceFactory<Req>,
-    T: Transform<S::Service, InitError = S::InitError>,
+    T: Transform<S::Service, Req, InitError = S::InitError>,
 {
     type Output = Result<T::Transform, T::InitError>;
 
@@ -232,15 +231,15 @@ where
         let mut this = self.as_mut().project();
 
         match this.state.as_mut().project() {
-            ApplyTransformFutureStateProj::A(fut) => match fut.poll(cx)? {
+            ApplyTransformFutureStateProj::A { fut } => match fut.poll(cx)? {
                 Poll::Ready(srv) => {
                     let fut = this.store.0.new_transform(srv);
-                    this.state.set(ApplyTransformFutureState::B(fut));
+                    this.state.set(ApplyTransformFutureState::B { fut });
                     self.poll(cx)
                 }
                 Poll::Pending => Poll::Pending,
             },
-            ApplyTransformFutureStateProj::B(fut) => fut.poll(cx),
+            ApplyTransformFutureStateProj::B { fut } => fut.poll(cx),
         }
     }
 }

actix-service/src/transform_err.rs

@@ -1,7 +1,11 @@
-use std::future::Future;
+use core::{
-use std::marker::PhantomData;
+    future::Future,
-use std::pin::Pin;
+    marker::PhantomData,
-use std::task::{Context, Poll};
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use pin_project_lite::pin_project;
 
 use super::Transform;
 
@@ -9,75 +13,75 @@ use super::Transform;
 /// transform's init error.
 ///
 /// This is created by the `Transform::map_init_err` method.
-pub struct TransformMapInitErr<T, S, F, E> {
+pub struct TransformMapInitErr<T, S, Req, F, E> {
-    t: T,
+    transform: T,
-    f: F,
+    mapper: F,
-    e: PhantomData<(S, E)>,
+    _phantom: PhantomData<(S, Req, E)>,
 }
 
-impl<T, S, F, E> TransformMapInitErr<T, S, F, E> {
+impl<T, S, F, E, Req> TransformMapInitErr<T, S, Req, F, E> {
     pub(crate) fn new(t: T, f: F) -> Self
     where
-        T: Transform<S>,
+        T: Transform<S, Req>,
         F: Fn(T::InitError) -> E,
     {
         Self {
-            t,
+            transform: t,
-            f,
+            mapper: f,
-            e: PhantomData,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, S, F, E> Clone for TransformMapInitErr<T, S, F, E>
+impl<T, S, Req, F, E> Clone for TransformMapInitErr<T, S, Req, F, E>
 where
     T: Clone,
     F: Clone,
 {
     fn clone(&self) -> Self {
         Self {
-            t: self.t.clone(),
+            transform: self.transform.clone(),
-            f: self.f.clone(),
+            mapper: self.mapper.clone(),
-            e: PhantomData,
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<T, S, F, E> Transform<S> for TransformMapInitErr<T, S, F, E>
+impl<T, S, F, E, Req> Transform<S, Req> for TransformMapInitErr<T, S, Req, F, E>
 where
-    T: Transform<S>,
+    T: Transform<S, Req>,
     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>;
+    type Future = TransformMapInitErrFuture<T, S, F, E, Req>;
 
     fn new_transform(&self, service: S) -> Self::Future {
         TransformMapInitErrFuture {
-            fut: self.t.new_transform(service),
+            fut: self.transform.new_transform(service),
-            f: self.f.clone(),
+            f: self.mapper.clone(),
         }
     }
 }
 
-#[pin_project::pin_project]
+pin_project! {
-pub struct TransformMapInitErrFuture<T, S, F, E>
+    pub struct TransformMapInitErrFuture<T, S, F, E, Req>
-where
+    where
-    T: Transform<S>,
+    T: Transform<S, Req>,
     F: Fn(T::InitError) -> E,
-{
+    {
-    #[pin]
+        #[pin]
-    fut: T::Future,
+        fut: T::Future,
-    f: F,
+        f: F,
+    }
 }
 
-impl<T, S, F, E> Future for TransformMapInitErrFuture<T, S, F, E>
+impl<T, S, F, E, Req> Future for TransformMapInitErrFuture<T, S, F, E, Req>
 where
-    T: Transform<S>,
+    T: Transform<S, Req>,
     F: Fn(T::InitError) -> E + Clone,
 {
     type Output = Result<T::Transform, E>;

actix-testing/src/lib.rs

@@ -1,6 +1,9 @@
 //! Various helpers for Actix applications to use during testing.
-#![deny(rust_2018_idioms, warnings)]
+
+#![deny(rust_2018_idioms, nonstandard_style)]
 #![allow(clippy::type_complexity, clippy::needless_doctest_main)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
 use std::sync::mpsc;
 use std::{net, thread};
@@ -37,7 +40,7 @@ pub use actix_macros::test;
 /// ```
 pub struct TestServer;
 
-/// Test server runstime
+/// Test server runtime
 pub struct TestServerRuntime {
     addr: net::SocketAddr,
     host: String,
@@ -80,15 +83,18 @@ impl TestServer {
 
         // run server in separate thread
         thread::spawn(move || {
-            let sys = System::new("actix-test-server");
+            let mut sys = System::new("actix-test-server");
             let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
             let local_addr = tcp.local_addr().unwrap();
 
-            Server::build()
+            sys.block_on(async {
-                .listen("test", tcp, factory)?
+                Server::build()
-                .workers(1)
+                    .listen("test", tcp, factory)
-                .disable_signals()
+                    .unwrap()
-                .start();
+                    .workers(1)
+                    .disable_signals()
+                    .start();
+            });
 
             tx.send((System::current(), local_addr)).unwrap();
             sys.run()
@@ -107,7 +113,7 @@ impl TestServer {
         }
     }
 
-    /// Get firat available unused local address
+    /// Get first available unused local address
     pub fn unused_addr() -> net::SocketAddr {
         let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
         let socket =

actix-threadpool/src/lib.rs

@@ -1,5 +1,9 @@
 //! Thread pool for blocking operations
 
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
+
 use std::fmt;
 use std::future::Future;
 use std::pin::Pin;

actix-tls/Cargo.toml

@@ -18,6 +18,10 @@ features = ["openssl", "rustls", "nativetls"]
 name = "actix_tls"
 path = "src/lib.rs"
 
+[[example]]
+name = "basic"
+required-features = ["rustls"]
+
 [features]
 default = []
 
@@ -53,4 +57,8 @@ tokio-tls = { version = "0.3", optional = true }
 
 [dev-dependencies]
 bytes = "0.5"
+log = "0.4"
+env_logger = "0.7"
 actix-testing = "1.0.0"
+actix-server = "1"
+actix-rt = "1"

actix-tls/examples/basic.rs

@@ -0,0 +1,82 @@
+//! TLS Acceptor Server
+//!
+//! Using either HTTPie (`http`) or cURL:
+//!
+//! This commands will produce errors in the server log:
+//! ```sh
+//! curl 127.0.0.1:8443
+//! http 127.0.0.1:8443
+//! ```
+//!
+//! These commands will show "empty reply" on the client but will debug print the TLS stream info
+//! in the server log, indicating a successful TLS handshake:
+//! ```sh
+//! curl -k https://127.0.0.1:8443
+//! http --verify=false https://127.0.0.1:8443
+//! ```
+
+use std::{
+    env,
+    fs::File,
+    io::{self, BufReader},
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+};
+
+use actix_server::Server;
+use actix_service::pipeline_factory;
+use actix_tls::rustls::Acceptor as RustlsAcceptor;
+use futures_util::future::ok;
+use log::info;
+use rust_tls::{
+    internal::pemfile::certs, internal::pemfile::rsa_private_keys, NoClientAuth, ServerConfig,
+};
+
+#[derive(Debug)]
+struct ServiceState {
+    num: Arc<AtomicUsize>,
+}
+
+#[actix_rt::main]
+async fn main() -> io::Result<()> {
+    env::set_var("RUST_LOG", "actix=trace,basic=trace");
+    env_logger::init();
+
+    let mut tls_config = ServerConfig::new(NoClientAuth::new());
+
+    // Load TLS key and cert files
+    let cert_file = &mut BufReader::new(File::open("./examples/cert.pem").unwrap());
+    let key_file = &mut BufReader::new(File::open("./examples/key.pem").unwrap());
+
+    let cert_chain = certs(cert_file).unwrap();
+    let mut keys = rsa_private_keys(key_file).unwrap();
+    tls_config
+        .set_single_cert(cert_chain, keys.remove(0))
+        .unwrap();
+
+    let tls_acceptor = RustlsAcceptor::new(tls_config);
+
+    let count = Arc::new(AtomicUsize::new(0));
+
+    let addr = ("127.0.0.1", 8443);
+    info!("starting server on port: {}", &addr.0);
+
+    Server::build()
+        .bind("tls-example", addr, move || {
+            let count = Arc::clone(&count);
+
+            // Set up TLS service factory
+            pipeline_factory(tls_acceptor.clone())
+                .map_err(|err| println!("Rustls error: {:?}", err))
+                .and_then(move |stream| {
+                    let num = count.fetch_add(1, Ordering::Relaxed);
+                    info!("[{}] Got TLS connection: {:?}", num, stream);
+                    ok(())
+                })
+        })?
+        .workers(1)
+        .run()
+        .await
+}

actix-tls/examples/cert.pem

@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIENjCCAp6gAwIBAgIRANp+D9pBErdacw6KjrwJ+4swDQYJKoZIhvcNAQELBQAw
+bTEeMBwGA1UEChMVbWtjZXJ0IGRldmVsb3BtZW50IENBMSEwHwYDVQQLDBhyb2JA
+c29tYnJhLng1Mi5kZXYgKFJvYikxKDAmBgNVBAMMH21rY2VydCByb2JAc29tYnJh
+Lng1Mi5kZXYgKFJvYikwHhcNMTkwNjAxMDAwMDAwWhcNMzAwOTEzMDIzNDI0WjBM
+MScwJQYDVQQKEx5ta2NlcnQgZGV2ZWxvcG1lbnQgY2VydGlmaWNhdGUxITAfBgNV
+BAsMGHJvYkBzb21icmEueDUyLmRldiAoUm9iKTCCASIwDQYJKoZIhvcNAQEBBQAD
+ggEPADCCAQoCggEBALYAn8dsQUDTp8SptAtkiAySvQYLpAOct3/OjBn+dSYfbQcp
+Ph9w/Zo83Msl7Fb1DBvADHFtyBpESATZ2chS5fwCAwUFTlKrzMk3qauEoJ3cCQa8
+ccqhTMLeT38jRlhXrMHWBfz0ipqy+yTLWeM32LX8s0jPbbsZ3gVJ/Ls4qm0CTaqb
+zRdcQ7GTVKYet5DR7ZvwvAaLtWk/iiHKwnOveuF27HNlxj0Rwd/lhJ/t9x8xJwyR
+MTdm852KQadI8xOSbWNK4j9419yzKjUEMKgn78wT/7DQfeKKCAreHa4MaEw4+koD
+2Bqb+V4fI6T84VvXkNG3CjSpmIiYGlIE1LVgBL8CAwEAAaNyMHAwDgYDVR0PAQH/
+BAQDAgWgMBMGA1UdJQQMMAoGCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0j
+BBgwFoAUto/ox0MqZShmQpViV/gjfJKrMDkwGgYDVR0RBBMwEYIJbG9jYWxob3N0
+hwR/AAABMA0GCSqGSIb3DQEBCwUAA4IBgQBUCMzqTY0sg+61gh8gKS5TCL6qs0R1
+xys/EFFaD5JYUsfM/HyhHd0jq+x5Pd3mB2Jvhoq9xhjMwP11H8Uw5lLBHA8USdF9
+EiLW1GvT3/gLfMqb0lPk0RMRBeX8c0QbDtqdiUCE7S6zJbZ5gjFeRuFNjdcGA1Ss
+8CPPts2mns5cwah6H7T/BFzj5aR9Qe14vo1Rpr5gD5CpHvk1t16q7YsczQfVMvt3
+Ydk6p0rwA8Z5okQK7y3qKPZI+//ygWL6ZBjVjl1/Al8vybG2UYjYgfMBwaVvMiDJ
+j/vCdVmlvGb+MZlZID/p2veaNeEKgi1A1EOj3sNuQYXXFfSD9mdamX7JIfGi/U7v
+ivvUjJUbzGrUngldt5iCKqcCQum7nlzu9sT1Tm2t/n4tz/btrI+Wimg8riSzM+Nk
+dfuvv4NbWe6Th5460HH8mMvfPZSB8dCoxwm98tuqcMXLkR1RJX5Z8LYAaPTsUs/h
+HxQCY4EaY7feZ/qFal9FGwvpzVr3/XjgSCU=
+-----END CERTIFICATE-----

actix-tls/examples/key.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpAIBAAKCAQEAtgCfx2xBQNOnxKm0C2SIDJK9BgukA5y3f86MGf51Jh9tByk+
+H3D9mjzcyyXsVvUMG8AMcW3IGkRIBNnZyFLl/AIDBQVOUqvMyTepq4SgndwJBrxx
+yqFMwt5PfyNGWFeswdYF/PSKmrL7JMtZ4zfYtfyzSM9tuxneBUn8uziqbQJNqpvN
+F1xDsZNUph63kNHtm/C8Bou1aT+KIcrCc6964Xbsc2XGPRHB3+WEn+33HzEnDJEx
+N2bznYpBp0jzE5JtY0riP3jX3LMqNQQwqCfvzBP/sNB94ooICt4drgxoTDj6SgPY
+Gpv5Xh8jpPzhW9eQ0bcKNKmYiJgaUgTUtWAEvwIDAQABAoIBADC0Zg21+Jhii6jj
+SR0rYAUNV6xAfTnCPJDlMzTZlXwIOOMLtGYxlIwr8WIj2eVDWmQqtqm8GSp+T0+N
+BOzI0mboGurDCryw4PKQBMWzjk/wTDITR9hT5fjYCSoaxH5rp/2PSrbwsg7ICtFD
+4eAeV84Lu+amK9VADNwZepqXhXP6EDOY5yovkwzOQNDM/qVzHSe9EoFP74M/oWnY
+ohIuWdZzwAZuTA5SUjPygiVzs/vhsrSE9crMIzr5VgKBi+C+ALkrL7Lc4GlRPI4r
+6VsbIxZHa7who+FhjZ0cVfdXHH47QDdf10X5bEXsaFBvGGCLtkQ3XEpov6GOlaH+
+aY7fzPECgYEA4LGloaMC9J27uyPxHkQwEehexmJdIu0vNUefv5yiO9PbvrjvYnh7
+JxRVgv1fy2bRMOvg19TujCYRZdkrLDqSDsfFfEiThvlFBRZfKKIHmWdyfvIe9Jp9
+rqdxhWAco7FoM+W6c8c4iR4xs8/GA60CVcAiTLqgPWWzn12fesiULi0CgYEAz1xD
+OulJyfpHVGQ6ZM1wR0SZ9H9GS3BenpL2ue5uBfe3hM+JIAAM61Y48wJuCWT5EvfL
+FgnH3oCo7SYGcgGkERS8H7k67DJCLlqDo/3FC7lX/irz+ya/FoZmKBagvjEUWhpe
+Bb2dRIbqsG0lsCzU9MVrgtvodD0MBTyt0RM5fhsCgYEAhgYQiLhGBAituLN4mBgO
+IDBdj7GOYk3dkcc2J0HTlyIIeduvlinNM4Myel6NrDKY5rhbtgGhhGEUkY6W7NvG
+0SAh0L8tmB3JKH6upfr3023b4pKjGj2oZ+wij27DxnQEdqg5reOP+mHTPbDaKMki
+kml3TBMpj1XBbXaXsNJBaMUCgYEAnnNzEC4563QrU2pvUJ3HgT4Dotgqv/Sy6NuG
+W1e9jSPYgU0RDHndZWtygwdFTDpzNbJR5po8t2J7MxQOcsmcNE0y387sHpbdCYyy
+8Po2uxm7CoaJ/02BUVYL8/Aujob0dVGWrS5SYY3zAjO1S+VGKXA+EjW2cDRB3jKa
+45ucICcCgYBdMxB5Oj6GpdewWWaBss9dwHtDaD4oVGYIBbIc2qdyCYixWdW9NccV
+fRJs0ulGrpg9OtyWbwZASu2jz55+s3hi4rnrcaXKiIh9Rs25v1irF6Dmduvo7CaN
+Mf7zBg7LUttmqN6D3npIAxmBULl8KRfjnt6U2tJolF5X0qQ1uqnnTA==
+-----END RSA PRIVATE KEY-----

actix-tls/src/lib.rs

@@ -5,7 +5,9 @@
 //! * `rustls` - TLS acceptor using the `rustls` crate.
 //! * `nativetls` - TLS acceptor using the `native-tls` crate.
 
-#![deny(rust_2018_idioms)]
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
 use std::sync::atomic::{AtomicUsize, Ordering};
 

actix-tracing/src/lib.rs

@@ -1,8 +1,10 @@
 //! Actix tracing - support for tokio tracing with Actix services.
-#![deny(rust_2018_idioms, warnings)]
 
-use std::marker::PhantomData;
+#![deny(rust_2018_idioms, nonstandard_style)]
-use std::task::{Context, Poll};
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
+
+use core::marker::PhantomData;
 
 use actix_service::{
     apply, dev::ApplyTransform, IntoServiceFactory, Service, ServiceFactory, Transform,
@@ -24,21 +26,18 @@ impl<S, F> TracingService<S, F> {
     }
 }
 
-impl<S, F> Service for TracingService<S, F>
+impl<S, Req, F> Service<Req> for TracingService<S, F>
 where
-    S: Service,
+    S: Service<Req>,
-    F: Fn(&S::Request) -> Option<tracing::Span>,
+    F: Fn(&Req) -> Option<tracing::Span>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Future = Either<S::Future, Instrumented<S::Future>>;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    actix_service::forward_ready!(inner);
-        self.inner.poll_ready(ctx)
-    }
 
-    fn call(&mut self, req: Self::Request) -> Self::Future {
+    fn call(&mut self, req: Req) -> Self::Future {
         let span = (self.make_span)(&req);
         let _enter = span.as_ref().map(|s| s.enter());
 
@@ -57,8 +56,6 @@ where
 }
 
 /// A `Transform` implementation that wraps services with a [`TracingService`].
-///
-/// [`TracingService`]: struct.TracingService.html
 pub struct TracingTransform<S, U, F> {
     make_span: F,
     _p: PhantomData<fn(S, U)>,
@@ -73,18 +70,12 @@ impl<S, U, F> TracingTransform<S, U, F> {
     }
 }
 
-impl<S, U, F> Transform<S> for TracingTransform<S, U, F>
+impl<S, Req, U, F> Transform<S, Req> for TracingTransform<S, U, F>
 where
-    S: Service,
+    S: Service<Req>,
-    U: ServiceFactory<
+    U: ServiceFactory<Req, Response = S::Response, Error = S::Error, Service = S>,
-        Request = S::Request,
+    F: Fn(&Req) -> Option<tracing::Span> + Clone,
-        Response = S::Response,
-        Error = S::Error,
-        Service = S,
-    >,
-    F: Fn(&S::Request) -> Option<tracing::Span> + Clone,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = S::Error;
     type Transform = TracingService<S, F>;
@@ -109,14 +100,14 @@ where
 ///     |req: &Request| Some(span!(Level::INFO, "request", req.id))
 /// );
 /// ```
-pub fn trace<S, U, F>(
+pub fn trace<S, Req, I, F>(
-    service_factory: U,
+    service_factory: I,
     make_span: F,
-) -> ApplyTransform<TracingTransform<S::Service, S, F>, S>
+) -> ApplyTransform<TracingTransform<S::Service, S, F>, S, Req>
 where
-    S: ServiceFactory,
+    I: IntoServiceFactory<S, Req>,
-    F: Fn(&S::Request) -> Option<tracing::Span> + Clone,
+    S: ServiceFactory<Req>,
-    U: IntoServiceFactory<S>,
+    F: Fn(&Req) -> Option<tracing::Span> + Clone,
 {
     apply(
         TracingTransform::new(make_span),

actix-utils/CHANGES.md

@@ -1,6 +1,10 @@
 # Changes
 
 ## Unreleased - 2020-xx-xx
+* Use `pin-project-lite` to replace `pin-project`. [#229]
+* Remove `condition`,`either`,`inflight`,`keepalive`,`oneshot`,`order`,`stream` and `time` mods. [#229]
+
+[#229]: https://github.com/actix/actix-net/pull/229
 
 ## 2.0.0 - 2020-08-23
 * No changes from beta 1.

actix-utils/Cargo.toml

@@ -19,12 +19,11 @@ path = "src/lib.rs"
 actix-codec = "0.3.0"
 actix-rt = "1.1.1"
 actix-service = "1.0.6"
-bitflags = "1.2.1"
+
-bytes = "0.5.3"
+futures-core = { version = "0.3.7", default-features = false }
-either = "1.5.3"
+futures-sink = { version = "0.3.7", default-features = false }
-futures-channel = { version = "0.3.4", default-features = false }
-futures-sink = { version = "0.3.4", default-features = false }
-futures-util = { version = "0.3.4", default-features = false }
 log = "0.4"
-pin-project = "0.4.17"
+pin-project-lite = "0.2.0"
-slab = "0.4"
+
+[dev-dependencies]
+futures-util = { version = "0.3.7", default-features = false }

actix-utils/src/condition.rs

@@ -1,129 +0,0 @@
-use std::cell::RefCell;
-use std::future::Future;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::task::{Context, Poll};
-
-use slab::Slab;
-
-use crate::task::LocalWaker;
-
-/// Condition allows to notify multiple receivers at the same time
-pub struct Condition(Rc<RefCell<Inner>>);
-
-struct Inner {
-    data: Slab<Option<LocalWaker>>,
-}
-
-impl Default for Condition {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Condition {
-    pub fn new() -> Condition {
-        Condition(Rc::new(RefCell::new(Inner { data: Slab::new() })))
-    }
-
-    /// Get condition waiter
-    pub fn wait(&mut self) -> Waiter {
-        let token = self.0.borrow_mut().data.insert(None);
-        Waiter {
-            token,
-            inner: self.0.clone(),
-        }
-    }
-
-    /// Notify all waiters
-    pub fn notify(&self) {
-        let inner = self.0.borrow();
-        for item in inner.data.iter() {
-            if let Some(waker) = item.1 {
-                waker.wake();
-            }
-        }
-    }
-}
-
-impl Drop for Condition {
-    fn drop(&mut self) {
-        self.notify()
-    }
-}
-
-#[must_use = "Waiter do nothing unless polled"]
-pub struct Waiter {
-    token: usize,
-    inner: Rc<RefCell<Inner>>,
-}
-
-impl Clone for Waiter {
-    fn clone(&self) -> Self {
-        let token = self.inner.borrow_mut().data.insert(None);
-        Waiter {
-            token,
-            inner: self.inner.clone(),
-        }
-    }
-}
-
-impl Future for Waiter {
-    type Output = ();
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.get_mut();
-
-        let mut inner = this.inner.borrow_mut();
-        let inner = unsafe { inner.data.get_unchecked_mut(this.token) };
-        if inner.is_none() {
-            let waker = LocalWaker::default();
-            waker.register(cx.waker());
-            *inner = Some(waker);
-            Poll::Pending
-        } else if inner.as_mut().unwrap().register(cx.waker()) {
-            Poll::Pending
-        } else {
-            Poll::Ready(())
-        }
-    }
-}
-
-impl Drop for Waiter {
-    fn drop(&mut self) {
-        self.inner.borrow_mut().data.remove(self.token);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use futures_util::future::lazy;
-
-    #[actix_rt::test]
-    async fn test_condition() {
-        let mut cond = Condition::new();
-        let mut waiter = cond.wait();
-        assert_eq!(
-            lazy(|cx| Pin::new(&mut waiter).poll(cx)).await,
-            Poll::Pending
-        );
-        cond.notify();
-        waiter.await;
-
-        let mut waiter = cond.wait();
-        assert_eq!(
-            lazy(|cx| Pin::new(&mut waiter).poll(cx)).await,
-            Poll::Pending
-        );
-        let mut waiter2 = waiter.clone();
-        assert_eq!(
-            lazy(|cx| Pin::new(&mut waiter2).poll(cx)).await,
-            Poll::Pending
-        );
-
-        drop(cond);
-        waiter.await;
-        waiter2.await;
-    }
-}

actix-utils/src/counter.rs

@@ -1,6 +1,7 @@
-use std::cell::Cell;
+use core::cell::Cell;
+use core::task;
+
 use std::rc::Rc;
-use std::task;
 
 use crate::task::LocalWaker;
 

actix-utils/src/dispatcher.rs

@@ -1,15 +1,17 @@
-//! Framed dispatcher service and related utilities
+//! Framed dispatcher service and related utilities.
 
 #![allow(type_alias_bounds)]
 
-use std::pin::Pin;
+use core::future::Future;
-use std::task::{Context, Poll};
+use core::pin::Pin;
-use std::{fmt, mem};
+use core::task::{Context, Poll};
+use core::{fmt, mem};
 
 use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use actix_service::{IntoService, Service};
-use futures_util::{future::Future, stream::Stream, FutureExt};
+use futures_core::stream::Stream;
 use log::debug;
+use pin_project_lite::pin_project;
 
 use crate::mpsc;
 
@@ -61,28 +63,35 @@ pub enum Message<T> {
     Close,
 }
 
-/// Dispatcher is a future that reads frames from Framed object
+pin_project! {
-/// and passes them to the service.
+    /// Dispatcher is a future that reads frames from Framed object
-#[pin_project::pin_project]
+    /// and passes them to the service.
-pub struct Dispatcher<S, T, U, I>
+    pub struct Dispatcher<S, T, U, I>
-where
+    where
-    S: Service<Request = <U as Decoder>::Item, Response = I>,
+        S: Service<<U as Decoder>::Item, Response = I>,
-    S::Error: 'static,
+        S::Error: 'static,
-    S::Future: 'static,
+        S::Future: 'static,
-    T: AsyncRead + AsyncWrite,
+        T: AsyncRead,
-    U: Encoder<I> + Decoder,
+        T: AsyncWrite,
-    I: 'static,
+        U: Encoder<I>,
-    <U as Encoder<I>>::Error: std::fmt::Debug,
+        U: Decoder,
-{
+        I: 'static,
-    service: S,
+        <U as Encoder<I>>::Error: fmt::Debug,
-    state: State<S, U, I>,
+    {
-    #[pin]
+        service: S,
-    framed: Framed<T, U>,
+        state: State<S, U, I>,
-    rx: mpsc::Receiver<Result<Message<I>, S::Error>>,
+        #[pin]
-    tx: mpsc::Sender<Result<Message<I>, S::Error>>,
+        framed: Framed<T, U>,
+        rx: mpsc::Receiver<Result<Message<I>, S::Error>>,
+        tx: mpsc::Sender<Result<Message<I>, S::Error>>,
+    }
 }
 
-enum State<S: Service, U: Encoder<I> + Decoder, I> {
+enum State<S, U, I>
+where
+    S: Service<<U as Decoder>::Item>,
+    U: Encoder<I> + Decoder,
+{
     Processing,
     Error(DispatcherError<S::Error, U, I>),
     FramedError(DispatcherError<S::Error, U, I>),
@@ -90,7 +99,11 @@ enum State<S: Service, U: Encoder<I> + Decoder, I> {
     Stopping,
 }
 
-impl<S: Service, U: Encoder<I> + Decoder, I> State<S, U, I> {
+impl<S, U, I> State<S, U, I>
+where
+    S: Service<<U as Decoder>::Item>,
+    U: Encoder<I> + Decoder,
+{
     fn take_error(&mut self) -> DispatcherError<S::Error, U, I> {
         match mem::replace(self, State::Processing) {
             State::Error(err) => err,
@@ -108,16 +121,19 @@ impl<S: Service, U: Encoder<I> + Decoder, I> State<S, U, I> {
 
 impl<S, T, U, I> Dispatcher<S, T, U, I>
 where
-    S: Service<Request = <U as Decoder>::Item, Response = I>,
+    S: Service<<U as Decoder>::Item, Response = I>,
     S::Error: 'static,
     S::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder<I>,
     I: 'static,
-    <U as Decoder>::Error: std::fmt::Debug,
+    <U as Decoder>::Error: fmt::Debug,
-    <U as Encoder<I>>::Error: std::fmt::Debug,
+    <U as Encoder<I>>::Error: fmt::Debug,
 {
-    pub fn new<F: IntoService<S>>(framed: Framed<T, U>, service: F) -> Self {
+    pub fn new<F>(framed: Framed<T, U>, service: F) -> Self
+    where
+        F: IntoService<S, <U as Decoder>::Item>,
+    {
         let (tx, rx) = mpsc::channel();
         Dispatcher {
             framed,
@@ -129,11 +145,14 @@ where
     }
 
     /// Construct new `Dispatcher` instance with customer `mpsc::Receiver`
-    pub fn with_rx<F: IntoService<S>>(
+    pub fn with_rx<F>(
         framed: Framed<T, U>,
         service: F,
         rx: mpsc::Receiver<Result<Message<I>, S::Error>>,
-    ) -> Self {
+    ) -> Self
+    where
+        F: IntoService<S, <U as Decoder>::Item>,
+    {
         let tx = rx.sender();
         Dispatcher {
             framed,
@@ -172,13 +191,13 @@ where
 
     fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> bool
     where
-        S: Service<Request = <U as Decoder>::Item, Response = I>,
+        S: Service<<U as Decoder>::Item, Response = I>,
         S::Error: 'static,
         S::Future: 'static,
         T: AsyncRead + AsyncWrite,
         U: Decoder + Encoder<I>,
         I: 'static,
-        <U as Encoder<I>>::Error: std::fmt::Debug,
+        <U as Encoder<I>>::Error: fmt::Debug,
     {
         loop {
             let this = self.as_mut().project();
@@ -198,9 +217,11 @@ where
                     };
 
                     let tx = this.tx.clone();
-                    actix_rt::spawn(this.service.call(item).map(move |item| {
+                    let fut = this.service.call(item);
+                    actix_rt::spawn(async move {
+                        let item = fut.await;
                         let _ = tx.send(item.map(Message::Item));
-                    }));
+                    });
                 }
                 Poll::Pending => return false,
                 Poll::Ready(Err(err)) => {
@@ -214,13 +235,13 @@ where
     /// write to framed object
     fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> bool
     where
-        S: Service<Request = <U as Decoder>::Item, Response = I>,
+        S: Service<<U as Decoder>::Item, Response = I>,
         S::Error: 'static,
         S::Future: 'static,
         T: AsyncRead + AsyncWrite,
         U: Decoder + Encoder<I>,
         I: 'static,
-        <U as Encoder<I>>::Error: std::fmt::Debug,
+        <U as Encoder<I>>::Error: fmt::Debug,
     {
         loop {
             let mut this = self.as_mut().project();
@@ -265,14 +286,14 @@ where
 
 impl<S, T, U, I> Future for Dispatcher<S, T, U, I>
 where
-    S: Service<Request = <U as Decoder>::Item, Response = I>,
+    S: Service<<U as Decoder>::Item, Response = I>,
     S::Error: 'static,
     S::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder<I>,
     I: 'static,
-    <U as Encoder<I>>::Error: std::fmt::Debug,
+    <U as Encoder<I>>::Error: fmt::Debug,
-    <U as Decoder>::Error: std::fmt::Debug,
+    <U as Decoder>::Error: fmt::Debug,
 {
     type Output = Result<(), DispatcherError<S::Error, U, I>>;
 
@@ -290,10 +311,8 @@ where
                 }
                 State::Error(_) => {
                     // flush write buffer
-                    if !this.framed.is_write_buf_empty() {
+                    if !this.framed.is_write_buf_empty() && this.framed.flush(cx).is_pending() {
-                        if let Poll::Pending = this.framed.flush(cx) {
+                        return Poll::Pending;
-                            return Poll::Pending;
-                        }
                     }
                     Poll::Ready(Err(this.state.take_error()))
                 }

actix-utils/src/either.rs

@@ -1,153 +0,0 @@
-//! Contains `Either` service and related types and functions.
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use actix_service::{Service, ServiceFactory};
-use futures_util::{future, future::Future, ready};
-
-/// Combine two different service types into a single type.
-///
-/// Both services must be of the same request, response, and error types.
-/// `EitherService` is useful for handling conditional branching in service
-/// middleware to different inner service types.
-pub struct EitherService<A, B> {
-    left: A,
-    right: B,
-}
-
-impl<A: Clone, B: Clone> Clone for EitherService<A, B> {
-    fn clone(&self) -> Self {
-        EitherService {
-            left: self.left.clone(),
-            right: self.right.clone(),
-        }
-    }
-}
-
-impl<A, B> Service for EitherService<A, B>
-where
-    A: Service,
-    B: Service<Response = A::Response, Error = A::Error>,
-{
-    type Request = either::Either<A::Request, B::Request>;
-    type Response = A::Response;
-    type Error = A::Error;
-    type Future = future::Either<A::Future, B::Future>;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        let left = self.left.poll_ready(cx)?;
-        let right = self.right.poll_ready(cx)?;
-
-        if left.is_ready() && right.is_ready() {
-            Poll::Ready(Ok(()))
-        } else {
-            Poll::Pending
-        }
-    }
-
-    fn call(&mut self, req: either::Either<A::Request, B::Request>) -> Self::Future {
-        match req {
-            either::Either::Left(req) => future::Either::Left(self.left.call(req)),
-            either::Either::Right(req) => future::Either::Right(self.right.call(req)),
-        }
-    }
-}
-
-/// Combine two different new service types into a single service.
-pub struct Either<A, B> {
-    left: A,
-    right: B,
-}
-
-impl<A, B> Either<A, B> {
-    pub fn new(left: A, right: B) -> Either<A, B>
-    where
-        A: ServiceFactory,
-        A::Config: Clone,
-        B: ServiceFactory<
-            Config = A::Config,
-            Response = A::Response,
-            Error = A::Error,
-            InitError = A::InitError,
-        >,
-    {
-        Either { left, right }
-    }
-}
-
-impl<A, B> ServiceFactory for Either<A, B>
-where
-    A: ServiceFactory,
-    A::Config: Clone,
-    B: ServiceFactory<
-        Config = A::Config,
-        Response = A::Response,
-        Error = A::Error,
-        InitError = A::InitError,
-    >,
-{
-    type Request = either::Either<A::Request, B::Request>;
-    type Response = A::Response;
-    type Error = A::Error;
-    type InitError = A::InitError;
-    type Config = A::Config;
-    type Service = EitherService<A::Service, B::Service>;
-    type Future = EitherNewService<A, B>;
-
-    fn new_service(&self, cfg: A::Config) -> Self::Future {
-        EitherNewService {
-            left: None,
-            right: None,
-            left_fut: self.left.new_service(cfg.clone()),
-            right_fut: self.right.new_service(cfg),
-        }
-    }
-}
-
-impl<A: Clone, B: Clone> Clone for Either<A, B> {
-    fn clone(&self) -> Self {
-        Self {
-            left: self.left.clone(),
-            right: self.right.clone(),
-        }
-    }
-}
-
-#[doc(hidden)]
-#[pin_project::pin_project]
-pub struct EitherNewService<A: ServiceFactory, B: ServiceFactory> {
-    left: Option<A::Service>,
-    right: Option<B::Service>,
-    #[pin]
-    left_fut: A::Future,
-    #[pin]
-    right_fut: B::Future,
-}
-
-impl<A, B> Future for EitherNewService<A, B>
-where
-    A: ServiceFactory,
-    B: ServiceFactory<Response = A::Response, Error = A::Error, InitError = A::InitError>,
-{
-    type Output = Result<EitherService<A::Service, B::Service>, A::InitError>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-
-        if this.left.is_none() {
-            *this.left = Some(ready!(this.left_fut.poll(cx))?);
-        }
-        if this.right.is_none() {
-            *this.right = Some(ready!(this.right_fut.poll(cx))?);
-        }
-
-        if this.left.is_some() && this.right.is_some() {
-            Poll::Ready(Ok(EitherService {
-                left: this.left.take().unwrap(),
-                right: this.right.take().unwrap(),
-            }))
-        } else {
-            Poll::Pending
-        }
-    }
-}

actix-utils/src/inflight.rs

@@ -1,169 +0,0 @@
-use std::convert::Infallible;
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use actix_service::{IntoService, Service, Transform};
-use futures_util::future::{ok, Ready};
-
-use super::counter::{Counter, CounterGuard};
-
-/// InFlight - new service for service that can limit number of in-flight
-/// async requests.
-///
-/// Default number of in-flight requests is 15
-pub struct InFlight {
-    max_inflight: usize,
-}
-
-impl InFlight {
-    pub fn new(max: usize) -> Self {
-        Self { max_inflight: max }
-    }
-}
-
-impl Default for InFlight {
-    fn default() -> Self {
-        Self::new(15)
-    }
-}
-
-impl<S> Transform<S> for InFlight
-where
-    S: Service,
-{
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = S::Error;
-    type InitError = Infallible;
-    type Transform = InFlightService<S>;
-    type Future = Ready<Result<Self::Transform, Self::InitError>>;
-
-    fn new_transform(&self, service: S) -> Self::Future {
-        ok(InFlightService::new(self.max_inflight, service))
-    }
-}
-
-pub struct InFlightService<S> {
-    count: Counter,
-    service: S,
-}
-
-impl<S> InFlightService<S>
-where
-    S: Service,
-{
-    pub fn new<U>(max: usize, service: U) -> Self
-    where
-        U: IntoService<S>,
-    {
-        Self {
-            count: Counter::new(max),
-            service: service.into_service(),
-        }
-    }
-}
-
-impl<T> Service for InFlightService<T>
-where
-    T: Service,
-{
-    type Request = T::Request;
-    type Response = T::Response;
-    type Error = T::Error;
-    type Future = InFlightServiceResponse<T>;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        if let Poll::Pending = self.service.poll_ready(cx)? {
-            Poll::Pending
-        } else if !self.count.available(cx) {
-            log::trace!("InFlight limit exceeded");
-            Poll::Pending
-        } else {
-            Poll::Ready(Ok(()))
-        }
-    }
-
-    fn call(&mut self, req: T::Request) -> Self::Future {
-        InFlightServiceResponse {
-            fut: self.service.call(req),
-            _guard: self.count.get(),
-        }
-    }
-}
-
-#[doc(hidden)]
-#[pin_project::pin_project]
-pub struct InFlightServiceResponse<T: Service> {
-    #[pin]
-    fut: T::Future,
-    _guard: CounterGuard,
-}
-
-impl<T: Service> Future for InFlightServiceResponse<T> {
-    type Output = Result<T::Response, T::Error>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        self.project().fut.poll(cx)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use std::task::{Context, Poll};
-    use std::time::Duration;
-
-    use super::*;
-    use actix_service::{apply, fn_factory, Service, ServiceFactory};
-    use futures_util::future::{lazy, ok, FutureExt, LocalBoxFuture};
-
-    struct SleepService(Duration);
-
-    impl Service for SleepService {
-        type Request = ();
-        type Response = ();
-        type Error = ();
-        type Future = LocalBoxFuture<'static, Result<(), ()>>;
-
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-
-        fn call(&mut self, _: ()) -> Self::Future {
-            actix_rt::time::delay_for(self.0)
-                .then(|_| ok::<_, ()>(()))
-                .boxed_local()
-        }
-    }
-
-    #[actix_rt::test]
-    async fn test_transform() {
-        let wait_time = Duration::from_millis(50);
-
-        let mut srv = InFlightService::new(1, SleepService(wait_time));
-        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
-
-        let res = srv.call(());
-        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Pending);
-
-        let _ = res.await;
-        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
-    }
-
-    #[actix_rt::test]
-    async fn test_new_transform() {
-        let wait_time = Duration::from_millis(50);
-
-        let srv = apply(InFlight::new(1), fn_factory(|| ok(SleepService(wait_time))));
-
-        let mut srv = srv.new_service(&()).await.unwrap();
-        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
-
-        let res = srv.call(());
-        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Pending);
-
-        let _ = res.await;
-        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
-    }
-}

actix-utils/src/keepalive.rs

@@ -1,125 +0,0 @@
-use std::convert::Infallible;
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::time::Duration;
-
-use actix_rt::time::{delay_until, Delay, Instant};
-use actix_service::{Service, ServiceFactory};
-use futures_util::future::{ok, Ready};
-
-use super::time::{LowResTime, LowResTimeService};
-
-pub struct KeepAlive<R, E, F> {
-    f: F,
-    ka: Duration,
-    time: LowResTime,
-    _t: PhantomData<(R, E)>,
-}
-
-impl<R, E, F> KeepAlive<R, E, F>
-where
-    F: Fn() -> E + Clone,
-{
-    pub fn new(ka: Duration, time: LowResTime, f: F) -> Self {
-        KeepAlive {
-            f,
-            ka,
-            time,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<R, E, F> Clone for KeepAlive<R, E, F>
-where
-    F: Clone,
-{
-    fn clone(&self) -> Self {
-        KeepAlive {
-            f: self.f.clone(),
-            ka: self.ka,
-            time: self.time.clone(),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<R, E, F> ServiceFactory for KeepAlive<R, E, F>
-where
-    F: Fn() -> E + Clone,
-{
-    type Request = R;
-    type Response = R;
-    type Error = E;
-    type InitError = Infallible;
-    type Config = ();
-    type Service = KeepAliveService<R, E, F>;
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        ok(KeepAliveService::new(
-            self.ka,
-            self.time.timer(),
-            self.f.clone(),
-        ))
-    }
-}
-
-pub struct KeepAliveService<R, E, F> {
-    f: F,
-    ka: Duration,
-    time: LowResTimeService,
-    delay: Delay,
-    expire: Instant,
-    _t: PhantomData<(R, E)>,
-}
-
-impl<R, E, F> KeepAliveService<R, E, F>
-where
-    F: Fn() -> E,
-{
-    pub fn new(ka: Duration, time: LowResTimeService, f: F) -> Self {
-        let expire = Instant::from_std(time.now() + ka);
-        KeepAliveService {
-            f,
-            ka,
-            time,
-            expire,
-            delay: delay_until(expire),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<R, E, F> Service for KeepAliveService<R, E, F>
-where
-    F: Fn() -> E,
-{
-    type Request = R;
-    type Response = R;
-    type Error = E;
-    type Future = Ready<Result<R, E>>;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        match Pin::new(&mut self.delay).poll(cx) {
-            Poll::Ready(_) => {
-                let now = Instant::from_std(self.time.now());
-                if self.expire <= now {
-                    Poll::Ready(Err((self.f)()))
-                } else {
-                    self.delay.reset(self.expire);
-                    let _ = Pin::new(&mut self.delay).poll(cx);
-                    Poll::Ready(Ok(()))
-                }
-            }
-            Poll::Pending => Poll::Ready(Ok(())),
-        }
-    }
-
-    fn call(&mut self, req: R) -> Self::Future {
-        self.expire = Instant::from_std(self.time.now() + self.ka);
-        ok(req)
-    }
-}

actix-utils/src/lib.rs

@@ -1,18 +1,12 @@
 //! Actix utils - various helper services
 
-#![deny(rust_2018_idioms)]
+#![deny(rust_2018_idioms, nonstandard_style)]
 #![allow(clippy::type_complexity)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 
-pub mod condition;
 pub mod counter;
 pub mod dispatcher;
-pub mod either;
-pub mod inflight;
-pub mod keepalive;
 pub mod mpsc;
-pub mod oneshot;
-pub mod order;
-pub mod stream;
 pub mod task;
-pub mod time;
 pub mod timeout;

actix-utils/src/mpsc.rs

@@ -1,15 +1,16 @@
 //! A multi-producer, single-consumer, futures-aware, FIFO queue.
-use std::any::Any;
+use core::any::Any;
-use std::cell::RefCell;
+use core::cell::RefCell;
+use core::fmt;
+use core::pin::Pin;
+use core::task::{Context, Poll};
+
 use std::collections::VecDeque;
 use std::error::Error;
-use std::fmt;
-use std::pin::Pin;
 use std::rc::Rc;
-use std::task::{Context, Poll};
 
+use futures_core::stream::Stream;
 use futures_sink::Sink;
-use futures_util::stream::Stream;
 
 use crate::task::LocalWaker;
 

actix-utils/src/oneshot.rs

@@ -1,316 +0,0 @@
-//! A one-shot, futures-aware channel.
-use std::cell::RefCell;
-use std::future::Future;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::task::{Context, Poll};
-
-pub use futures_channel::oneshot::Canceled;
-use slab::Slab;
-
-use crate::task::LocalWaker;
-
-/// Creates a new futures-aware, one-shot channel.
-pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
-    let inner = Rc::new(RefCell::new(Inner {
-        value: None,
-        rx_task: LocalWaker::new(),
-    }));
-    let tx = Sender {
-        inner: inner.clone(),
-    };
-    let rx = Receiver { inner };
-    (tx, rx)
-}
-
-/// Creates a new futures-aware, pool of one-shot's.
-pub fn pool<T>() -> Pool<T> {
-    Pool(Rc::new(RefCell::new(Slab::new())))
-}
-
-/// Represents the completion half of a oneshot through which the result of a
-/// computation is signaled.
-#[derive(Debug)]
-pub struct Sender<T> {
-    inner: Rc<RefCell<Inner<T>>>,
-}
-
-/// A future representing the completion of a computation happening elsewhere in
-/// memory.
-#[derive(Debug)]
-#[must_use = "futures do nothing unless polled"]
-pub struct Receiver<T> {
-    inner: Rc<RefCell<Inner<T>>>,
-}
-
-// The channels do not ever project Pin to the inner T
-impl<T> Unpin for Receiver<T> {}
-impl<T> Unpin for Sender<T> {}
-
-#[derive(Debug)]
-struct Inner<T> {
-    value: Option<T>,
-    rx_task: LocalWaker,
-}
-
-impl<T> Sender<T> {
-    /// Completes this oneshot with a successful result.
-    ///
-    /// This function will consume `self` and indicate to the other end, the
-    /// `Receiver`, that the error provided is the result of the computation this
-    /// represents.
-    ///
-    /// If the value is successfully enqueued for the remote end to receive,
-    /// then `Ok(())` is returned. If the receiving end was dropped before
-    /// this function was called, however, then `Err` is returned with the value
-    /// provided.
-    pub fn send(self, val: T) -> Result<(), T> {
-        if Rc::strong_count(&self.inner) == 2 {
-            let mut inner = self.inner.borrow_mut();
-            inner.value = Some(val);
-            inner.rx_task.wake();
-            Ok(())
-        } else {
-            Err(val)
-        }
-    }
-
-    /// Tests to see whether this `Sender`'s corresponding `Receiver`
-    /// has gone away.
-    pub fn is_canceled(&self) -> bool {
-        Rc::strong_count(&self.inner) == 1
-    }
-}
-
-impl<T> Drop for Sender<T> {
-    fn drop(&mut self) {
-        self.inner.borrow().rx_task.wake();
-    }
-}
-
-impl<T> Future for Receiver<T> {
-    type Output = Result<T, Canceled>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.get_mut();
-
-        // If we've got a value, then skip the logic below as we're done.
-        if let Some(val) = this.inner.borrow_mut().value.take() {
-            return Poll::Ready(Ok(val));
-        }
-
-        // Check if sender is dropped and return error if it is.
-        if Rc::strong_count(&this.inner) == 1 {
-            Poll::Ready(Err(Canceled))
-        } else {
-            this.inner.borrow().rx_task.register(cx.waker());
-            Poll::Pending
-        }
-    }
-}
-
-/// Futures-aware, pool of one-shot's.
-pub struct Pool<T>(Rc<RefCell<Slab<PoolInner<T>>>>);
-
-bitflags::bitflags! {
-    pub struct Flags: u8 {
-        const SENDER = 0b0000_0001;
-        const RECEIVER = 0b0000_0010;
-    }
-}
-
-#[derive(Debug)]
-struct PoolInner<T> {
-    flags: Flags,
-    value: Option<T>,
-    waker: LocalWaker,
-}
-
-impl<T> Pool<T> {
-    pub fn channel(&mut self) -> (PSender<T>, PReceiver<T>) {
-        let token = self.0.borrow_mut().insert(PoolInner {
-            flags: Flags::all(),
-            value: None,
-            waker: LocalWaker::default(),
-        });
-
-        (
-            PSender {
-                token,
-                inner: self.0.clone(),
-            },
-            PReceiver {
-                token,
-                inner: self.0.clone(),
-            },
-        )
-    }
-}
-
-impl<T> Clone for Pool<T> {
-    fn clone(&self) -> Self {
-        Pool(self.0.clone())
-    }
-}
-
-/// Represents the completion half of a oneshot through which the result of a
-/// computation is signaled.
-#[derive(Debug)]
-pub struct PSender<T> {
-    token: usize,
-    inner: Rc<RefCell<Slab<PoolInner<T>>>>,
-}
-
-/// A future representing the completion of a computation happening elsewhere in
-/// memory.
-#[derive(Debug)]
-#[must_use = "futures do nothing unless polled"]
-pub struct PReceiver<T> {
-    token: usize,
-    inner: Rc<RefCell<Slab<PoolInner<T>>>>,
-}
-
-// The one-shots do not ever project Pin to the inner T
-impl<T> Unpin for PReceiver<T> {}
-impl<T> Unpin for PSender<T> {}
-
-impl<T> PSender<T> {
-    /// Completes this oneshot with a successful result.
-    ///
-    /// This function will consume `self` and indicate to the other end, the
-    /// `Receiver`, that the error provided is the result of the computation this
-    /// represents.
-    ///
-    /// If the value is successfully enqueued for the remote end to receive,
-    /// then `Ok(())` is returned. If the receiving end was dropped before
-    /// this function was called, however, then `Err` is returned with the value
-    /// provided.
-    pub fn send(self, val: T) -> Result<(), T> {
-        let mut inner = self.inner.borrow_mut();
-        let inner = unsafe { inner.get_unchecked_mut(self.token) };
-
-        if inner.flags.contains(Flags::RECEIVER) {
-            inner.value = Some(val);
-            inner.waker.wake();
-            Ok(())
-        } else {
-            Err(val)
-        }
-    }
-
-    /// Tests to see whether this `Sender`'s corresponding `Receiver`
-    /// has gone away.
-    pub fn is_canceled(&self) -> bool {
-        !unsafe { self.inner.borrow().get_unchecked(self.token) }
-            .flags
-            .contains(Flags::RECEIVER)
-    }
-}
-
-impl<T> Drop for PSender<T> {
-    fn drop(&mut self) {
-        let mut inner = self.inner.borrow_mut();
-        let inner_token = unsafe { inner.get_unchecked_mut(self.token) };
-        if inner_token.flags.contains(Flags::RECEIVER) {
-            inner_token.waker.wake();
-            inner_token.flags.remove(Flags::SENDER);
-        } else {
-            inner.remove(self.token);
-        }
-    }
-}
-
-impl<T> Drop for PReceiver<T> {
-    fn drop(&mut self) {
-        let mut inner = self.inner.borrow_mut();
-        let inner_token = unsafe { inner.get_unchecked_mut(self.token) };
-        if inner_token.flags.contains(Flags::SENDER) {
-            inner_token.flags.remove(Flags::RECEIVER);
-        } else {
-            inner.remove(self.token);
-        }
-    }
-}
-
-impl<T> Future for PReceiver<T> {
-    type Output = Result<T, Canceled>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.get_mut();
-        let mut inner = this.inner.borrow_mut();
-        let inner = unsafe { inner.get_unchecked_mut(this.token) };
-
-        // If we've got a value, then skip the logic below as we're done.
-        if let Some(val) = inner.value.take() {
-            return Poll::Ready(Ok(val));
-        }
-
-        // Check if sender is dropped and return error if it is.
-        if !inner.flags.contains(Flags::SENDER) {
-            Poll::Ready(Err(Canceled))
-        } else {
-            inner.waker.register(cx.waker());
-            Poll::Pending
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use futures_util::future::lazy;
-
-    #[actix_rt::test]
-    async fn test_oneshot() {
-        let (tx, rx) = channel();
-        tx.send("test").unwrap();
-        assert_eq!(rx.await.unwrap(), "test");
-
-        let (tx, rx) = channel();
-        assert!(!tx.is_canceled());
-        drop(rx);
-        assert!(tx.is_canceled());
-        assert!(tx.send("test").is_err());
-
-        let (tx, rx) = channel::<&'static str>();
-        drop(tx);
-        assert!(rx.await.is_err());
-
-        let (tx, mut rx) = channel::<&'static str>();
-        assert_eq!(lazy(|cx| Pin::new(&mut rx).poll(cx)).await, Poll::Pending);
-        tx.send("test").unwrap();
-        assert_eq!(rx.await.unwrap(), "test");
-
-        let (tx, mut rx) = channel::<&'static str>();
-        assert_eq!(lazy(|cx| Pin::new(&mut rx).poll(cx)).await, Poll::Pending);
-        drop(tx);
-        assert!(rx.await.is_err());
-    }
-
-    #[actix_rt::test]
-    async fn test_pool() {
-        let (tx, rx) = pool().channel();
-        tx.send("test").unwrap();
-        assert_eq!(rx.await.unwrap(), "test");
-
-        let (tx, rx) = pool().channel();
-        assert!(!tx.is_canceled());
-        drop(rx);
-        assert!(tx.is_canceled());
-        assert!(tx.send("test").is_err());
-
-        let (tx, rx) = pool::<&'static str>().channel();
-        drop(tx);
-        assert!(rx.await.is_err());
-
-        let (tx, mut rx) = pool::<&'static str>().channel();
-        assert_eq!(lazy(|cx| Pin::new(&mut rx).poll(cx)).await, Poll::Pending);
-        tx.send("test").unwrap();
-        assert_eq!(rx.await.unwrap(), "test");
-
-        let (tx, mut rx) = pool::<&'static str>().channel();
-        assert_eq!(lazy(|cx| Pin::new(&mut rx).poll(cx)).await, Poll::Pending);
-        drop(tx);
-        assert!(rx.await.is_err());
-    }
-}

actix-utils/src/order.rs

@@ -1,278 +0,0 @@
-use std::collections::VecDeque;
-use std::convert::Infallible;
-use std::fmt;
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::task::{Context, Poll};
-
-use actix_service::{IntoService, Service, Transform};
-use futures_util::future::{ok, Ready};
-
-use crate::oneshot;
-use crate::task::LocalWaker;
-
-struct Record<I, E> {
-    rx: oneshot::Receiver<Result<I, E>>,
-    tx: oneshot::Sender<Result<I, E>>,
-}
-
-/// Timeout error
-pub enum InOrderError<E> {
-    /// Service error
-    Service(E),
-    /// Service call dropped
-    Disconnected,
-}
-
-impl<E> From<E> for InOrderError<E> {
-    fn from(err: E) -> Self {
-        InOrderError::Service(err)
-    }
-}
-
-impl<E: fmt::Debug> fmt::Debug for InOrderError<E> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            InOrderError::Service(e) => write!(f, "InOrderError::Service({:?})", e),
-            InOrderError::Disconnected => write!(f, "InOrderError::Disconnected"),
-        }
-    }
-}
-
-impl<E: fmt::Display> fmt::Display for InOrderError<E> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            InOrderError::Service(e) => e.fmt(f),
-            InOrderError::Disconnected => write!(f, "InOrder service disconnected"),
-        }
-    }
-}
-
-/// InOrder - The service will yield responses as they become available,
-/// in the order that their originating requests were submitted to the service.
-pub struct InOrder<S> {
-    _t: PhantomData<S>,
-}
-
-impl<S> InOrder<S>
-where
-    S: Service,
-    S::Response: 'static,
-    S::Future: 'static,
-    S::Error: 'static,
-{
-    pub fn new() -> Self {
-        Self { _t: PhantomData }
-    }
-
-    pub fn service(service: S) -> InOrderService<S> {
-        InOrderService::new(service)
-    }
-}
-
-impl<S> Default for InOrder<S>
-where
-    S: Service,
-    S::Response: 'static,
-    S::Future: 'static,
-    S::Error: 'static,
-{
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<S> Transform<S> for InOrder<S>
-where
-    S: Service,
-    S::Response: 'static,
-    S::Future: 'static,
-    S::Error: 'static,
-{
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = InOrderError<S::Error>;
-    type InitError = Infallible;
-    type Transform = InOrderService<S>;
-    type Future = Ready<Result<Self::Transform, Self::InitError>>;
-
-    fn new_transform(&self, service: S) -> Self::Future {
-        ok(InOrderService::new(service))
-    }
-}
-
-pub struct InOrderService<S: Service> {
-    service: S,
-    waker: Rc<LocalWaker>,
-    acks: VecDeque<Record<S::Response, S::Error>>,
-}
-
-impl<S> InOrderService<S>
-where
-    S: Service,
-    S::Response: 'static,
-    S::Future: 'static,
-    S::Error: 'static,
-{
-    pub fn new<U>(service: U) -> Self
-    where
-        U: IntoService<S>,
-    {
-        Self {
-            service: service.into_service(),
-            acks: VecDeque::new(),
-            waker: Rc::new(LocalWaker::new()),
-        }
-    }
-}
-
-impl<S> Service for InOrderService<S>
-where
-    S: Service,
-    S::Response: 'static,
-    S::Future: 'static,
-    S::Error: 'static,
-{
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = InOrderError<S::Error>;
-    type Future = InOrderServiceResponse<S>;
-
-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        // poll_ready could be called from different task
-        self.waker.register(cx.waker());
-
-        // check acks
-        while !self.acks.is_empty() {
-            let rec = self.acks.front_mut().unwrap();
-            match Pin::new(&mut rec.rx).poll(cx) {
-                Poll::Ready(Ok(res)) => {
-                    let rec = self.acks.pop_front().unwrap();
-                    let _ = rec.tx.send(res);
-                }
-                Poll::Pending => break,
-                Poll::Ready(Err(oneshot::Canceled)) => {
-                    return Poll::Ready(Err(InOrderError::Disconnected))
-                }
-            }
-        }
-
-        // check nested service
-        if let Poll::Pending = self.service.poll_ready(cx).map_err(InOrderError::Service)? {
-            Poll::Pending
-        } else {
-            Poll::Ready(Ok(()))
-        }
-    }
-
-    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 waker = self.waker.clone();
-        let fut = self.service.call(request);
-        actix_rt::spawn(async move {
-            let res = fut.await;
-            waker.wake();
-            let _ = tx1.send(res);
-        });
-
-        InOrderServiceResponse { rx: rx2 }
-    }
-}
-
-#[doc(hidden)]
-pub struct InOrderServiceResponse<S: Service> {
-    rx: oneshot::Receiver<Result<S::Response, S::Error>>,
-}
-
-impl<S: Service> Future for InOrderServiceResponse<S> {
-    type Output = Result<S::Response, InOrderError<S::Error>>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match Pin::new(&mut self.rx).poll(cx) {
-            Poll::Pending => Poll::Pending,
-            Poll::Ready(Ok(Ok(res))) => Poll::Ready(Ok(res)),
-            Poll::Ready(Ok(Err(e))) => Poll::Ready(Err(e.into())),
-            Poll::Ready(Err(_)) => Poll::Ready(Err(InOrderError::Disconnected)),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use std::task::{Context, Poll};
-    use std::time::Duration;
-
-    use super::*;
-    use actix_service::Service;
-    use futures_channel::oneshot;
-    use futures_util::future::{lazy, poll_fn, FutureExt, LocalBoxFuture};
-
-    struct Srv;
-
-    impl Service for Srv {
-        type Request = oneshot::Receiver<usize>;
-        type Response = usize;
-        type Error = ();
-        type Future = LocalBoxFuture<'static, Result<usize, ()>>;
-
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            Poll::Ready(Ok(()))
-        }
-
-        fn call(&mut self, req: oneshot::Receiver<usize>) -> Self::Future {
-            req.map(|res| res.map_err(|_| ())).boxed_local()
-        }
-    }
-
-    #[actix_rt::test]
-    async fn test_in_order() {
-        let (tx1, rx1) = oneshot::channel();
-        let (tx2, rx2) = oneshot::channel();
-        let (tx3, rx3) = oneshot::channel();
-        let (tx_stop, rx_stop) = oneshot::channel();
-
-        let h = std::thread::spawn(move || {
-            let rx1 = rx1;
-            let rx2 = rx2;
-            let rx3 = rx3;
-            let tx_stop = tx_stop;
-            actix_rt::System::new("test").block_on(async {
-                let mut srv = InOrderService::new(Srv);
-
-                let _ = lazy(|cx| srv.poll_ready(cx)).await;
-                let res1 = srv.call(rx1);
-                let res2 = srv.call(rx2);
-                let res3 = srv.call(rx3);
-
-                actix_rt::spawn(async move {
-                    poll_fn(|cx| {
-                        let _ = srv.poll_ready(cx);
-                        Poll::<()>::Pending
-                    })
-                    .await;
-                });
-
-                assert_eq!(res1.await.unwrap(), 1);
-                assert_eq!(res2.await.unwrap(), 2);
-                assert_eq!(res3.await.unwrap(), 3);
-
-                let _ = tx_stop.send(());
-                actix_rt::System::current().stop();
-            });
-        });
-
-        let _ = tx3.send(3);
-        std::thread::sleep(Duration::from_millis(50));
-        let _ = tx2.send(2);
-        let _ = tx1.send(1);
-
-        let _ = rx_stop.await;
-        let _ = h.join();
-    }
-}

actix-utils/src/stream.rs

@@ -1,76 +0,0 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use actix_service::{IntoService, Service};
-use futures_util::{stream::Stream, FutureExt};
-
-use crate::mpsc;
-
-#[pin_project::pin_project]
-pub struct Dispatcher<S, T>
-where
-    S: Stream,
-    T: Service<Request = S::Item, Response = ()> + 'static,
-{
-    #[pin]
-    stream: S,
-    service: T,
-    err_rx: mpsc::Receiver<T::Error>,
-    err_tx: mpsc::Sender<T::Error>,
-}
-
-impl<S, T> Dispatcher<S, T>
-where
-    S: Stream,
-    T: Service<Request = S::Item, Response = ()> + 'static,
-{
-    pub fn new<F>(stream: S, service: F) -> Self
-    where
-        F: IntoService<T>,
-    {
-        let (err_tx, err_rx) = mpsc::channel();
-        Dispatcher {
-            err_rx,
-            err_tx,
-            stream,
-            service: service.into_service(),
-        }
-    }
-}
-
-impl<S, T> Future for Dispatcher<S, T>
-where
-    S: Stream,
-    T: Service<Request = S::Item, Response = ()> + 'static,
-{
-    type Output = Result<(), T::Error>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.as_mut().project();
-
-        if let Poll::Ready(Some(e)) = Pin::new(&mut this.err_rx).poll_next(cx) {
-            return Poll::Ready(Err(e));
-        }
-
-        loop {
-            return match this.service.poll_ready(cx)? {
-                Poll::Ready(_) => match this.stream.poll_next(cx) {
-                    Poll::Ready(Some(item)) => {
-                        let stop = this.err_tx.clone();
-                        actix_rt::spawn(this.service.call(item).map(move |res| {
-                            if let Err(e) = res {
-                                let _ = stop.send(e);
-                            }
-                        }));
-                        this = self.as_mut().project();
-                        continue;
-                    }
-                    Poll::Pending => Poll::Pending,
-                    Poll::Ready(None) => Poll::Ready(Ok(())),
-                },
-                Poll::Pending => Poll::Pending,
-            };
-        }
-    }
-}

actix-utils/src/task.rs

@@ -1,7 +1,7 @@
-use std::cell::UnsafeCell;
+use core::cell::UnsafeCell;
-use std::marker::PhantomData;
+use core::fmt;
-use std::task::Waker;
+use core::marker::PhantomData;
-use std::{fmt, rc};
+use core::task::Waker;
 
 /// A synchronization primitive for task wakeup.
 ///
@@ -19,10 +19,12 @@ use std::{fmt, rc};
 ///
 /// A single `AtomicWaker` may be reused for any number of calls to `register` or
 /// `wake`.
+// TODO: Refactor to Cell when remove deprecated methods (@botika)
 #[derive(Default)]
 pub struct LocalWaker {
     pub(crate) waker: UnsafeCell<Option<Waker>>,
-    _t: PhantomData<rc::Rc<()>>,
+    // mark LocalWaker as a !Send type.
+    _t: PhantomData<*const ()>,
 }
 
 impl LocalWaker {
@@ -34,6 +36,10 @@ impl LocalWaker {
         }
     }
 
+    #[deprecated(
+        since = "2.1.0",
+        note = "In favor of `wake`. State of the register doesn't matter at `wake` up"
+    )]
     #[inline]
     /// Check if waker has been registered.
     pub fn is_registered(&self) -> bool {
@@ -47,9 +53,8 @@ impl LocalWaker {
     pub fn register(&self, waker: &Waker) -> bool {
         unsafe {
             let w = self.waker.get();
-            let is_registered = (*w).is_some();
+            let last_waker = w.replace(Some(waker.clone()));
-            *w = Some(waker.clone());
+            last_waker.is_some()
-            is_registered
         }
     }
 
@@ -63,6 +68,7 @@ impl LocalWaker {
         }
     }
 
+    #[inline]
     /// Returns the last `Waker` passed to `register`, so that the user can wake it.
     ///
     /// If a waker has not been registered, this returns `None`.

actix-utils/src/time.rs

@@ -1,225 +0,0 @@
-use std::cell::RefCell;
-use std::convert::Infallible;
-use std::rc::Rc;
-use std::task::{Context, Poll};
-use std::time::{self, Duration, Instant};
-
-use actix_rt::time::delay_for;
-use actix_service::{Service, ServiceFactory};
-use futures_util::future::{ok, ready, FutureExt, Ready};
-
-#[derive(Clone, Debug)]
-pub struct LowResTime(Rc<RefCell<Inner>>);
-
-#[derive(Debug)]
-struct Inner {
-    resolution: Duration,
-    current: Option<Instant>,
-}
-
-impl Inner {
-    fn new(resolution: Duration) -> Self {
-        Inner {
-            resolution,
-            current: None,
-        }
-    }
-}
-
-impl LowResTime {
-    pub fn with(resolution: Duration) -> LowResTime {
-        LowResTime(Rc::new(RefCell::new(Inner::new(resolution))))
-    }
-
-    pub fn timer(&self) -> LowResTimeService {
-        LowResTimeService(self.0.clone())
-    }
-}
-
-impl Default for LowResTime {
-    fn default() -> Self {
-        LowResTime(Rc::new(RefCell::new(Inner::new(Duration::from_secs(1)))))
-    }
-}
-
-impl ServiceFactory for LowResTime {
-    type Request = ();
-    type Response = Instant;
-    type Error = Infallible;
-    type InitError = Infallible;
-    type Config = ();
-    type Service = LowResTimeService;
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: ()) -> Self::Future {
-        ok(self.timer())
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct LowResTimeService(Rc<RefCell<Inner>>);
-
-impl LowResTimeService {
-    pub fn with(resolution: Duration) -> LowResTimeService {
-        LowResTimeService(Rc::new(RefCell::new(Inner::new(resolution))))
-    }
-
-    /// Get current time. This function has to be called from
-    /// future's poll method, otherwise it panics.
-    pub fn now(&self) -> Instant {
-        let cur = self.0.borrow().current;
-        if let Some(cur) = cur {
-            cur
-        } else {
-            let now = Instant::now();
-            let inner = self.0.clone();
-            let interval = {
-                let mut b = inner.borrow_mut();
-                b.current = Some(now);
-                b.resolution
-            };
-
-            actix_rt::spawn(delay_for(interval).then(move |_| {
-                inner.borrow_mut().current.take();
-                ready(())
-            }));
-            now
-        }
-    }
-}
-
-impl Service for LowResTimeService {
-    type Request = ();
-    type Response = Instant;
-    type Error = Infallible;
-    type Future = Ready<Result<Self::Response, Self::Error>>;
-
-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
-    }
-
-    fn call(&mut self, _: ()) -> Self::Future {
-        ok(self.now())
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct SystemTime(Rc<RefCell<SystemTimeInner>>);
-
-#[derive(Debug)]
-struct SystemTimeInner {
-    resolution: Duration,
-    current: Option<time::SystemTime>,
-}
-
-impl SystemTimeInner {
-    fn new(resolution: Duration) -> Self {
-        SystemTimeInner {
-            resolution,
-            current: None,
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct SystemTimeService(Rc<RefCell<SystemTimeInner>>);
-
-impl SystemTimeService {
-    pub fn with(resolution: Duration) -> SystemTimeService {
-        SystemTimeService(Rc::new(RefCell::new(SystemTimeInner::new(resolution))))
-    }
-
-    /// Get current time. This function has to be called from
-    /// future's poll method, otherwise it panics.
-    pub fn now(&self) -> time::SystemTime {
-        let cur = self.0.borrow().current;
-        if let Some(cur) = cur {
-            cur
-        } else {
-            let now = time::SystemTime::now();
-            let inner = self.0.clone();
-            let interval = {
-                let mut b = inner.borrow_mut();
-                b.current = Some(now);
-                b.resolution
-            };
-
-            actix_rt::spawn(delay_for(interval).then(move |_| {
-                inner.borrow_mut().current.take();
-                ready(())
-            }));
-            now
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::time::{Duration, SystemTime};
-
-    /// State Under Test: Two calls of `SystemTimeService::now()` return the same value if they are done within resolution interval of `SystemTimeService`.
-    ///
-    /// Expected Behavior: Two back-to-back calls of `SystemTimeService::now()` return the same value.
-    #[actix_rt::test]
-    async fn system_time_service_time_does_not_immediately_change() {
-        let resolution = Duration::from_millis(50);
-
-        let time_service = SystemTimeService::with(resolution);
-        assert_eq!(time_service.now(), time_service.now());
-    }
-
-    /// State Under Test: Two calls of `LowResTimeService::now()` return the same value if they are done within resolution interval of `SystemTimeService`.
-    ///
-    /// Expected Behavior: Two back-to-back calls of `LowResTimeService::now()` return the same value.
-    #[actix_rt::test]
-    async fn low_res_time_service_time_does_not_immediately_change() {
-        let resolution = Duration::from_millis(50);
-        let time_service = LowResTimeService::with(resolution);
-        assert_eq!(time_service.now(), time_service.now());
-    }
-
-    /// State Under Test: `SystemTimeService::now()` updates returned value every resolution period.
-    ///
-    /// Expected Behavior: Two calls of `LowResTimeService::now()` made in subsequent resolution interval return different values
-    /// and second value is greater than the first one at least by a resolution interval.
-    #[actix_rt::test]
-    async fn system_time_service_time_updates_after_resolution_interval() {
-        let resolution = Duration::from_millis(100);
-        let wait_time = Duration::from_millis(300);
-
-        let time_service = SystemTimeService::with(resolution);
-
-        let first_time = time_service
-            .now()
-            .duration_since(SystemTime::UNIX_EPOCH)
-            .unwrap();
-
-        delay_for(wait_time).await;
-
-        let second_time = time_service
-            .now()
-            .duration_since(SystemTime::UNIX_EPOCH)
-            .unwrap();
-
-        assert!(second_time - first_time >= wait_time);
-    }
-
-    /// State Under Test: `LowResTimeService::now()` updates returned value every resolution period.
-    ///
-    /// Expected Behavior: Two calls of `LowResTimeService::now()` made in subsequent resolution interval return different values
-    /// and second value is greater than the first one at least by a resolution interval.
-    #[actix_rt::test]
-    async fn low_res_time_service_time_updates_after_resolution_interval() {
-        let resolution = Duration::from_millis(100);
-        let wait_time = Duration::from_millis(300);
-        let time_service = LowResTimeService::with(resolution);
-
-        let first_time = time_service.now();
-
-        delay_for(wait_time).await;
-
-        let second_time = time_service.now();
-        assert!(second_time - first_time >= wait_time);
-    }
-}

actix-utils/src/timeout.rs

@@ -2,15 +2,16 @@
 //!
 //! If the response does not complete within the specified timeout, the response
 //! will be aborted.
-use std::future::Future;
+
-use std::marker::PhantomData;
+use core::future::Future;
-use std::pin::Pin;
+use core::marker::PhantomData;
-use std::task::{Context, Poll};
+use core::pin::Pin;
-use std::{fmt, time};
+use core::task::{Context, Poll};
+use core::{fmt, time};
 
 use actix_rt::time::{delay_for, Delay};
 use actix_service::{IntoService, Service, Transform};
-use futures_util::future::{ok, Ready};
+use pin_project_lite::pin_project;
 
 /// Applies a timeout to requests.
 #[derive(Debug)]
@@ -78,61 +79,82 @@ impl<E> Clone for Timeout<E> {
     }
 }
 
-impl<S, E> Transform<S> for Timeout<E>
+impl<S, E, Req> Transform<S, Req> for Timeout<E>
 where
-    S: Service,
+    S: Service<Req>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = TimeoutError<S::Error>;
     type InitError = E;
-    type Transform = TimeoutService<S>;
+    type Transform = TimeoutService<S, Req>;
-    type Future = Ready<Result<Self::Transform, Self::InitError>>;
+    type Future = TimeoutFuture<Self::Transform, Self::InitError>;
 
     fn new_transform(&self, service: S) -> Self::Future {
-        ok(TimeoutService {
+        let service = TimeoutService {
             service,
             timeout: self.timeout,
-        })
+            _phantom: PhantomData,
+        };
+
+        TimeoutFuture {
+            service: Some(service),
+            _err: PhantomData,
+        }
+    }
+}
+
+pub struct TimeoutFuture<T, E> {
+    service: Option<T>,
+    _err: PhantomData<E>,
+}
+
+impl<T, E> Unpin for TimeoutFuture<T, E> {}
+
+impl<T, E> Future for TimeoutFuture<T, E> {
+    type Output = Result<T, E>;
+
+    fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Ready(Ok(self.get_mut().service.take().unwrap()))
     }
 }
 
 /// Applies a timeout to requests.
 #[derive(Debug, Clone)]
-pub struct TimeoutService<S> {
+pub struct TimeoutService<S, Req> {
     service: S,
     timeout: time::Duration,
+    _phantom: PhantomData<Req>,
 }
 
-impl<S> TimeoutService<S>
+impl<S, Req> TimeoutService<S, Req>
 where
-    S: Service,
+    S: Service<Req>,
 {
     pub fn new<U>(timeout: time::Duration, service: U) -> Self
     where
-        U: IntoService<S>,
+        U: IntoService<S, Req>,
     {
         TimeoutService {
             timeout,
             service: service.into_service(),
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<S> Service for TimeoutService<S>
+impl<S, Req> Service<Req> for TimeoutService<S, Req>
 where
-    S: Service,
+    S: Service<Req>,
 {
-    type Request = S::Request;
     type Response = S::Response;
     type Error = TimeoutError<S::Error>;
-    type Future = TimeoutServiceResponse<S>;
+    type Future = TimeoutServiceResponse<S, Req>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.service.poll_ready(cx).map_err(TimeoutError::Service)
     }
 
-    fn call(&mut self, request: S::Request) -> Self::Future {
+    fn call(&mut self, request: Req) -> Self::Future {
         TimeoutServiceResponse {
             fut: self.service.call(request),
             sleep: delay_for(self.timeout),
@@ -140,42 +162,46 @@ where
     }
 }
 
-/// `TimeoutService` response future
+pin_project! {
-#[pin_project::pin_project]
+    /// `TimeoutService` response future
-#[derive(Debug)]
+    #[derive(Debug)]
-pub struct TimeoutServiceResponse<T: Service> {
+    pub struct TimeoutServiceResponse<S, Req>
-    #[pin]
+    where
-    fut: T::Future,
+        S: Service<Req>
-    sleep: Delay,
+    {
+        #[pin]
+        fut: S::Future,
+        sleep: Delay,
+    }
 }
 
-impl<T> Future for TimeoutServiceResponse<T>
+impl<S, Req> Future for TimeoutServiceResponse<S, Req>
 where
-    T: Service,
+    S: Service<Req>,
 {
-    type Output = Result<T::Response, TimeoutError<T::Error>>;
+    type Output = Result<S::Response, TimeoutError<S::Error>>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.project();
+        let this = self.project();
 
         // First, try polling the future
-        match this.fut.poll(cx) {
+        if let Poll::Ready(res) = this.fut.poll(cx) {
-            Poll::Ready(Ok(v)) => return Poll::Ready(Ok(v)),
+            return match res {
-            Poll::Ready(Err(e)) => return Poll::Ready(Err(TimeoutError::Service(e))),
+                Ok(v) => Poll::Ready(Ok(v)),
-            Poll::Pending => {}
+                Err(e) => Poll::Ready(Err(TimeoutError::Service(e))),
+            };
         }
 
         // Now check the sleep
-        match Pin::new(&mut this.sleep).poll(cx) {
+        Pin::new(this.sleep)
-            Poll::Pending => Poll::Pending,
+            .poll(cx)
-            Poll::Ready(_) => Poll::Ready(Err(TimeoutError::Timeout)),
+            .map(|_| Err(TimeoutError::Timeout))
-        }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use std::task::{Context, Poll};
+    use std::task::Poll;
     use std::time::Duration;
 
     use super::*;
@@ -184,15 +210,12 @@ mod tests {
 
     struct SleepService(Duration);
 
-    impl Service for SleepService {
+    impl Service<()> for SleepService {
-        type Request = ();
         type Response = ();
         type Error = ();
         type Future = LocalBoxFuture<'static, Result<(), ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        actix_service::always_ready!();
-            Poll::Ready(Ok(()))
-        }
 
         fn call(&mut self, _: ()) -> Self::Future {
             actix_rt::time::delay_for(self.0)

codecov.yml

@@ -1,3 +1,5 @@
+comment: false
+
 coverage:
   status:
     project:

examples/basic.rs

@@ -1,77 +0,0 @@
-//! simple composite service
-//! build: cargo run --example basic --features "ssl"
-//! to test: curl https://127.0.0.1:8443/ -k
-use std::sync::{
-    atomic::{AtomicUsize, Ordering},
-    Arc,
-};
-use std::{env, fmt, io};
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::System;
-use actix_server::{Io, Server};
-use actix_service::{service_fn, NewService};
-use futures_util::{future, Future};
-use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
-use tokio_openssl::SslAcceptorExt;
-
-/// Simple logger service, it just prints fact of the new connections
-fn logger<T: AsyncRead + AsyncWrite + fmt::Debug>(
-    stream: T,
-) -> impl Future<Item = T, Error = ()> {
-    println!("New connection: {:?}", stream);
-    future::ok(stream)
-}
-
-fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "actix_net=trace");
-    env_logger::init();
-
-    let sys = System::new("test");
-
-    // load ssl keys
-    let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
-    builder
-        .set_private_key_file("./examples/key.pem", SslFiletype::PEM)
-        .unwrap();
-    builder
-        .set_certificate_chain_file("./examples/cert.pem")
-        .unwrap();
-    let acceptor = builder.build();
-
-    let num = Arc::new(AtomicUsize::new(0));
-
-    // 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.
-    Server::build()
-        .bind(
-            // configure service pipeline
-            "basic",
-            "0.0.0.0:8443",
-            move || {
-                let num = num.clone();
-                let acceptor = acceptor.clone();
-
-                // service for converting incoming TcpStream to a SslStream<TcpStream>
-                service_fn(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(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(())
-                })
-            },
-        )
-        .unwrap()
-        .start();
-
-    sys.run()
-}

examples/cert.pem

@@ -1,31 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIFPjCCAyYCCQDvLYiYD+jqeTANBgkqhkiG9w0BAQsFADBhMQswCQYDVQQGEwJV
-UzELMAkGA1UECAwCQ0ExCzAJBgNVBAcMAlNGMRAwDgYDVQQKDAdDb21wYW55MQww
-CgYDVQQLDANPcmcxGDAWBgNVBAMMD3d3dy5leGFtcGxlLmNvbTAeFw0xODAxMjUx
-NzQ2MDFaFw0xOTAxMjUxNzQ2MDFaMGExCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJD
-QTELMAkGA1UEBwwCU0YxEDAOBgNVBAoMB0NvbXBhbnkxDDAKBgNVBAsMA09yZzEY
-MBYGA1UEAwwPd3d3LmV4YW1wbGUuY29tMIICIjANBgkqhkiG9w0BAQEFAAOCAg8A
-MIICCgKCAgEA2WzIA2IpVR9Tb9EFhITlxuhE5rY2a3S6qzYNzQVgSFggxXEPn8k1
-sQEcer5BfAP986Sck3H0FvB4Bt/I8PwOtUCmhwcc8KtB5TcGPR4fjXnrpC+MIK5U
-NLkwuyBDKziYzTdBj8kUFX1WxmvEHEgqToPOZfBgsS71cJAR/zOWraDLSRM54jXy
-voLZN4Ti9rQagQrvTQ44Vz5ycDQy7UxtbUGh1CVv69vNVr7/SOOh/Nw5FNOZWLWr
-odGyoec5wh9iqRZgRqiTUc6Lt7V2RWc2X2gjwST2UfI+U46Ip3oaQ7ZD4eAkoqND
-xdniBZAykVG3c/99ux4BAESTF8fsNch6UticBxYMuTu+ouvP0psfI9wwwNliJDmA
-CRUTB9AgRynbL1AzhqQoDfsb98IZfjfNOpwnwuLwpMAPhbgd5KNdZaIJ4Hb6/stI
-yFElOExxd3TAxF2Gshd/lq1JcNHAZ1DSXV5MvOWT/NWgXwbIzUgQ8eIi+HuDYX2U
-UuaB6R8tbd52H7rbUv6HrfinuSlKWqjSYLkiKHkwUpoMw8y9UycRSzs1E9nPwPTO
-vRXb0mNCQeBCV9FvStNVXdCUTT8LGPv87xSD2pmt7LijlE6mHLG8McfcWkzA69un
-CEHIFAFDimTuN7EBljc119xWFTcHMyoZAfFF+oTqwSbBGImruCxnaJECAwEAATAN
-BgkqhkiG9w0BAQsFAAOCAgEApavsgsn7SpPHfhDSN5iZs1ILZQRewJg0Bty0xPfk
-3tynSW6bNH3nSaKbpsdmxxomthNSQgD2heOq1By9YzeOoNR+7Pk3s4FkASnf3ToI
-JNTUasBFFfaCG96s4Yvs8KiWS/k84yaWuU8c3Wb1jXs5Rv1qE1Uvuwat1DSGXSoD
-JNluuIkCsC4kWkyq5pWCGQrabWPRTWsHwC3PTcwSRBaFgYLJaR72SloHB1ot02zL
-d2age9dmFRFLLCBzP+D7RojBvL37qS/HR+rQ4SoQwiVc/JzaeqSe7ZbvEH9sZYEu
-ALowJzgbwro7oZflwTWunSeSGDSltkqKjvWvZI61pwfHKDahUTmZ5h2y67FuGEaC
-CIOUI8dSVSPKITxaq3JL4ze2e9/0Lt7hj19YK2uUmtMAW5Tirz4Yx5lyGH9U8Wur
-y/X8VPxTc4A9TMlJgkyz0hqvhbPOT/zSWB10zXh0glKAsSBryAOEDxV1UygmSir7
-YV8Qaq+oyKUTMc1MFq5vZ07M51EPaietn85t8V2Y+k/8XYltRp32NxsypxAJuyxh
-g/ko6RVTrWa1sMvz/F9LFqAdKiK5eM96lh9IU4xiLg4ob8aS/GRAA8oIFkZFhLrt
-tOwjIUPmEPyHWFi8dLpNuQKYalLYhuwZftG/9xV+wqhKGZO9iPrpHSYBRTap8w2y
-1QU=
------END CERTIFICATE-----

examples/key.pem

@@ -1,51 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIJKAIBAAKCAgEA2WzIA2IpVR9Tb9EFhITlxuhE5rY2a3S6qzYNzQVgSFggxXEP
-n8k1sQEcer5BfAP986Sck3H0FvB4Bt/I8PwOtUCmhwcc8KtB5TcGPR4fjXnrpC+M
-IK5UNLkwuyBDKziYzTdBj8kUFX1WxmvEHEgqToPOZfBgsS71cJAR/zOWraDLSRM5
-4jXyvoLZN4Ti9rQagQrvTQ44Vz5ycDQy7UxtbUGh1CVv69vNVr7/SOOh/Nw5FNOZ
-WLWrodGyoec5wh9iqRZgRqiTUc6Lt7V2RWc2X2gjwST2UfI+U46Ip3oaQ7ZD4eAk
-oqNDxdniBZAykVG3c/99ux4BAESTF8fsNch6UticBxYMuTu+ouvP0psfI9wwwNli
-JDmACRUTB9AgRynbL1AzhqQoDfsb98IZfjfNOpwnwuLwpMAPhbgd5KNdZaIJ4Hb6
-/stIyFElOExxd3TAxF2Gshd/lq1JcNHAZ1DSXV5MvOWT/NWgXwbIzUgQ8eIi+HuD
-YX2UUuaB6R8tbd52H7rbUv6HrfinuSlKWqjSYLkiKHkwUpoMw8y9UycRSzs1E9nP
-wPTOvRXb0mNCQeBCV9FvStNVXdCUTT8LGPv87xSD2pmt7LijlE6mHLG8McfcWkzA
-69unCEHIFAFDimTuN7EBljc119xWFTcHMyoZAfFF+oTqwSbBGImruCxnaJECAwEA
-AQKCAgAME3aoeXNCPxMrSri7u4Xnnk71YXl0Tm9vwvjRQlMusXZggP8VKN/KjP0/
-9AE/GhmoxqPLrLCZ9ZE1EIjgmZ9Xgde9+C8rTtfCG2RFUL7/5J2p6NonlocmxoJm
-YkxYwjP6ce86RTjQWL3RF3s09u0inz9/efJk5O7M6bOWMQ9VZXDlBiRY5BYvbqUR
-6FeSzD4MnMbdyMRoVBeXE88gTvZk8xhB6DJnLzYgc0tKiRoeKT0iYv5JZw25VyRM
-ycLzfTrFmXCPfB1ylb483d9Ly4fBlM8nkx37PzEnAuukIawDxsPOb9yZC+hfvNJI
-7NFiMN+3maEqG2iC00w4Lep4skHY7eHUEUMl+Wjr+koAy2YGLWAwHZQTm7iXn9Ab
-L6adL53zyCKelRuEQOzbeosJAqS+5fpMK0ekXyoFIuskj7bWuIoCX7K/kg6q5IW+
-vC2FrlsrbQ79GztWLVmHFO1I4J9M5r666YS0qdh8c+2yyRl4FmSiHfGxb3eOKpxQ
-b6uI97iZlkxPF9LYUCSc7wq0V2gGz+6LnGvTHlHrOfVXqw/5pLAKhXqxvnroDTwz
-0Ay/xFF6ei/NSxBY5t8ztGCBm45wCU3l8pW0X6dXqwUipw5b4MRy1VFRu6rqlmbL
-OPSCuLxqyqsigiEYsBgS/icvXz9DWmCQMPd2XM9YhsHvUq+R4QKCAQEA98EuMMXI
-6UKIt1kK2t/3OeJRyDd4iv/fCMUAnuPjLBvFE4cXD/SbqCxcQYqb+pue3PYkiTIC
-71rN8OQAc5yKhzmmnCE5N26br/0pG4pwEjIr6mt8kZHmemOCNEzvhhT83nfKmV0g
-9lNtuGEQMiwmZrpUOF51JOMC39bzcVjYX2Cmvb7cFbIq3lR0zwM+aZpQ4P8LHCIu
-bgHmwbdlkLyIULJcQmHIbo6nPFB3ZZE4mqmjwY+rA6Fh9rgBa8OFCfTtrgeYXrNb
-IgZQ5U8GoYRPNC2ot0vpTinraboa/cgm6oG4M7FW1POCJTl+/ktHEnKuO5oroSga
-/BSg7hCNFVaOhwKCAQEA4Kkys0HtwEbV5mY/NnvUD5KwfXX7BxoXc9lZ6seVoLEc
-KjgPYxqYRVrC7dB2YDwwp3qcRTi/uBAgFNm3iYlDzI4xS5SeaudUWjglj7BSgXE2
-iOEa7EwcvVPluLaTgiWjlzUKeUCNNHWSeQOt+paBOT+IgwRVemGVpAgkqQzNh/nP
-tl3p9aNtgzEm1qVlPclY/XUCtf3bcOR+z1f1b4jBdn0leu5OhnxkC+Htik+2fTXD
-jt6JGrMkanN25YzsjnD3Sn+v6SO26H99wnYx5oMSdmb8SlWRrKtfJHnihphjG/YY
-l1cyorV6M/asSgXNQfGJm4OuJi0I4/FL2wLUHnU+JwKCAQEAzh4WipcRthYXXcoj
-gMKRkMOb3GFh1OpYqJgVExtudNTJmZxq8GhFU51MR27Eo7LycMwKy2UjEfTOnplh
-Us2qZiPtW7k8O8S2m6yXlYUQBeNdq9IuuYDTaYD94vsazscJNSAeGodjE+uGvb1q
-1wLqE87yoE7dUInYa1cOA3+xy2/CaNuviBFJHtzOrSb6tqqenQEyQf6h9/12+DTW
-t5pSIiixHrzxHiFqOoCLRKGToQB+71rSINwTf0nITNpGBWmSj5VcC3VV3TG5/XxI
-fPlxV2yhD5WFDPVNGBGvwPDSh4jSMZdZMSNBZCy4XWFNSKjGEWoK4DFYed3DoSt9
-5IG1YwKCAQA63ntHl64KJUWlkwNbboU583FF3uWBjee5VqoGKHhf3CkKMxhtGqnt
-+oN7t5VdUEhbinhqdx1dyPPvIsHCS3K1pkjqii4cyzNCVNYa2dQ00Qq+QWZBpwwc
-3GAkz8rFXsGIPMDa1vxpU6mnBjzPniKMcsZ9tmQDppCEpBGfLpio2eAA5IkK8eEf
-cIDB3CM0Vo94EvI76CJZabaE9IJ+0HIJb2+jz9BJ00yQBIqvJIYoNy9gP5Xjpi+T
-qV/tdMkD5jwWjHD3AYHLWKUGkNwwkAYFeqT/gX6jpWBP+ZRPOp011X3KInJFSpKU
-DT5GQ1Dux7EMTCwVGtXqjO8Ym5wjwwsfAoIBAEcxlhIW1G6BiNfnWbNPWBdh3v/K
-5Ln98Rcrz8UIbWyl7qNPjYb13C1KmifVG1Rym9vWMO3KuG5atK3Mz2yLVRtmWAVc
-fxzR57zz9MZFDun66xo+Z1wN3fVxQB4CYpOEI4Lb9ioX4v85hm3D6RpFukNtRQEc
-Gfr4scTjJX4jFWDp0h6ffMb8mY+quvZoJ0TJqV9L9Yj6Ksdvqez/bdSraev97bHQ
-4gbQxaTZ6WjaD4HjpPQefMdWp97Metg0ZQSS8b8EzmNFgyJ3XcjirzwliKTAQtn6
-I2sd0NCIooelrKRD8EJoDUwxoOctY7R97wpZ7/wEHU45cBCbRV3H4JILS5c=
------END RSA PRIVATE KEY-----

examples/ssl.rs

@@ -1,51 +0,0 @@
-use std::io;
-use std::sync::{
-    atomic::{AtomicUsize, Ordering},
-    Arc,
-};
-
-use actix_rt::System;
-use actix_server::{ssl, Server};
-use actix_service::NewService;
-use futures_util::future;
-use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
-
-#[derive(Debug)]
-struct ServiceState {
-    num: Arc<AtomicUsize>,
-}
-
-fn main() -> io::Result<()> {
-    let sys = System::new("test");
-
-    // load ssl keys
-    let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
-    builder
-        .set_private_key_file("./examples/key.pem", SslFiletype::PEM)
-        .unwrap();
-    builder
-        .set_certificate_chain_file("./examples/cert.pem")
-        .unwrap();
-
-    let num = Arc::new(AtomicUsize::new(0));
-    let openssl = ssl::OpensslAcceptor::new(builder.build());
-
-    // server start mutiple workers, it runs supplied `Fn` in each worker.
-    Server::build()
-        .bind("test-ssl", "0.0.0.0:8443", move || {
-            let num = num.clone();
-
-            // configure service
-            openssl
-                .clone()
-                .map_err(|e| println!("Openssl error: {}", e))
-                .and_then(move |_| {
-                    let num = num.fetch_add(1, Ordering::Relaxed);
-                    println!("got ssl connection {:?}", num);
-                    future::ok(())
-                })
-        })?
-        .start();
-
-    sys.run()
-}

router/CHANGES.md

@@ -1,53 +1,55 @@
 # Changes
 
-## [0.2.4] - 2019-12-31
+## Unreleased - 2020-xx-xx
 
+
+## 0.2.5 - 2020-09-20
+* Fix `from_hex()` method
+
+
+## 0.2.4 - 2019-12-31
 * Add `ResourceDef::resource_path_named()` path generation method
 
-## [0.2.3] - 2019-12-25
 
+## 0.2.3 - 2019-12-25
 * Add impl `IntoPattern` for `&String`
 
-## [0.2.2] - 2019-12-25
 
+## 0.2.2 - 2019-12-25
 * Use `IntoPattern` for `RouterBuilder::path()`
 
-## [0.2.1] - 2019-12-25
 
+## 0.2.1 - 2019-12-25
 * Add `IntoPattern` trait
-
 * Add multi-pattern resources
 
-## [0.2.0] - 2019-12-07
 
+## 0.2.0 - 2019-12-07
 * Update http to 0.2
-
 * Update regex to 1.3
-
 * Use bytestring instead of string
 
-## [0.1.5] - 2019-05-15
 
+## 0.1.5 - 2019-05-15
 * Remove debug prints
 
-## [0.1.4] - 2019-05-15
 
+## 0.1.4 - 2019-05-15
 * Fix checked resource match
 
-## [0.1.3] - 2019-04-22
 
+## 0.1.3 - 2019-04-22
 * Added support for `remainder match` (i.e "/path/{tail}*")
 
-## [0.1.2] - 2019-04-07
 
+## 0.1.2 - 2019-04-07
 * Export `Quoter` type
-
 * Allow to reset `Path` instance
 
-## [0.1.1] - 2019-04-03
 
+## 0.1.1 - 2019-04-03
 * Get dynamic segment by name instead of iterator.
 
-## [0.1.0] - 2019-03-09
 
+## 0.1.0 - 2019-03-09
 * Initial release

router/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "actix-router"
-version = "0.2.4"
+version = "0.2.5"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Path router"
+description = "Resource path matching library"
 keywords = ["actix"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
@@ -22,7 +22,7 @@ regex = "1.3.1"
 serde = "1.0.104"
 bytestring = "0.1.2"
 log = "0.4.8"
-http = { version="0.2.0", optional=true }
+http = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
 http = "0.2.0"

router/src/de.rs

@@ -42,7 +42,7 @@ macro_rules! parse_single_value {
     };
 }
 
-pub struct PathDeserializer<'de, T: ResourcePath + 'de> {
+pub struct PathDeserializer<'de, T: ResourcePath> {
     path: &'de Path<T>,
 }
 
@@ -161,9 +161,7 @@ impl<'de, T: ResourcePath + 'de> Deserializer<'de> for PathDeserializer<'de, T>
         V: Visitor<'de>,
     {
         if self.path.is_empty() {
-            Err(de::value::Error::custom(
+            Err(de::value::Error::custom("expected at least one parameters"))
-                "expeceted at least one parameters",
-            ))
         } else {
             visitor.visit_enum(ValueEnum {
                 value: &self.path[0],

router/src/lib.rs

@@ -1,4 +1,9 @@
 //! Resource path matching library.
+
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
+
 mod de;
 mod path;
 mod resource;

router/src/path.rs

@@ -158,7 +158,7 @@ impl<T: ResourcePath> Path<T> {
     }
 
     /// Return iterator to items in parameter container
-    pub fn iter(&self) -> PathIter<T> {
+    pub fn iter(&self) -> PathIter<'_, T> {
         PathIter {
             idx: 0,
             params: self,

router/src/resource.rs

@@ -155,7 +155,7 @@ impl ResourceDef {
     }
 
     #[inline]
-    /// Check if path matchs this pattern?
+    /// Check if path matches this pattern.
     pub fn is_match(&self, path: &str) -> bool {
         match self.tp {
             PatternType::Static(ref s) => s == path,
@@ -165,15 +165,15 @@ impl ResourceDef {
         }
     }
 
-    /// Is prefix path a match against this resource?
+    /// Is prefix path a match against this resource.
     pub fn is_prefix_match(&self, path: &str) -> Option<usize> {
-        let plen = path.len();
+        let p_len = path.len();
         let path = if path.is_empty() { "/" } else { path };
 
         match self.tp {
             PatternType::Static(ref s) => {
                 if s == path {
-                    Some(plen)
+                    Some(p_len)
                 } else {
                     None
                 }
@@ -211,7 +211,7 @@ impl ResourceDef {
                 } else {
                     return None;
                 };
-                Some(min(plen, len))
+                Some(min(p_len, len))
             }
             PatternType::DynamicSet(ref re, ref params) => {
                 if let Some(idx) = re.matches(path).into_iter().next() {
@@ -240,7 +240,7 @@ impl ResourceDef {
         }
     }
 
-    /// Is the given path and parameters a match against this pattern?
+    /// Is the given path and parameters a match against this pattern.
     pub fn match_path<T: ResourcePath>(&self, path: &mut Path<T>) -> bool {
         match self.tp {
             PatternType::Static(ref s) => {
@@ -252,11 +252,11 @@ impl ResourceDef {
                 }
             }
             PatternType::Prefix(ref s) => {
-                let rpath = path.path();
+                let r_path = path.path();
-                let len = if s == rpath {
+                let len = if s == r_path {
                     s.len()
-                } else if rpath.starts_with(s)
+                } else if r_path.starts_with(s)
-                    && (s.ends_with('/') || rpath.split_at(s.len()).1.starts_with('/'))
+                    && (s.ends_with('/') || r_path.split_at(s.len()).1.starts_with('/'))
                 {
                     if s.ends_with('/') {
                         s.len() - 1
@@ -266,8 +266,8 @@ impl ResourceDef {
                 } else {
                     return false;
                 };
-                let rpath_len = rpath.len();
+                let r_path_len = r_path.len();
-                path.skip(min(rpath_len, len) as u16);
+                path.skip(min(r_path_len, len) as u16);
                 true
             }
             PatternType::Dynamic(ref re, ref names, len) => {
@@ -361,11 +361,11 @@ impl ResourceDef {
             }
             PatternType::Prefix(ref s) => {
                 let len = {
-                    let rpath = res.resource_path().path();
+                    let r_path = res.resource_path().path();
-                    if s == rpath {
+                    if s == r_path {
                         s.len()
-                    } else if rpath.starts_with(s)
+                    } else if r_path.starts_with(s)
-                        && (s.ends_with('/') || rpath.split_at(s.len()).1.starts_with('/'))
+                        && (s.ends_with('/') || r_path.split_at(s.len()).1.starts_with('/'))
                     {
                         if s.ends_with('/') {
                             s.len() - 1
@@ -580,6 +580,8 @@ impl ResourceDef {
         mut for_prefix: bool,
     ) -> (String, Vec<PatternElement>, bool, usize) {
         if pattern.find('{').is_none() {
+            // TODO: MSRV: 1.45
+            #[allow(clippy::manual_strip)]
             return if pattern.ends_with('*') {
                 let path = &pattern[..pattern.len() - 1];
                 let re = String::from("^") + path + "(.*)";
@@ -594,39 +596,39 @@ impl ResourceDef {
             };
         }
 
-        let mut elems = Vec::new();
+        let mut elements = Vec::new();
         let mut re = String::from("^");
-        let mut dyn_elems = 0;
+        let mut dyn_elements = 0;
 
         while let Some(idx) = pattern.find('{') {
             let (prefix, rem) = pattern.split_at(idx);
-            elems.push(PatternElement::Str(String::from(prefix)));
+            elements.push(PatternElement::Str(String::from(prefix)));
             re.push_str(&escape(prefix));
             let (param_pattern, re_part, rem, tail) = Self::parse_param(rem);
             if tail {
                 for_prefix = true;
             }
 
-            elems.push(param_pattern);
+            elements.push(param_pattern);
             re.push_str(&re_part);
             pattern = rem;
-            dyn_elems += 1;
+            dyn_elements += 1;
         }
 
-        elems.push(PatternElement::Str(String::from(pattern)));
+        elements.push(PatternElement::Str(String::from(pattern)));
         re.push_str(&escape(pattern));
 
-        if dyn_elems > MAX_DYNAMIC_SEGMENTS {
+        if dyn_elements > MAX_DYNAMIC_SEGMENTS {
             panic!(
-                "Only {} dynanic segments are allowed, provided: {}",
+                "Only {} dynamic segments are allowed, provided: {}",
-                MAX_DYNAMIC_SEGMENTS, dyn_elems
+                MAX_DYNAMIC_SEGMENTS, dyn_elements
             );
         }
 
         if !for_prefix {
             re.push('$');
         }
-        (re, elems, true, pattern.chars().count())
+        (re, elements, true, pattern.chars().count())
     }
 }
 
@@ -718,10 +720,10 @@ mod tests {
         assert!(!re.is_match("/v/resource/1"));
         assert!(!re.is_match("/resource"));
 
-        let mut path = Path::new("/v151/resource/adahg32");
+        let mut path = Path::new("/v151/resource/adage32");
         assert!(re.match_path(&mut path));
         assert_eq!(path.get("version").unwrap(), "151");
-        assert_eq!(path.get("id").unwrap(), "adahg32");
+        assert_eq!(path.get("id").unwrap(), "adage32");
 
         let re = ResourceDef::new("/{id:[[:digit:]]{6}}");
         assert!(re.is_match("/012345"));
@@ -759,10 +761,10 @@ mod tests {
         assert!(!re.is_match("/v/resource/1"));
         assert!(!re.is_match("/resource"));
 
-        let mut path = Path::new("/v151/resource/adahg32");
+        let mut path = Path::new("/v151/resource/adage32");
         assert!(re.match_path(&mut path));
         assert_eq!(path.get("version").unwrap(), "151");
-        assert_eq!(path.get("id").unwrap(), "adahg32");
+        assert_eq!(path.get("id").unwrap(), "adage32");
 
         assert!(re.is_match("/012345"));
         assert!(!re.is_match("/012"));
@@ -875,7 +877,7 @@ mod tests {
     }
 
     #[test]
-    fn test_reousrce_prefix_dynamic() {
+    fn test_resource_prefix_dynamic() {
         let re = ResourceDef::prefix("/{name}/");
         assert!(re.is_match("/name/"));
         assert!(re.is_match("/name/gs"));

router/src/url.rs

@@ -182,11 +182,11 @@ impl Quoter {
 
 #[inline]
 fn from_hex(v: u8) -> Option<u8> {
-    if v >= b'0' && v <= b'9' {
+    if (b'0'..=b'9').contains(&v) {
         Some(v - 0x30) // ord('0') == 0x30
-    } else if v >= b'A' && v <= b'F' {
+    } else if (b'A'..=b'F').contains(&v) {
         Some(v - 0x41 + 10) // ord('A') == 0x41
-    } else if v > b'a' && v <= b'f' {
+    } else if (b'a'..=b'f').contains(&v) {
         Some(v - 0x61 + 10) // ord('a') == 0x61
     } else {
         None
@@ -225,4 +225,25 @@ mod tests {
         assert!(re.match_path(&mut path));
         assert_eq!(path.get("id").unwrap(), "qwe%rty");
     }
+
+    #[test]
+    fn test_from_hex() {
+        let hex = b"0123456789abcdefABCDEF";
+
+        for i in 0..256 {
+            let c = i as u8;
+            if hex.contains(&c) {
+                assert!(from_hex(c).is_some())
+            } else {
+                assert!(from_hex(c).is_none())
+            }
+        }
+
+        let expected = [
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 10, 11, 12, 13, 14, 15,
+        ];
+        for i in 0..hex.len() {
+            assert_eq!(from_hex(hex[i]).unwrap(), expected[i]);
+        }
+    }
 }

string/src/lib.rs

@@ -1,5 +1,9 @@
 //! A UTF-8 encoded read-only string using Bytes as storage.
 
+#![deny(rust_2018_idioms, nonstandard_style)]
+#![doc(html_logo_url = "https://actix.rs/img/logo.png")]
+#![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
+
 use std::convert::TryFrom;
 use std::{borrow, fmt, hash, ops, str};
 
@@ -7,7 +11,7 @@ use bytes::Bytes;
 
 /// A UTF-8 encoded string with [`Bytes`] as a storage.
 ///
-/// [`Bytes`]: https://docs.rs/bytes/0.5.3/bytes/struct.Bytes.html
+/// [`Bytes`]: bytes::Bytes
 #[derive(Clone, Eq, Ord, PartialOrd, Default)]
 pub struct ByteString(Bytes);
 
@@ -156,13 +160,13 @@ macro_rules! array_impls {
 array_impls!(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16);
 
 impl fmt::Debug for ByteString {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         (**self).fmt(fmt)
     }
 }
 
 impl fmt::Display for ByteString {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         (**self).fmt(fmt)
     }
 }