Add ResourceDef::resource_path_named() path generation method

This reverts commit b0d44198ba.

.github/workflows/main.yml

@@ -0,0 +1,78 @@
+name: CI
+
+on: [push, pull_request]
+
+env:
+  VCPKGRS_DYNAMIC: 1
+
+jobs:
+  build_and_test:
+    strategy:
+      fail-fast: false
+      matrix:
+        toolchain:
+          - x86_64-pc-windows-msvc
+          - x86_64-pc-windows-gnu
+          - i686-pc-windows-msvc
+          - x86_64-apple-darwin
+        version:
+          - stable
+          - nightly
+        include:
+        - toolchain: x86_64-pc-windows-msvc
+          os: windows-latest
+          arch: x64
+        - toolchain: x86_64-pc-windows-gnu
+          os: windows-latest
+        - toolchain: i686-pc-windows-msvc
+          os: windows-latest
+          arch: x86
+        - toolchain: x86_64-apple-darwin
+          os: macOS-latest
+
+    name: ${{ matrix.version }} - ${{ matrix.toolchain }}
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@master
+
+      - name: Install ${{ matrix.version }}
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.version }}-${{ matrix.toolchain }}
+          default: true
+
+
+      - name: Install OpenSSL
+        if: matrix.toolchain == 'x86_64-pc-windows-msvc' || matrix.toolchain == 'i686-pc-windows-msvc'
+        run: |
+          vcpkg integrate install
+          vcpkg install openssl:${{ matrix.arch }}-windows
+
+      - name: check nightly
+        if: matrix.version == 'nightly'
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all --benches --bins --examples --tests
+
+      - name: check stable
+        if: matrix.version == 'stable'
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+          args: --all --bins --examples --tests
+
+      - name: tests
+        if: matrix.toolchain != 'x86_64-pc-windows-gnu'
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all --all-features -- --nocapture
+
+      - name: tests on x86_64-pc-windows-gnu
+        if: matrix.toolchain == 'x86_64-pc-windows-gnu'
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all -- --nocapture

Cargo.toml

@@ -4,13 +4,15 @@ members = [
   "actix-connect",
   "actix-ioframe",
   "actix-rt",
+  "actix-macros",
   "actix-service",
   "actix-server",
-  "actix-server-config",
   "actix-testing",
   "actix-threadpool",
+  "actix-tls",
   "actix-utils",
   "router",
+  "string",
 ]
 
 [patch.crates-io]
@@ -18,10 +20,12 @@ actix-codec = { path = "actix-codec" }
 actix-connect = { path = "actix-connect" }
 actix-ioframe = { path = "actix-ioframe" }
 actix-rt = { path = "actix-rt" }
+actix-macros = { path = "actix-macros" }
 actix-server = { path = "actix-server" }
-actix-server-config = { path = "actix-server-config" }
 actix-service = { path = "actix-service" }
 actix-testing = { path = "actix-testing" }
 actix-threadpool = { path = "actix-threadpool" }
+actix-tls = { path = "actix-tls" }
 actix-utils = { path = "actix-utils" }
 actix-router = { path = "router" }
+bytestring = { path = "string" }

README.md

@@ -30,14 +30,16 @@ fn main() -> io::Result<()> {
                 let num = num.clone();
                 let acceptor = acceptor.clone();
 
-                // service for converting incoming TcpStream to a SslStream<TcpStream>
-                fn_service(move |stream: Io<tokio_tcp::TcpStream>| {
-                    SslAcceptorExt::accept_async(&acceptor, stream.into_parts().0)
-                        .map_err(|e| println!("Openssl error: {}", e))
-                })
-                // .and_then() combinator uses other service to convert incoming `Request` to a
-                // `Response` and then uses that response as an input for next
-                // service. in this case, on success we use `logger` service
+                // construct transformation pipeline
+                pipeline(
+                    // service for converting incoming TcpStream to a SslStream<TcpStream>
+                    fn_service(move |stream: actix_rt::net::TcpStream| async move {
+                        SslAcceptorExt::accept_async(&acceptor, stream.into_parts().0).await
+                            .map_err(|e| println!("Openssl error: {}", e))
+                    }))
+                // .and_then() combinator chains result of previos service call to argument
+                /// for next service calll. in this case, on success we chain
+                /// ssl stream to the `logger` service.
                 .and_then(fn_service(logger))
                 // Next service counts number of connections
                 .and_then(move |_| {

actix-codec/CHANGES.md

@@ -1,15 +1,33 @@
 # Changes
 
+* Use `.advance()` intead of `.split_to()`
+
+## [0.2.0] - 2019-12-10
+
+* Use specific futures dependencies
+
+## [0.2.0-alpha.4]
+
+* Fix buffer remaining capacity calcualtion
+
+## [0.2.0-alpha.3]
+
+* Use tokio 0.2
+
+* Fix low/high watermark for write/read buffers
+
+## [0.2.0-alpha.2]
+
+* Migrated to `std::future`
+
 ## [0.1.2] - 2019-03-27
 
 * Added `Framed::map_io()` method.
 
-
 ## [0.1.1] - 2019-03-06
 
 * Added `FramedParts::with_read_buffer()` method.
 
-
 ## [0.1.0] - 2018-12-09
 
 * Move codec to separate crate

actix-codec/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-codec"
-version = "0.2.0-alpha.1"
+version = "0.2.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Utilities for encoding and decoding frames"
 keywords = ["network", "framework", "async", "futures"]
@@ -9,7 +9,6 @@ repository = "https://github.com/actix/actix-net.git"
 documentation = "https://docs.rs/actix-codec/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
 workspace = ".."
 
@@ -18,9 +17,10 @@ name = "actix_codec"
 path = "src/lib.rs"
 
 [dependencies]
-bytes = "0.4.12"
-futures = "0.3.1"
-pin-project = "0.4.5"
-tokio-io = "0.2.0-alpha.6"
-tokio-codec = "0.2.0-alpha.6"
+bitflags = "1.2.1"
+bytes = "0.5.2"
+futures-core = "0.3.1"
+futures-sink = "0.3.1"
+tokio = { version = "0.2.4", default-features=false }
+tokio-util = { version = "0.2.0", default-features=false, features=["codec"] }
 log = "0.4"

actix-codec/src/bcodec.rs

@@ -1,7 +1,7 @@
+use bytes::{BufMut, Bytes, BytesMut};
 use std::io;
 
-use bytes::{Bytes, BytesMut};
-use tokio_codec::{Decoder, Encoder};
+use super::{Decoder, Encoder};
 
 /// Bytes codec.
 ///
@@ -14,7 +14,8 @@ impl Encoder for BytesCodec {
     type Error = io::Error;
 
     fn encode(&mut self, item: Bytes, dst: &mut BytesMut) -> Result<(), Self::Error> {
-        dst.extend_from_slice(&item[..]);
+        dst.reserve(item.len());
+        dst.put(item);
         Ok(())
     }
 }
@@ -27,7 +28,8 @@ impl Decoder for BytesCodec {
         if src.is_empty() {
             Ok(None)
         } else {
-            Ok(Some(src.take()))
+            let len = src.len();
+            Ok(Some(src.split_to(len)))
         }
     }
 }

actix-codec/src/framed.rs

@@ -1,36 +1,35 @@
-#![allow(deprecated)]
-
-use std::fmt;
-use std::io::{self};
 use std::pin::Pin;
 use std::task::{Context, Poll};
+use std::{fmt, io};
 
-use bytes::BytesMut;
-use futures::{ready, Sink, Stream};
-use pin_project::pin_project;
-use tokio_codec::{Decoder, Encoder};
-use tokio_io::{AsyncRead, AsyncWrite};
+use bytes::{Buf, BytesMut};
+use futures_core::{ready, Stream};
+use futures_sink::Sink;
+
+use crate::{AsyncRead, AsyncWrite, Decoder, Encoder};
 
 const LW: usize = 1024;
 const HW: usize = 8 * 1024;
-const INITIAL_CAPACITY: usize = 8 * 1024;
+
+bitflags::bitflags! {
+    struct Flags: u8 {
+        const EOF = 0b0001;
+        const READABLE = 0b0010;
+    }
+}
 
 /// A unified `Stream` and `Sink` interface to an underlying I/O object, using
 /// the `Encoder` and `Decoder` traits to encode and decode frames.
-///
-/// You can create a `Framed` instance by using the `AsyncRead::framed` adapter.
-#[pin_project]
 pub struct Framed<T, U> {
     io: T,
     codec: U,
-    eof: bool,
-    is_readable: bool,
+    flags: Flags,
     read_buf: BytesMut,
     write_buf: BytesMut,
-    write_lw: usize,
-    write_hw: usize,
 }
 
+impl<T, U> Unpin for Framed<T, U> {}
+
 impl<T, U> Framed<T, U>
 where
     T: AsyncRead + AsyncWrite,
@@ -49,35 +48,13 @@ where
     /// `Sink`; grouping this into a single object is often useful for layering
     /// things like gzip or TLS, which require both read and write access to the
     /// underlying object.
-    ///
-    /// If you want to work more directly with the streams and sink, consider
-    /// calling `split` on the `Framed` returned by this method, which will
-    /// break them into separate objects, allowing them to interact more easily.
     pub fn new(io: T, codec: U) -> Framed<T, U> {
         Framed {
             io,
             codec,
-            eof: false,
-            is_readable: false,
-            read_buf: BytesMut::with_capacity(INITIAL_CAPACITY),
+            flags: Flags::empty(),
+            read_buf: BytesMut::with_capacity(HW),
             write_buf: BytesMut::with_capacity(HW),
-            write_lw: LW,
-            write_hw: HW,
-        }
-    }
-
-    /// Same as `Framed::new()` with ability to specify write buffer low/high capacity watermarks.
-    pub fn new_with_caps(io: T, codec: U, lw: usize, hw: usize) -> Framed<T, U> {
-        debug_assert!((lw < hw) && hw != 0);
-        Framed {
-            io,
-            codec,
-            eof: false,
-            is_readable: false,
-            read_buf: BytesMut::with_capacity(INITIAL_CAPACITY),
-            write_buf: BytesMut::with_capacity(hw),
-            write_lw: lw,
-            write_hw: hw,
         }
     }
 }
@@ -100,19 +77,12 @@ impl<T, U> Framed<T, U> {
     /// This objects takes a stream and a readbuffer and a writebuffer. These
     /// field can be obtained from an existing `Framed` with the
     /// `into_parts` method.
-    ///
-    /// If you want to work more directly with the streams and sink, consider
-    /// calling `split` on the `Framed` returned by this method, which will
-    /// break them into separate objects, allowing them to interact more easily.
     pub fn from_parts(parts: FramedParts<T, U>) -> Framed<T, U> {
         Framed {
             io: parts.io,
             codec: parts.codec,
-            eof: false,
-            is_readable: false,
+            flags: parts.flags,
             write_buf: parts.write_buf,
-            write_lw: parts.write_buf_lw,
-            write_hw: parts.write_buf_hw,
             read_buf: parts.read_buf,
         }
     }
@@ -154,29 +124,17 @@ impl<T, U> Framed<T, U> {
 
     /// Check if write buffer is full.
     pub fn is_write_buf_full(&self) -> bool {
-        self.write_buf.len() >= self.write_hw
-    }
-
-    /// Consumes the `Frame`, returning its underlying I/O stream.
-    ///
-    /// Note that care should be taken to not tamper with the underlying stream
-    /// of data coming in as it may corrupt the stream of frames otherwise
-    /// being worked with.
-    pub fn into_inner(self) -> T {
-        self.io
+        self.write_buf.len() >= HW
     }
 
     /// Consume the `Frame`, returning `Frame` with different codec.
     pub fn into_framed<U2>(self, codec: U2) -> Framed<T, U2> {
         Framed {
-            io: self.io,
             codec,
-            eof: self.eof,
-            is_readable: self.is_readable,
+            io: self.io,
+            flags: self.flags,
             read_buf: self.read_buf,
             write_buf: self.write_buf,
-            write_lw: self.write_lw,
-            write_hw: self.write_hw,
         }
     }
 
@@ -188,12 +146,9 @@ impl<T, U> Framed<T, U> {
         Framed {
             io: f(self.io),
             codec: self.codec,
-            eof: self.eof,
-            is_readable: self.is_readable,
+            flags: self.flags,
             read_buf: self.read_buf,
             write_buf: self.write_buf,
-            write_lw: self.write_lw,
-            write_hw: self.write_hw,
         }
     }
 
@@ -205,12 +160,9 @@ impl<T, U> Framed<T, U> {
         Framed {
             io: self.io,
             codec: f(self.codec),
-            eof: self.eof,
-            is_readable: self.is_readable,
+            flags: self.flags,
             read_buf: self.read_buf,
             write_buf: self.write_buf,
-            write_lw: self.write_lw,
-            write_hw: self.write_hw,
         }
     }
 
@@ -224,11 +176,9 @@ impl<T, U> Framed<T, U> {
         FramedParts {
             io: self.io,
             codec: self.codec,
+            flags: self.flags,
             read_buf: self.read_buf,
             write_buf: self.write_buf,
-            write_buf_lw: self.write_lw,
-            write_buf_hw: self.write_hw,
-            _priv: (),
         }
     }
 }
@@ -240,20 +190,24 @@ impl<T, U> Framed<T, U> {
         T: AsyncWrite,
         U: Encoder,
     {
-        let len = self.write_buf.len();
-        if len < self.write_lw {
-            self.write_buf.reserve(self.write_hw - len)
+        let remaining = self.write_buf.capacity() - self.write_buf.len();
+        if remaining < LW {
+            self.write_buf.reserve(HW - remaining);
         }
+
         self.codec.encode(item, &mut self.write_buf)?;
         Ok(())
     }
 
-    pub fn is_ready(&self) -> bool {
-        let len = self.write_buf.len();
-        len < self.write_hw
+    /// Check if framed is able to write more data.
+    ///
+    /// `Framed` object considers ready if there is free space in write buffer.
+    pub fn is_write_ready(&self) -> bool {
+        self.write_buf.len() < HW
     }
 
-    pub fn next_item(&mut self, cx: &mut Context) -> Poll<Option<Result<U::Item, U::Error>>>
+    /// Try to read underlying I/O stream and decode item.
+    pub fn next_item(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<U::Item, U::Error>>>
     where
         T: AsyncRead,
         U: Decoder,
@@ -265,8 +219,8 @@ impl<T, U> Framed<T, U> {
             // readable, it can be assumed that the decoder will never become
             // readable again, at which point the stream is terminated.
 
-            if self.is_readable {
-                if self.eof {
+            if self.flags.contains(Flags::READABLE) {
+                if self.flags.contains(Flags::EOF) {
                     match self.codec.decode_eof(&mut self.read_buf) {
                         Ok(Some(frame)) => return Poll::Ready(Some(Ok(frame))),
                         Ok(None) => return Poll::Ready(None),
@@ -282,36 +236,36 @@ impl<T, U> Framed<T, U> {
                         return Poll::Ready(Some(Ok(frame)));
                     }
                     Err(e) => return Poll::Ready(Some(Err(e))),
-                    _ => {
-                        // Need more data
-                    }
+                    _ => (), // Need more data
                 }
 
-                self.is_readable = false;
+                self.flags.remove(Flags::READABLE);
             }
 
-            assert!(!self.eof);
+            debug_assert!(!self.flags.contains(Flags::EOF));
 
-            // Otherwise, try to read more data and try again. Make sure we've
-            // got room for at least one byte to read to ensure that we don't
-            // get a spurious 0 that looks like EOF
-            self.read_buf.reserve(1);
-            let cnt = unsafe {
-                match Pin::new_unchecked(&mut self.io).poll_read_buf(cx, &mut self.read_buf) {
-                    Poll::Pending => return Poll::Pending,
-                    Poll::Ready(Err(e)) => return Poll::Ready(Some(Err(e.into()))),
-                    Poll::Ready(Ok(cnt)) => cnt,
-                }
+            // Otherwise, try to read more data and try again. Make sure we've got room
+            let remaining = self.read_buf.capacity() - self.read_buf.len();
+            if remaining < LW {
+                self.read_buf.reserve(HW - remaining)
+            }
+            let cnt = match unsafe {
+                Pin::new_unchecked(&mut self.io).poll_read_buf(cx, &mut self.read_buf)
+            } {
+                Poll::Pending => return Poll::Pending,
+                Poll::Ready(Err(e)) => return Poll::Ready(Some(Err(e.into()))),
+                Poll::Ready(Ok(cnt)) => cnt,
             };
 
             if cnt == 0 {
-                self.eof = true;
+                self.flags.insert(Flags::EOF);
             }
-            self.is_readable = true;
+            self.flags.insert(Flags::READABLE);
         }
     }
 
-    pub fn flush(&mut self, cx: &mut Context) -> Poll<Result<(), U::Error>>
+    /// Flush write buffer to underlying I/O stream.
+    pub fn flush(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), U::Error>>
     where
         T: AsyncWrite,
         U: Encoder,
@@ -321,39 +275,39 @@ impl<T, U> Framed<T, U> {
         while !self.write_buf.is_empty() {
             log::trace!("writing; remaining={}", self.write_buf.len());
 
-            let n = ready!(
-                unsafe { Pin::new_unchecked(&mut self.io) }.poll_write(cx, &self.write_buf)
-            )?;
+            let n = ready!(unsafe {
+                Pin::new_unchecked(&mut self.io).poll_write(cx, &self.write_buf)
+            })?;
 
             if n == 0 {
                 return Poll::Ready(Err(io::Error::new(
                     io::ErrorKind::WriteZero,
-                    "failed to \
-                     write frame to transport",
+                    "failed to write frame to transport",
                 )
                 .into()));
             }
 
-            // TODO: Add a way to `bytes` to do this w/o returning the drained
-            // data.
-            let _ = self.write_buf.split_to(n);
+            // remove written data
+            self.write_buf.advance(n);
         }
 
         // Try flushing the underlying IO
-        ready!(unsafe { Pin::new_unchecked(&mut self.io) }.poll_flush(cx))?;
+        ready!(unsafe { Pin::new_unchecked(&mut self.io).poll_flush(cx) })?;
 
         log::trace!("framed transport flushed");
         Poll::Ready(Ok(()))
     }
 
-    pub fn close(&mut self, cx: &mut Context) -> Poll<Result<(), U::Error>>
+    /// Flush write buffer and shutdown underlying I/O stream.
+    pub fn close(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), U::Error>>
     where
         T: AsyncWrite,
         U: Encoder,
     {
-        ready!(unsafe { Pin::new_unchecked(&mut self.io) }.poll_flush(cx))?;
-        ready!(unsafe { Pin::new_unchecked(&mut self.io) }.poll_shutdown(cx))?;
-
+        unsafe {
+            ready!(Pin::new_unchecked(&mut self.io).poll_flush(cx))?;
+            ready!(Pin::new_unchecked(&mut self.io).poll_shutdown(cx))?;
+        }
         Poll::Ready(Ok(()))
     }
 }
@@ -365,7 +319,7 @@ where
 {
     type Item = Result<U::Item, U::Error>;
 
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         self.next_item(cx)
     }
 }
@@ -378,8 +332,8 @@ where
 {
     type Error = U::Error;
 
-    fn poll_ready(self: Pin<&mut Self>, _: &mut Context) -> Poll<Result<(), Self::Error>> {
-        if self.is_ready() {
+    fn poll_ready(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        if self.is_write_ready() {
             Poll::Ready(Ok(()))
         } else {
             Poll::Pending
@@ -393,11 +347,17 @@ where
         self.write(item)
     }
 
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+    fn poll_flush(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
         self.flush(cx)
     }
 
-    fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+    fn poll_close(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), Self::Error>> {
         self.close(cx)
     }
 }
@@ -407,7 +367,7 @@ where
     T: fmt::Debug,
     U: fmt::Debug,
 {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Framed")
             .field("io", &self.io)
             .field("codec", &self.codec)
@@ -432,15 +392,7 @@ pub struct FramedParts<T, U> {
     /// A buffer with unprocessed data which are not written yet.
     pub write_buf: BytesMut,
 
-    /// A buffer low watermark capacity
-    pub write_buf_lw: usize,
-
-    /// A buffer high watermark capacity
-    pub write_buf_hw: usize,
-
-    /// This private field allows us to add additional fields in the future in a
-    /// backwards compatible way.
-    _priv: (),
+    flags: Flags,
 }
 
 impl<T, U> FramedParts<T, U> {
@@ -449,11 +401,9 @@ impl<T, U> FramedParts<T, U> {
         FramedParts {
             io,
             codec,
+            flags: Flags::empty(),
             read_buf: BytesMut::new(),
             write_buf: BytesMut::new(),
-            write_buf_lw: LW,
-            write_buf_hw: HW,
-            _priv: (),
         }
     }
 
@@ -463,10 +413,8 @@ impl<T, U> FramedParts<T, U> {
             io,
             codec,
             read_buf,
+            flags: Flags::empty(),
             write_buf: BytesMut::new(),
-            write_buf_lw: LW,
-            write_buf_hw: HW,
-            _priv: (),
         }
     }
 }

actix-codec/src/lib.rs

@@ -6,9 +6,7 @@
 //!
 //! [`AsyncRead`]: #
 //! [`AsyncWrite`]: #
-//! [`Sink`]: #
-//! [`Stream`]: #
-//! [transports]: #
+#![deny(rust_2018_idioms, warnings)]
 
 mod bcodec;
 mod framed;
@@ -16,5 +14,5 @@ mod framed;
 pub use self::bcodec::BytesCodec;
 pub use self::framed::{Framed, FramedParts};
 
-pub use tokio_codec::{Decoder, Encoder};
-pub use tokio_io::{AsyncRead, AsyncWrite};
+pub use tokio::io::{AsyncRead, AsyncWrite};
+pub use tokio_util::codec::{Decoder, Encoder};

actix-connect/CHANGES.md

@@ -1,5 +1,27 @@
 # Changes
 
+## [1.0.1] - 2019-12-15
+
+* Fix trust-dns-resolver compilation
+
+## [1.0.0] - 2019-12-11
+
+* Release
+
+## [1.0.0-alpha.3] - 2019-12-07
+
+### Changed
+
+* Migrate to tokio 0.2
+
+
+## [1.0.0-alpha.2] - 2019-12-02
+
+### Changed
+
+* Migrated to `std::future`
+
+
 ## [0.3.0] - 2019-10-03
 
 ### Changed

actix-connect/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-connect"
-version = "1.0.0-alpha.1"
+version = "1.0.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix connect - tcp connector service"
 keywords = ["network", "framework", "async", "futures"]
@@ -9,7 +9,6 @@ repository = "https://github.com/actix/actix-net.git"
 documentation = "https://docs.rs/actix-connect/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
 workspace = ".."
 
@@ -33,31 +32,27 @@ rustls = ["rust-tls", "tokio-rustls", "webpki"]
 uri = ["http"]
 
 [dependencies]
-actix-service = "1.0.0-alpha.1"
-actix-codec = "0.2.0-alpha.1"
-actix-utils = "0.5.0-alpha.1"
-actix-rt = "1.0.0-alpha.1"
-derive_more = "0.15"
+actix-service = "1.0.0"
+actix-codec = "0.2.0"
+actix-utils = "1.0.3"
+actix-rt = "1.0.0"
+derive_more = "0.99.2"
 either = "1.5.2"
 futures = "0.3.1"
-http = { version = "0.1.17", optional = true }
+http = { version = "0.2.0", optional = true }
 log = "0.4"
-tokio-net = "=0.2.0-alpha.6"
-tokio-executor = "=0.2.0-alpha.6"
-trust-dns-resolver = { version="0.18.0-alpha.1", default-features = false }
+trust-dns-proto = "=0.18.0-alpha.2"
+trust-dns-resolver = "=0.18.0-alpha.2"
 
 # openssl
 open-ssl = { version="0.10", package = "openssl", optional = true }
-tokio-openssl = { version = "0.4.0-alpha.6", optional = true }
+tokio-openssl = { version = "0.4.0", optional = true }
 
 # rustls
 rust-tls = { version = "0.16.0", package = "rustls", optional = true }
-# tokio-rustls = { version = "0.10.0", optional = true }
-tokio-rustls = { git = "https://github.com/quininer/tokio-rustls.git", branch = "tokio-0.2", optional = true }
+tokio-rustls = { version = "0.12.0", optional = true }
 webpki = { version = "0.21", optional = true }
 
 [dev-dependencies]
-bytes = "0.4"
-actix-testing = { version="0.3.0-alpha.1" }
-actix-server-config = "0.3.0-alpha.1"
-tokio = "0.2.0-alpha.6"
+bytes = "0.5.3"
+actix-testing = { version="1.0.0" }

actix-connect/src/connect.rs

@@ -132,7 +132,7 @@ impl<T: Address> From<T> for Connect<T> {
 }
 
 impl<T: Address> fmt::Display for Connect<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}:{}", self.host(), self.port())
     }
 }
@@ -163,7 +163,7 @@ impl Iterator for ConnectAddrsIter<'_> {
 }
 
 impl fmt::Debug for ConnectAddrsIter<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.clone()).finish()
     }
 }
@@ -275,7 +275,7 @@ impl<T, U> std::ops::DerefMut for Connection<T, U> {
 }
 
 impl<T, U: fmt::Debug> fmt::Debug for Connection<T, U> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Stream {{{:?}}}", self.io)
     }
 }

actix-connect/src/connector.rs

@@ -6,9 +6,9 @@ use std::net::SocketAddr;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
+use actix_rt::net::TcpStream;
 use actix_service::{Service, ServiceFactory};
 use futures::future::{err, ok, BoxFuture, Either, FutureExt, Ready};
-use tokio_net::tcp::TcpStream;
 
 use super::connect::{Address, Connect, Connection};
 use super::error::ConnectError;
@@ -49,7 +49,7 @@ impl<T: Address> ServiceFactory for TcpConnectorFactory<T> {
     type InitError = ();
     type Future = Ready<Result<Self::Service, Self::InitError>>;
 
-    fn new_service(&self, _: &()) -> Self::Future {
+    fn new_service(&self, _: ()) -> Self::Future {
         ok(self.service())
     }
 }
@@ -76,7 +76,7 @@ impl<T: Address> Service for TcpConnector<T> {
     type Error = ConnectError;
     type Future = Either<TcpConnectorResponse<T>, Ready<Result<Self::Response, Self::Error>>>;
 
-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
@@ -134,7 +134,7 @@ impl<T: Address> TcpConnectorResponse<T> {
 impl<T: Address> Future for TcpConnectorResponse<T> {
     type Output = Result<Connection<T, TcpStream>, ConnectError>;
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
 
         // connect

actix-connect/src/lib.rs

@@ -2,9 +2,10 @@
 //!
 //! ## Package feature
 //!
-//! * `ssl` - enables ssl support via `openssl` crate
-//! * `rust-tls` - enables ssl support via `rustls` crate
-
+//! * `openssl` - enables ssl support via `openssl` crate
+//! * `rustls` - enables ssl support via `rustls` crate
+#![deny(rust_2018_idioms, warnings)]
+#![allow(clippy::type_complexity)]
 #![recursion_limit = "128"]
 
 #[macro_use]
@@ -13,30 +14,34 @@ extern crate log;
 mod connect;
 mod connector;
 mod error;
-mod resolver;
+mod resolve;
 mod service;
 pub mod ssl;
 
 #[cfg(feature = "uri")]
 mod uri;
 
-use actix_rt::Arbiter;
+use actix_rt::{net::TcpStream, Arbiter};
 use actix_service::{pipeline, pipeline_factory, Service, ServiceFactory};
-use tokio_net::tcp::TcpStream;
+use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
+use trust_dns_resolver::system_conf::read_system_conf;
+use trust_dns_resolver::AsyncResolver;
 
-pub use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
-pub use trust_dns_resolver::system_conf::read_system_conf;
-pub use trust_dns_resolver::{error::ResolveError, AsyncResolver};
+pub mod resolver {
+    pub use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
+    pub use trust_dns_resolver::system_conf::read_system_conf;
+    pub use trust_dns_resolver::{error::ResolveError, AsyncResolver};
+}
 
 pub use self::connect::{Address, Connect, Connection};
 pub use self::connector::{TcpConnector, TcpConnectorFactory};
 pub use self::error::ConnectError;
-pub use self::resolver::{Resolver, ResolverFactory};
+pub use self::resolve::{Resolver, ResolverFactory};
 pub use self::service::{ConnectService, ConnectServiceFactory, TcpConnectService};
 
 pub fn start_resolver(cfg: ResolverConfig, opts: ResolverOpts) -> AsyncResolver {
     let (resolver, bg) = AsyncResolver::new(cfg, opts);
-    tokio_executor::current_thread::spawn(bg);
+    actix_rt::spawn(bg);
     resolver
 }
 
@@ -44,7 +49,7 @@ struct DefaultResolver(AsyncResolver);
 
 pub(crate) fn get_default_resolver() -> AsyncResolver {
     if Arbiter::contains_item::<DefaultResolver>() {
-        return Arbiter::get_item(|item: &DefaultResolver| item.0.clone());
+        Arbiter::get_item(|item: &DefaultResolver| item.0.clone())
     } else {
         let (cfg, opts) = match read_system_conf() {
             Ok((cfg, opts)) => (cfg, opts),
@@ -55,7 +60,7 @@ pub(crate) fn get_default_resolver() -> AsyncResolver {
         };
 
         let (resolver, bg) = AsyncResolver::new(cfg, opts);
-        tokio_executor::current_thread::spawn(bg);
+        actix_rt::spawn(bg);
 
         Arbiter::set_item(DefaultResolver(resolver.clone()));
         resolver

actix-connect/src/resolve.rs

@@ -63,7 +63,7 @@ impl<T: Address> ServiceFactory for ResolverFactory<T> {
     type InitError = ();
     type Future = Ready<Result<Self::Service, Self::InitError>>;
 
-    fn new_service(&self, _: &()) -> Self::Future {
+    fn new_service(&self, _: ()) -> Self::Future {
         ok(self.service())
     }
 }
@@ -108,7 +108,7 @@ impl<T: Address> Service for Resolver<T> {
     type Error = ConnectError;
     type Future = Either<ResolverFuture<T>, Ready<Result<Connect<T>, Self::Error>>>;
 
-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
@@ -153,7 +153,7 @@ impl<T: Address> ResolverFuture<T> {
 impl<T: Address> Future for ResolverFuture<T> {
     type Output = Result<Connect<T>, ConnectError>;
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
 
         match Pin::new(&mut this.lookup).poll(cx) {

actix-connect/src/service.rs

@@ -2,16 +2,16 @@ use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
+use actix_rt::net::TcpStream;
 use actix_service::{Service, ServiceFactory};
 use either::Either;
 use futures::future::{ok, Ready};
-use tokio_net::tcp::TcpStream;
 use trust_dns_resolver::AsyncResolver;
 
 use crate::connect::{Address, Connect, Connection};
 use crate::connector::{TcpConnector, TcpConnectorFactory};
 use crate::error::ConnectError;
-use crate::resolver::{Resolver, ResolverFactory};
+use crate::resolve::{Resolver, ResolverFactory};
 
 pub struct ConnectServiceFactory<T> {
     tcp: TcpConnectorFactory<T>,
@@ -79,7 +79,7 @@ impl<T: Address> ServiceFactory for ConnectServiceFactory<T> {
     type InitError = ();
     type Future = Ready<Result<Self::Service, Self::InitError>>;
 
-    fn new_service(&self, _: &()) -> Self::Future {
+    fn new_service(&self, _: ()) -> Self::Future {
         ok(self.service())
     }
 }
@@ -96,7 +96,7 @@ impl<T: Address> Service for ConnectService<T> {
     type Error = ConnectError;
     type Future = ConnectServiceResponse<T>;
 
-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
@@ -116,7 +116,7 @@ enum ConnectState<T: Address> {
 impl<T: Address> ConnectState<T> {
     fn poll(
         &mut self,
-        cx: &mut Context,
+        cx: &mut Context<'_>,
     ) -> Either<Poll<Result<Connection<T, TcpStream>, ConnectError>>, Connect<T>> {
         match self {
             ConnectState::Resolve(ref mut fut) => match Pin::new(fut).poll(cx) {
@@ -137,7 +137,7 @@ pub struct ConnectServiceResponse<T: Address> {
 impl<T: Address> Future for ConnectServiceResponse<T> {
     type Output = Result<Connection<T, TcpStream>, ConnectError>;
 
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let res = match self.state.poll(cx) {
             Either::Right(res) => {
                 self.state = ConnectState::Connect(self.tcp.call(res));
@@ -165,7 +165,7 @@ impl<T: Address + 'static> Service for TcpConnectService<T> {
     type Error = ConnectError;
     type Future = TcpConnectServiceResponse<T>;
 
-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
@@ -185,7 +185,7 @@ enum TcpConnectState<T: Address> {
 impl<T: Address> TcpConnectState<T> {
     fn poll(
         &mut self,
-        cx: &mut Context,
+        cx: &mut Context<'_>,
     ) -> Either<Poll<Result<TcpStream, ConnectError>>, Connect<T>> {
         match self {
             TcpConnectState::Resolve(ref mut fut) => match Pin::new(fut).poll(cx) {
@@ -214,7 +214,7 @@ pub struct TcpConnectServiceResponse<T: Address> {
 impl<T: Address> Future for TcpConnectServiceResponse<T> {
     type Output = Result<TcpStream, ConnectError>;
 
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let res = match self.state.poll(cx) {
             Either::Right(res) => {
                 self.state = TcpConnectState::Connect(self.tcp.call(res));

actix-connect/src/ssl/mod.rs

@@ -1,13 +1,7 @@
 //! SSL Services
 
 #[cfg(feature = "openssl")]
-mod openssl;
-#[cfg(feature = "openssl")]
-pub use self::openssl::{
-    OpensslConnectService, OpensslConnectServiceFactory, OpensslConnector,
-};
+pub mod openssl;
 
 #[cfg(feature = "rustls")]
-mod rustls;
-#[cfg(feature = "rustls")]
-pub use self::rustls::RustlsConnector;
+pub mod rustls;

actix-connect/src/ssl/openssl.rs

@@ -4,12 +4,13 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::{fmt, io};
 
+pub use open_ssl::ssl::{Error as SslError, SslConnector, SslMethod};
+pub use tokio_openssl::{HandshakeError, SslStream};
+
 use actix_codec::{AsyncRead, AsyncWrite};
+use actix_rt::net::TcpStream;
 use actix_service::{Service, ServiceFactory};
 use futures::future::{err, ok, Either, FutureExt, LocalBoxFuture, Ready};
-use open_ssl::ssl::SslConnector;
-use tokio_net::tcp::TcpStream;
-use tokio_openssl::{HandshakeError, SslStream};
 use trust_dns_resolver::AsyncResolver;
 
 use crate::{
@@ -38,7 +39,7 @@ where
 {
     pub fn service(connector: SslConnector) -> OpensslConnectorService<T, U> {
         OpensslConnectorService {
-            connector: connector,
+            connector,
             _t: PhantomData,
         }
     }
@@ -66,7 +67,7 @@ where
     type InitError = ();
     type Future = Ready<Result<Self::Service, Self::InitError>>;
 
-    fn new_service(&self, _: &()) -> Self::Future {
+    fn new_service(&self, _: ()) -> Self::Future {
         ok(OpensslConnectorService {
             connector: self.connector.clone(),
             _t: PhantomData,
@@ -98,7 +99,7 @@ where
     type Error = io::Error;
     type Future = Either<ConnectAsyncExt<T, U>, Ready<Result<Self::Response, Self::Error>>>;
 
-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
@@ -131,7 +132,7 @@ where
 {
     type Output = Result<Connection<T, SslStream<U>>, io::Error>;
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
 
         match Pin::new(&mut this.fut).poll(cx) {
@@ -201,7 +202,7 @@ impl<T: Address + 'static> ServiceFactory for OpensslConnectServiceFactory<T> {
     type InitError = ();
     type Future = Ready<Result<Self::Service, Self::InitError>>;
 
-    fn new_service(&self, _: &()) -> Self::Future {
+    fn new_service(&self, _: ()) -> Self::Future {
         ok(self.service())
     }
 }
@@ -218,7 +219,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>> {
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
@@ -240,14 +241,14 @@ pub struct OpensslConnectServiceResponse<T: Address + 'static> {
 impl<T: Address> Future for OpensslConnectServiceResponse<T> {
     type Output = Result<SslStream<TcpStream>, ConnectError>;
 
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         if let Some(ref mut fut) = self.fut1 {
             match futures::ready!(Pin::new(fut).poll(cx)) {
                 Ok(res) => {
                     let _ = self.fut1.take();
                     self.fut2 = Some(self.openssl.call(res));
                 }
-                Err(e) => return Poll::Ready(Err(e.into())),
+                Err(e) => return Poll::Ready(Err(e)),
             }
         }
 

actix-connect/src/ssl/rustls.rs

@@ -5,10 +5,13 @@ use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll};
 
+pub use rust_tls::Session;
+pub use tokio_rustls::{client::TlsStream, rustls::ClientConfig};
+
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_service::{Service, ServiceFactory};
 use futures::future::{ok, Ready};
-use tokio_rustls::{client::TlsStream, rustls::ClientConfig, Connect, TlsConnector};
+use tokio_rustls::{Connect, TlsConnector};
 use webpki::DNSNameRef;
 
 use crate::{Address, Connection};
@@ -62,7 +65,7 @@ where
     type InitError = ();
     type Future = Ready<Result<Self::Service, Self::InitError>>;
 
-    fn new_service(&self, _: &()) -> Self::Future {
+    fn new_service(&self, _: ()) -> Self::Future {
         ok(RustlsConnectorService {
             connector: self.connector.clone(),
             _t: PhantomData,
@@ -93,7 +96,7 @@ where
     type Error = std::io::Error;
     type Future = ConnectAsyncExt<T, U>;
 
-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         Poll::Ready(Ok(()))
     }
 
@@ -120,7 +123,7 @@ where
 {
     type Output = Result<Connection<T, TlsStream<U>>, std::io::Error>;
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
         Poll::Ready(
             futures::ready!(Pin::new(&mut this.fut).poll(cx)).map(|stream| {

actix-connect/tests/test_connect.rs

@@ -1,22 +1,22 @@
 use std::io;
 
 use actix_codec::{BytesCodec, Framed};
-use actix_server_config::Io;
-use actix_service::{service_fn, Service, ServiceFactory};
-use actix_testing::{self as test, TestServer};
+use actix_rt::net::TcpStream;
+use actix_service::{fn_service, Service, ServiceFactory};
+use actix_testing::TestServer;
 use bytes::Bytes;
 use futures::SinkExt;
-use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
 
+use actix_connect::resolver::{ResolverConfig, ResolverOpts};
 use actix_connect::Connect;
 
 #[cfg(feature = "openssl")]
-#[test]
-fn test_string() {
+#[actix_rt::test]
+async fn test_string() {
     let srv = TestServer::with(|| {
-        service_fn(|io: Io<tokio_net::tcp::TcpStream>| {
+        fn_service(|io: TcpStream| {
             async {
-                let mut framed = Framed::new(io.into_parts().0, BytesCodec);
+                let mut framed = Framed::new(io, BytesCodec);
                 framed.send(Bytes::from_static(b"test")).await?;
                 Ok::<_, io::Error>(())
             }
@@ -25,17 +25,17 @@ fn test_string() {
 
     let mut conn = actix_connect::default_connector();
     let addr = format!("localhost:{}", srv.port());
-    let con = test::call_service(&mut conn, addr.into());
+    let con = conn.call(addr.into()).await.unwrap();
     assert_eq!(con.peer_addr().unwrap(), srv.addr());
 }
 
 #[cfg(feature = "rustls")]
-#[test]
-fn test_rustls_string() {
+#[actix_rt::test]
+async fn test_rustls_string() {
     let srv = TestServer::with(|| {
-        service_fn(|io: Io<tokio_net::tcp::TcpStream>| {
+        fn_service(|io: TcpStream| {
             async {
-                let mut framed = Framed::new(io.into_parts().0, BytesCodec);
+                let mut framed = Framed::new(io, BytesCodec);
                 framed.send(Bytes::from_static(b"test")).await?;
                 Ok::<_, io::Error>(())
             }
@@ -44,16 +44,16 @@ fn test_rustls_string() {
 
     let mut conn = actix_connect::default_connector();
     let addr = format!("localhost:{}", srv.port());
-    let con = test::call_service(&mut conn, addr.into());
+    let con = conn.call(addr.into()).await.unwrap();
     assert_eq!(con.peer_addr().unwrap(), srv.addr());
 }
 
-#[tokio::test]
+#[actix_rt::test]
 async fn test_static_str() {
     let srv = TestServer::with(|| {
-        service_fn(|io: Io<tokio_net::tcp::TcpStream>| {
+        fn_service(|io: TcpStream| {
             async {
-                let mut framed = Framed::new(io.into_parts().0, BytesCodec);
+                let mut framed = Framed::new(io, BytesCodec);
                 framed.send(Bytes::from_static(b"test")).await?;
                 Ok::<_, io::Error>(())
             }
@@ -72,37 +72,37 @@ async fn test_static_str() {
     assert!(con.is_err());
 }
 
-#[test]
-fn test_new_service() {
+#[actix_rt::test]
+async fn test_new_service() {
     let srv = TestServer::with(|| {
-        service_fn(|io: Io<tokio_net::tcp::TcpStream>| {
+        fn_service(|io: TcpStream| {
             async {
-                let mut framed = Framed::new(io.into_parts().0, BytesCodec);
+                let mut framed = Framed::new(io, BytesCodec);
                 framed.send(Bytes::from_static(b"test")).await?;
                 Ok::<_, io::Error>(())
             }
         })
     });
 
-    let resolver = test::block_on(async {
-        actix_connect::start_resolver(ResolverConfig::default(), ResolverOpts::default())
-    });
-    let factory = test::block_on(async { actix_connect::new_connector_factory(resolver) });
+    let resolver =
+        actix_connect::start_resolver(ResolverConfig::default(), ResolverOpts::default());
 
-    let mut conn = test::block_on(factory.new_service(&())).unwrap();
-    let con = test::block_on(conn.call(Connect::with("10", srv.addr()))).unwrap();
+    let factory = actix_connect::new_connector_factory(resolver);
+
+    let mut conn = factory.new_service(()).await.unwrap();
+    let con = conn.call(Connect::with("10", srv.addr())).await.unwrap();
     assert_eq!(con.peer_addr().unwrap(), srv.addr());
 }
 
 #[cfg(feature = "openssl")]
-#[test]
-fn test_uri() {
-    use http::HttpTryFrom;
+#[actix_rt::test]
+async fn test_uri() {
+    use std::convert::TryFrom;
 
     let srv = TestServer::with(|| {
-        service_fn(|io: Io<tokio_net::tcp::TcpStream>| {
+        fn_service(|io: TcpStream| {
             async {
-                let mut framed = Framed::new(io.into_parts().0, BytesCodec);
+                let mut framed = Framed::new(io, BytesCodec);
                 framed.send(Bytes::from_static(b"test")).await?;
                 Ok::<_, io::Error>(())
             }
@@ -111,19 +111,19 @@ fn test_uri() {
 
     let mut conn = actix_connect::default_connector();
     let addr = http::Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
-    let con = test::call_service(&mut conn, addr.into());
+    let con = conn.call(addr.into()).await.unwrap();
     assert_eq!(con.peer_addr().unwrap(), srv.addr());
 }
 
 #[cfg(feature = "rustls")]
-#[test]
-fn test_rustls_uri() {
-    use http::HttpTryFrom;
+#[actix_rt::test]
+async fn test_rustls_uri() {
+    use std::convert::TryFrom;
 
     let srv = TestServer::with(|| {
-        service_fn(|io: Io<tokio_net::tcp::TcpStream>| {
+        fn_service(|io: TcpStream| {
             async {
-                let mut framed = Framed::new(io.into_parts().0, BytesCodec);
+                let mut framed = Framed::new(io, BytesCodec);
                 framed.send(Bytes::from_static(b"test")).await?;
                 Ok::<_, io::Error>(())
             }
@@ -132,6 +132,6 @@ fn test_rustls_uri() {
 
     let mut conn = actix_connect::default_connector();
     let addr = http::Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
-    let con = test::call_service(&mut conn, addr.into());
+    let con = conn.call(addr.into()).await.unwrap();
     assert_eq!(con.peer_addr().unwrap(), srv.addr());
 }

actix-ioframe/CHANGES.md

@@ -1,11 +1,33 @@
 # Changes
 
+## [0.5.0] - 2019-12-29
+
+* Simplify state management
+
+* Allow to set custom output stream
+
+* Removed disconnect callback
+
+## [0.4.1] - 2019-12-11
+
+* Disconnect callback accepts owned state
+
+## [0.4.0] - 2019-12-11
+
+* Remove `E` param
+
+## [0.3.0-alpha.3] - 2019-12-07
+
+* Migrate to tokio 0.2
+
+## [0.3.0-alpha.2] - 2019-12-02
+
+* Migrate to `std::future`
 
 ## [0.1.1] - 2019-10-14
 
 * Re-register task on every dispatcher poll.
 
-
 ## [0.1.0] - 2019-09-25
 
 * Initial release

actix-ioframe/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-ioframe"
-version = "0.3.0-alpha.1"
+version = "0.5.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix framed service"
 keywords = ["network", "framework", "async", "futures"]
@@ -9,29 +9,23 @@ repository = "https://github.com/actix/actix-net.git"
 documentation = "https://docs.rs/actix-ioframe/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
-workspace = ".."
 
 [lib]
 name = "actix_ioframe"
 path = "src/lib.rs"
 
 [dependencies]
-actix-service = "1.0.0-alpha.1"
-actix-codec = "0.2.0-alpha.1"
-actix-utils = "0.5.0-alpha.1"
-bytes = "0.4"
-either = "1.5.2"
+actix-service = "1.0.1"
+actix-codec = "0.2.0"
+actix-utils = "1.0.4"
+actix-rt = "1.0.0"
+bytes = "0.5.3"
+either = "1.5.3"
 futures = "0.3.1"
-pin-project = "0.4.5"
-tokio-executor = "=0.2.0-alpha.6"
+pin-project = "0.4.6"
 log = "0.4"
 
 [dev-dependencies]
-actix-rt = "1.0.0-alpha.1"
-actix-connect = "1.0.0-alpha.1"
-actix-testing = "0.3.0-alpha.1"
-actix-server-config = "0.3.0-alpha.1"
-tokio-net = "=0.2.0-alpha.6"
-tokio-timer = "=0.3.0-alpha.6"
+actix-connect = "1.0.0"
+actix-testing = "1.0.0"

actix-ioframe/src/cell.rs

@@ -1,39 +0,0 @@
-//! Custom cell impl
-
-use std::cell::UnsafeCell;
-use std::fmt;
-use std::rc::Rc;
-
-pub(crate) struct Cell<T> {
-    inner: Rc<UnsafeCell<T>>,
-}
-
-impl<T> Clone for Cell<T> {
-    fn clone(&self) -> Self {
-        Self {
-            inner: self.inner.clone(),
-        }
-    }
-}
-
-impl<T: fmt::Debug> fmt::Debug for Cell<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.inner.fmt(f)
-    }
-}
-
-impl<T> Cell<T> {
-    pub fn new(inner: T) -> Self {
-        Self {
-            inner: Rc::new(UnsafeCell::new(inner)),
-        }
-    }
-
-    pub(crate) unsafe fn get_ref(&mut self) -> &T {
-        &*self.inner.as_ref().get()
-    }
-
-    pub(crate) unsafe fn get_mut(&mut self) -> &mut T {
-        &mut *self.inner.as_ref().get()
-    }
-}

actix-ioframe/src/connect.rs

@@ -3,20 +3,21 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 
 use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
-use actix_utils::mpsc;
+use actix_utils::mpsc::Receiver;
 use futures::Stream;
 
-use crate::dispatcher::FramedMessage;
-use crate::sink::Sink;
-
-pub struct Connect<Io, St = (), Codec = ()> {
+pub struct Connect<Io, Codec>
+where
+    Codec: Encoder + Decoder,
+{
     io: Io,
-    _t: PhantomData<(St, Codec)>,
+    _t: PhantomData<Codec>,
 }
 
-impl<Io> Connect<Io>
+impl<Io, Codec> Connect<Io, Codec>
 where
     Io: AsyncRead + AsyncWrite,
+    Codec: Encoder + Decoder,
 {
     pub(crate) fn new(io: Io) -> Self {
         Self {
@@ -25,36 +26,26 @@ where
         }
     }
 
-    pub fn codec<Codec>(self, codec: Codec) -> ConnectResult<Io, (), Codec>
-    where
-        Codec: Encoder + Decoder,
-    {
-        let (tx, rx) = mpsc::channel();
-        let sink = Sink::new(tx);
-
+    pub fn codec(
+        self,
+        codec: Codec,
+    ) -> ConnectResult<Io, (), Codec, Receiver<<Codec as Encoder>::Item>> {
         ConnectResult {
             state: (),
+            out: None,
             framed: Framed::new(self.io, codec),
-            rx,
-            sink,
         }
     }
 }
 
 #[pin_project::pin_project]
-pub struct ConnectResult<Io, St, Codec: Encoder + Decoder> {
+pub struct ConnectResult<Io, St, Codec: Encoder + Decoder, Out> {
     pub(crate) state: St,
+    pub(crate) out: Option<Out>,
     pub(crate) framed: Framed<Io, Codec>,
-    pub(crate) rx: mpsc::Receiver<FramedMessage<<Codec as Encoder>::Item>>,
-    pub(crate) sink: Sink<<Codec as Encoder>::Item>,
 }
 
-impl<Io, St, Codec: Encoder + Decoder> ConnectResult<Io, St, Codec> {
-    #[inline]
-    pub fn sink(&self) -> &Sink<<Codec as Encoder>::Item> {
-        &self.sink
-    }
-
+impl<Io, St, Codec: Encoder + Decoder, Out: Unpin> ConnectResult<Io, St, Codec, Out> {
     #[inline]
     pub fn get_ref(&self) -> &Io {
         self.framed.get_ref()
@@ -65,38 +56,49 @@ impl<Io, St, Codec: Encoder + Decoder> ConnectResult<Io, St, Codec> {
         self.framed.get_mut()
     }
 
+    pub fn out<U>(self, out: U) -> ConnectResult<Io, St, Codec, U>
+    where
+        U: Stream<Item = <Codec as Encoder>::Item> + Unpin,
+    {
+        ConnectResult {
+            state: self.state,
+            framed: self.framed,
+            out: Some(out),
+        }
+    }
+
     #[inline]
-    pub fn state<S>(self, state: S) -> ConnectResult<Io, S, Codec> {
+    pub fn state<S>(self, state: S) -> ConnectResult<Io, S, Codec, Out> {
         ConnectResult {
             state,
             framed: self.framed,
-            rx: self.rx,
-            sink: self.sink,
+            out: self.out,
         }
     }
 }
 
-impl<Io, St, Codec> Stream for ConnectResult<Io, St, Codec>
+impl<Io, St, Codec, Out> Stream for ConnectResult<Io, St, Codec, Out>
 where
     Io: AsyncRead + AsyncWrite,
     Codec: Encoder + Decoder,
 {
     type Item = Result<<Codec as Decoder>::Item, <Codec as Decoder>::Error>;
 
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         self.project().framed.next_item(cx)
     }
 }
 
-impl<Io, St, Codec> futures::Sink<<Codec as Encoder>::Item> for ConnectResult<Io, St, Codec>
+impl<Io, St, Codec, Out> futures::Sink<<Codec as Encoder>::Item>
+    for ConnectResult<Io, St, Codec, Out>
 where
     Io: AsyncRead + AsyncWrite,
     Codec: Encoder + Decoder,
 {
     type Error = <Codec as Encoder>::Error;
 
-    fn poll_ready(self: Pin<&mut Self>, _: &mut Context) -> Poll<Result<(), Self::Error>> {
-        if self.framed.is_ready() {
+    fn poll_ready(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        if self.framed.is_write_ready() {
             Poll::Ready(Ok(()))
         } else {
             Poll::Pending

actix-ioframe/src/dispatcher.rs

@@ -1,86 +1,56 @@
 //! Framed dispatcher service and related utilities
-use std::collections::VecDeque;
-use std::mem;
 use std::pin::Pin;
-use std::rc::Rc;
 use std::task::{Context, Poll};
 
 use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
-use actix_service::{IntoService, Service};
-use actix_utils::task::LocalWaker;
-use actix_utils::{mpsc, oneshot};
-use futures::future::ready;
-use futures::{FutureExt, Sink as FutureSink, Stream};
+use actix_service::Service;
+use actix_utils::mpsc;
+use futures::Stream;
 use log::debug;
 
-use crate::cell::Cell;
 use crate::error::ServiceError;
-use crate::item::Item;
-use crate::sink::Sink;
-use crate::state::State;
 
-type Request<S, U> = Item<S, U>;
+type Request<U> = <U as Decoder>::Item;
 type Response<U> = <U as Encoder>::Item;
 
-pub(crate) enum FramedMessage<T> {
-    Message(T),
-    Close,
-    WaitClose(oneshot::Sender<()>),
-}
-
 /// FramedTransport - is a future that reads frames from Framed object
 /// and pass then to the service.
-#[pin_project::pin_project]
-pub(crate) struct FramedDispatcher<St, S, T, U>
+pub(crate) struct Dispatcher<S, T, U, Out>
 where
-    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
+    S: Service<Request = Request<U>, Response = Option<Response<U>>>,
     S::Error: 'static,
     S::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Encoder + Decoder,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <U as Encoder>::Item> + Unpin,
 {
     service: S,
-    sink: Sink<<U as Encoder>::Item>,
-    state: State<St>,
-    dispatch_state: FramedState<S, U>,
+    sink: Option<Out>,
+    state: FramedState<S, U>,
     framed: Framed<T, U>,
-    rx: Option<mpsc::Receiver<FramedMessage<<U as Encoder>::Item>>>,
-    inner: Cell<FramedDispatcherInner<<U as Encoder>::Item, S::Error>>,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
+    rx: mpsc::Receiver<Result<<U as Encoder>::Item, S::Error>>,
 }
 
-impl<St, S, T, U> FramedDispatcher<St, S, T, U>
+impl<S, T, U, Out> Dispatcher<S, T, U, Out>
 where
-    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
+    S: Service<Request = Request<U>, Response = Option<Response<U>>>,
     S::Error: 'static,
     S::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <U as Encoder>::Item> + Unpin,
 {
-    pub(crate) fn new<F: IntoService<S>>(
-        framed: Framed<T, U>,
-        state: State<St>,
-        service: F,
-        rx: mpsc::Receiver<FramedMessage<<U as Encoder>::Item>>,
-        sink: Sink<<U as Encoder>::Item>,
-        disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
-    ) -> Self {
-        FramedDispatcher {
-            framed,
-            state,
+    pub(crate) fn new(framed: Framed<T, U>, service: S, sink: Option<Out>) -> Self {
+        Dispatcher {
             sink,
-            disconnect,
-            rx: Some(rx),
-            service: service.into_service(),
-            dispatch_state: FramedState::Processing,
-            inner: Cell::new(FramedDispatcherInner {
-                buf: VecDeque::new(),
-                task: LocalWaker::new(),
-            }),
+            service,
+            framed,
+            rx: mpsc::channel().1,
+            state: FramedState::Processing,
         }
     }
 }
@@ -89,305 +59,184 @@ enum FramedState<S: Service, U: Encoder + Decoder> {
     Processing,
     Error(ServiceError<S::Error, U>),
     FramedError(ServiceError<S::Error, U>),
-    FlushAndStop(Vec<oneshot::Sender<()>>),
+    FlushAndStop,
     Stopping,
 }
 
 impl<S: Service, U: Encoder + Decoder> FramedState<S, U> {
-    fn stop(&mut self, tx: Option<oneshot::Sender<()>>) {
-        match self {
-            FramedState::FlushAndStop(ref mut vec) => {
-                if let Some(tx) = tx {
-                    vec.push(tx)
-                }
-            }
-            FramedState::Processing => {
-                *self = FramedState::FlushAndStop(if let Some(tx) = tx {
-                    vec![tx]
-                } else {
-                    Vec::new()
-                })
-            }
-            FramedState::Error(_) | FramedState::FramedError(_) | FramedState::Stopping => {
-                if let Some(tx) = tx {
-                    let _ = tx.send(());
-                }
-            }
+    fn take_error(&mut self) -> ServiceError<S::Error, U> {
+        match std::mem::replace(self, FramedState::Processing) {
+            FramedState::Error(err) => err,
+            _ => panic!(),
+        }
+    }
+
+    fn take_framed_error(&mut self) -> ServiceError<S::Error, U> {
+        match std::mem::replace(self, FramedState::Processing) {
+            FramedState::FramedError(err) => err,
+            _ => panic!(),
         }
     }
 }
 
-struct FramedDispatcherInner<I, E> {
-    buf: VecDeque<Result<I, E>>,
-    task: LocalWaker,
-}
-
-impl<St, S, T, U> FramedDispatcher<St, S, T, U>
+impl<S, T, U, Out> Dispatcher<S, T, U, Out>
 where
-    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
+    S: Service<Request = Request<U>, Response = Option<Response<U>>>,
     S::Error: 'static,
     S::Future: 'static,
     T: AsyncRead + AsyncWrite,
     U: Decoder + Encoder,
     <U as Encoder>::Item: 'static,
     <U as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <U as Encoder>::Item> + Unpin,
 {
-    pub(crate) fn poll(
-        &mut self,
-        cx: &mut Context,
-    ) -> Poll<Result<(), ServiceError<S::Error, U>>> {
-        let this = self;
-        unsafe { this.inner.get_ref().task.register(cx.waker()) };
+    fn poll_read(&mut self, cx: &mut Context<'_>) -> bool {
+        loop {
+            match self.service.poll_ready(cx) {
+                Poll::Ready(Ok(_)) => {
+                    let item = match self.framed.next_item(cx) {
+                        Poll::Ready(Some(Ok(el))) => el,
+                        Poll::Ready(Some(Err(err))) => {
+                            self.state = FramedState::FramedError(ServiceError::Decoder(err));
+                            return true;
+                        }
+                        Poll::Pending => return false,
+                        Poll::Ready(None) => {
+                            log::trace!("Client disconnected");
+                            self.state = FramedState::Stopping;
+                            return true;
+                        }
+                    };
 
-        poll(
-            cx,
-            &mut this.service,
-            &mut this.state,
-            &mut this.sink,
-            &mut this.framed,
-            &mut this.dispatch_state,
-            &mut this.rx,
-            &mut this.inner,
-            &mut this.disconnect,
-        )
-    }
-}
-
-fn poll<St, S, T, U>(
-    cx: &mut Context,
-    srv: &mut S,
-    state: &mut State<St>,
-    sink: &mut Sink<<U as Encoder>::Item>,
-    framed: &mut Framed<T, U>,
-    dispatch_state: &mut FramedState<S, U>,
-    rx: &mut Option<mpsc::Receiver<FramedMessage<<U as Encoder>::Item>>>,
-    inner: &mut Cell<FramedDispatcherInner<<U as Encoder>::Item, S::Error>>,
-    disconnect: &mut Option<Rc<dyn Fn(&mut St, bool)>>,
-) -> Poll<Result<(), ServiceError<S::Error, U>>>
-where
-    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
-    S::Error: 'static,
-    S::Future: 'static,
-    T: AsyncRead + AsyncWrite,
-    U: Decoder + Encoder,
-    <U as Encoder>::Item: 'static,
-    <U as Encoder>::Error: std::fmt::Debug,
-{
-    match mem::replace(dispatch_state, FramedState::Processing) {
-        FramedState::Processing => {
-            if poll_read(cx, srv, state, sink, framed, dispatch_state, inner)
-                || poll_write(cx, framed, dispatch_state, rx, inner)
-            {
-                poll(
-                    cx,
-                    srv,
-                    state,
-                    sink,
-                    framed,
-                    dispatch_state,
-                    rx,
-                    inner,
-                    disconnect,
-                )
-            } else {
-                Poll::Pending
-            }
-        }
-        FramedState::Error(err) => {
-            if framed.is_write_buf_empty()
-                || (poll_write(cx, framed, dispatch_state, rx, inner)
-                    || framed.is_write_buf_empty())
-            {
-                if let Some(ref disconnect) = disconnect {
-                    (&*disconnect)(&mut *state.get_mut(), true);
+                    let tx = self.rx.sender();
+                    let fut = self.service.call(item);
+                    actix_rt::spawn(async move {
+                        let item = fut.await;
+                        let item = match item {
+                            Ok(Some(item)) => Ok(item),
+                            Ok(None) => return,
+                            Err(err) => Err(err),
+                        };
+                        let _ = tx.send(item);
+                    });
+                }
+                Poll::Pending => return false,
+                Poll::Ready(Err(err)) => {
+                    self.state = FramedState::Error(ServiceError::Service(err));
+                    return true;
                 }
-                Poll::Ready(Err(err))
-            } else {
-                *dispatch_state = FramedState::Error(err);
-                Poll::Pending
             }
         }
-        FramedState::FlushAndStop(mut vec) => {
-            if !framed.is_write_buf_empty() {
-                match Pin::new(framed).poll_flush(cx) {
+    }
+
+    /// write to framed object
+    fn poll_write(&mut self, cx: &mut Context<'_>) -> bool {
+        loop {
+            while !self.framed.is_write_buf_full() {
+                match Pin::new(&mut self.rx).poll_next(cx) {
+                    Poll::Ready(Some(Ok(msg))) => {
+                        if let Err(err) = self.framed.write(msg) {
+                            self.state = FramedState::FramedError(ServiceError::Encoder(err));
+                            return true;
+                        }
+                        continue;
+                    }
+                    Poll::Ready(Some(Err(err))) => {
+                        self.state = FramedState::Error(ServiceError::Service(err));
+                        return true;
+                    }
+                    Poll::Ready(None) | Poll::Pending => (),
+                }
+
+                if self.sink.is_some() {
+                    match Pin::new(self.sink.as_mut().unwrap()).poll_next(cx) {
+                        Poll::Ready(Some(msg)) => {
+                            if let Err(err) = self.framed.write(msg) {
+                                self.state =
+                                    FramedState::FramedError(ServiceError::Encoder(err));
+                                return true;
+                            }
+                            continue;
+                        }
+                        Poll::Ready(None) => {
+                            let _ = self.sink.take();
+                            self.state = FramedState::FlushAndStop;
+                            return true;
+                        }
+                        Poll::Pending => (),
+                    }
+                }
+                break;
+            }
+
+            if !self.framed.is_write_buf_empty() {
+                match self.framed.flush(cx) {
+                    Poll::Pending => break,
+                    Poll::Ready(Ok(_)) => (),
                     Poll::Ready(Err(err)) => {
                         debug!("Error sending data: {:?}", err);
-                    }
-                    Poll::Pending => {
-                        *dispatch_state = FramedState::FlushAndStop(vec);
-                        return Poll::Pending;
-                    }
-                    Poll::Ready(_) => (),
-                }
-            };
-            for tx in vec.drain(..) {
-                let _ = tx.send(());
-            }
-            if let Some(ref disconnect) = disconnect {
-                (&*disconnect)(&mut *state.get_mut(), false);
-            }
-            Poll::Ready(Ok(()))
-        }
-        FramedState::FramedError(err) => {
-            if let Some(ref disconnect) = disconnect {
-                (&*disconnect)(&mut *state.get_mut(), true);
-            }
-            Poll::Ready(Err(err))
-        }
-        FramedState::Stopping => {
-            if let Some(ref disconnect) = disconnect {
-                (&*disconnect)(&mut *state.get_mut(), false);
-            }
-            Poll::Ready(Ok(()))
-        }
-    }
-}
-
-fn poll_read<St, S, T, U>(
-    cx: &mut Context,
-    srv: &mut S,
-    state: &mut State<St>,
-    sink: &mut Sink<<U as Encoder>::Item>,
-    framed: &mut Framed<T, U>,
-    dispatch_state: &mut FramedState<S, U>,
-    inner: &mut Cell<FramedDispatcherInner<<U as Encoder>::Item, S::Error>>,
-) -> bool
-where
-    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
-    S::Error: 'static,
-    S::Future: 'static,
-    T: AsyncRead + AsyncWrite,
-    U: Decoder + Encoder,
-    <U as Encoder>::Item: 'static,
-    <U as Encoder>::Error: std::fmt::Debug,
-{
-    loop {
-        match srv.poll_ready(cx) {
-            Poll::Ready(Ok(_)) => {
-                let item = match framed.next_item(cx) {
-                    Poll::Ready(Some(Ok(el))) => el,
-                    Poll::Ready(Some(Err(err))) => {
-                        *dispatch_state = FramedState::FramedError(ServiceError::Decoder(err));
-                        return true;
-                    }
-                    Poll::Pending => return false,
-                    Poll::Ready(None) => {
-                        log::trace!("Client disconnected");
-                        *dispatch_state = FramedState::Stopping;
-                        return true;
-                    }
-                };
-
-                let mut cell = inner.clone();
-                tokio_executor::current_thread::spawn(
-                    srv.call(Item::new(state.clone(), sink.clone(), item))
-                        .then(move |item| {
-                            let item = match item {
-                                Ok(Some(item)) => Ok(item),
-                                Ok(None) => return ready(()),
-                                Err(err) => Err(err),
-                            };
-                            unsafe {
-                                let inner = cell.get_mut();
-                                inner.buf.push_back(item);
-                                inner.task.wake();
-                            }
-                            ready(())
-                        }),
-                );
-            }
-            Poll::Pending => return false,
-            Poll::Ready(Err(err)) => {
-                *dispatch_state = FramedState::Error(ServiceError::Service(err));
-                return true;
-            }
-        }
-    }
-}
-
-/// write to framed object
-fn poll_write<St, S, T, U>(
-    cx: &mut Context,
-    framed: &mut Framed<T, U>,
-    dispatch_state: &mut FramedState<S, U>,
-    rx: &mut Option<mpsc::Receiver<FramedMessage<<U as Encoder>::Item>>>,
-    inner: &mut Cell<FramedDispatcherInner<<U as Encoder>::Item, S::Error>>,
-) -> bool
-where
-    S: Service<Request = Request<St, U>, Response = Option<Response<U>>>,
-    S::Error: 'static,
-    S::Future: 'static,
-    T: AsyncRead + AsyncWrite,
-    U: Decoder + Encoder,
-    <U as Encoder>::Item: 'static,
-    <U as Encoder>::Error: std::fmt::Debug,
-{
-    let inner = unsafe { inner.get_mut() };
-    let mut rx_done = rx.is_none();
-    let mut buf_empty = inner.buf.is_empty();
-    loop {
-        while !framed.is_write_buf_full() {
-            if !buf_empty {
-                match inner.buf.pop_front().unwrap() {
-                    Ok(msg) => {
-                        if let Err(err) = framed.write(msg) {
-                            *dispatch_state =
-                                FramedState::FramedError(ServiceError::Encoder(err));
-                            return true;
-                        }
-                        buf_empty = inner.buf.is_empty();
-                    }
-                    Err(err) => {
-                        *dispatch_state = FramedState::Error(ServiceError::Service(err));
+                        self.state = FramedState::FramedError(ServiceError::Encoder(err));
                         return true;
                     }
                 }
-            }
-
-            if !rx_done && rx.is_some() {
-                match Pin::new(rx.as_mut().unwrap()).poll_next(cx) {
-                    Poll::Ready(Some(FramedMessage::Message(msg))) => {
-                        if let Err(err) = framed.write(msg) {
-                            *dispatch_state =
-                                FramedState::FramedError(ServiceError::Encoder(err));
-                            return true;
-                        }
-                    }
-                    Poll::Ready(Some(FramedMessage::Close)) => {
-                        dispatch_state.stop(None);
-                        return true;
-                    }
-                    Poll::Ready(Some(FramedMessage::WaitClose(tx))) => {
-                        dispatch_state.stop(Some(tx));
-                        return true;
-                    }
-                    Poll::Ready(None) => {
-                        rx_done = true;
-                        let _ = rx.take();
-                    }
-                    Poll::Pending => rx_done = true,
-                }
-            }
-
-            if rx_done && buf_empty {
+            } else {
                 break;
             }
         }
-
-        if !framed.is_write_buf_empty() {
-            match framed.flush(cx) {
-                Poll::Pending => break,
-                Poll::Ready(Err(err)) => {
-                    debug!("Error sending data: {:?}", err);
-                    *dispatch_state = FramedState::FramedError(ServiceError::Encoder(err));
-                    return true;
-                }
-                Poll::Ready(_) => (),
-            }
-        } else {
-            break;
-        }
+        false
     }
 
-    false
+    pub(crate) fn poll(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), ServiceError<S::Error, U>>> {
+        match self.state {
+            FramedState::Processing => loop {
+                let read = self.poll_read(cx);
+                let write = self.poll_write(cx);
+                if read || write {
+                    continue;
+                } else {
+                    return Poll::Pending;
+                }
+            },
+            FramedState::Error(_) => {
+                // flush write buffer
+                if !self.framed.is_write_buf_empty() {
+                    if let Poll::Pending = self.framed.flush(cx) {
+                        return Poll::Pending;
+                    }
+                }
+                Poll::Ready(Err(self.state.take_error()))
+            }
+            FramedState::FlushAndStop => {
+                // drain service responses
+                match Pin::new(&mut self.rx).poll_next(cx) {
+                    Poll::Ready(Some(Ok(msg))) => {
+                        if let Err(_) = self.framed.write(msg) {
+                            return Poll::Ready(Ok(()));
+                        }
+                    }
+                    Poll::Ready(Some(Err(_))) => return Poll::Ready(Ok(())),
+                    Poll::Ready(None) | Poll::Pending => (),
+                }
+
+                // flush io
+                if !self.framed.is_write_buf_empty() {
+                    match self.framed.flush(cx) {
+                        Poll::Ready(Err(err)) => {
+                            debug!("Error sending data: {:?}", err);
+                        }
+                        Poll::Pending => {
+                            return Poll::Pending;
+                        }
+                        Poll::Ready(_) => (),
+                    }
+                };
+                Poll::Ready(Ok(()))
+            }
+            FramedState::FramedError(_) => Poll::Ready(Err(self.state.take_framed_error())),
+            FramedState::Stopping => Poll::Ready(Ok(())),
+        }
+    }
 }

actix-ioframe/src/error.rs

@@ -24,7 +24,7 @@ where
     <U as Encoder>::Error: fmt::Debug,
     <U as Decoder>::Error: fmt::Debug,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             ServiceError::Service(ref e) => write!(fmt, "ServiceError::Service({:?})", e),
             ServiceError::Encoder(ref e) => write!(fmt, "ServiceError::Encoder({:?})", e),
@@ -39,7 +39,7 @@ where
     <U as Encoder>::Error: fmt::Debug,
     <U as Decoder>::Error: fmt::Debug,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             ServiceError::Service(ref e) => write!(fmt, "{}", e),
             ServiceError::Encoder(ref e) => write!(fmt, "{:?}", e),

actix-ioframe/src/item.rs

@@ -1,90 +0,0 @@
-use std::cell::{Ref, RefMut};
-use std::fmt;
-use std::ops::{Deref, DerefMut};
-
-use actix_codec::{Decoder, Encoder};
-
-use crate::sink::Sink;
-use crate::state::State;
-
-pub struct Item<St, Codec: Encoder + Decoder> {
-    state: State<St>,
-    sink: Sink<<Codec as Encoder>::Item>,
-    item: <Codec as Decoder>::Item,
-}
-
-impl<St, Codec> Item<St, Codec>
-where
-    Codec: Encoder + Decoder,
-{
-    pub(crate) fn new(
-        state: State<St>,
-        sink: Sink<<Codec as Encoder>::Item>,
-        item: <Codec as Decoder>::Item,
-    ) -> Self {
-        Item { state, sink, item }
-    }
-
-    #[inline]
-    pub fn state(&self) -> Ref<St> {
-        self.state.get_ref()
-    }
-
-    #[inline]
-    pub fn state_mut(&mut self) -> RefMut<St> {
-        self.state.get_mut()
-    }
-
-    #[inline]
-    pub fn sink(&self) -> &Sink<<Codec as Encoder>::Item> {
-        &self.sink
-    }
-
-    #[inline]
-    pub fn into_inner(self) -> <Codec as Decoder>::Item {
-        self.item
-    }
-
-    #[inline]
-    pub fn into_parts(
-        self,
-    ) -> (
-        State<St>,
-        Sink<<Codec as Encoder>::Item>,
-        <Codec as Decoder>::Item,
-    ) {
-        (self.state, self.sink, self.item)
-    }
-}
-
-impl<St, Codec> Deref for Item<St, Codec>
-where
-    Codec: Encoder + Decoder,
-{
-    type Target = <Codec as Decoder>::Item;
-
-    #[inline]
-    fn deref(&self) -> &<Codec as Decoder>::Item {
-        &self.item
-    }
-}
-
-impl<St, Codec> DerefMut for Item<St, Codec>
-where
-    Codec: Encoder + Decoder,
-{
-    #[inline]
-    fn deref_mut(&mut self) -> &mut <Codec as Decoder>::Item {
-        &mut self.item
-    }
-}
-
-impl<St, Codec> fmt::Debug for Item<St, Codec>
-where
-    Codec: Encoder + Decoder,
-    <Codec as Decoder>::Item: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("FramedItem").field(&self.item).finish()
-    }
-}

actix-ioframe/src/lib.rs

@@ -1,15 +1,11 @@
-mod cell;
+// #![deny(rust_2018_idioms, warnings)]
+#![allow(clippy::type_complexity, clippy::too_many_arguments)]
+
 mod connect;
 mod dispatcher;
 mod error;
-mod item;
 mod service;
-mod sink;
-mod state;
 
 pub use self::connect::{Connect, ConnectResult};
 pub use self::error::ServiceError;
-pub use self::item::Item;
-pub use self::service::{Builder, NewServiceBuilder, ServiceBuilder};
-pub use self::sink::Sink;
-pub use self::state::State;
+pub use self::service::{Builder, FactoryBuilder};

actix-ioframe/src/service.rs

@@ -4,254 +4,267 @@ use std::pin::Pin;
 use std::rc::Rc;
 use std::task::{Context, Poll};
 
-use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder};
+use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
 use actix_service::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 use either::Either;
-use futures::future::{FutureExt, LocalBoxFuture};
+use futures::{ready, Stream};
 use pin_project::project;
 
 use crate::connect::{Connect, ConnectResult};
-use crate::dispatcher::FramedDispatcher;
+use crate::dispatcher::Dispatcher;
 use crate::error::ServiceError;
-use crate::item::Item;
-use crate::state::State;
 
-type RequestItem<S, U> = Item<S, U>;
+type RequestItem<U> = <U as Decoder>::Item;
 type ResponseItem<U> = Option<<U as Encoder>::Item>;
 
 /// Service builder - structure that follows the builder pattern
 /// for building instances for framed services.
-pub struct Builder<St, Codec>(PhantomData<(St, Codec)>);
-
-impl<St, Codec> Builder<St, Codec> {
-    pub fn new() -> Builder<St, Codec> {
-        Builder(PhantomData)
-    }
+pub struct Builder<St, C, Io, Codec, Out> {
+    connect: C,
+    _t: PhantomData<(St, Io, Codec, Out)>,
+}
 
+impl<St, C, Io, Codec, Out> Builder<St, C, Io, Codec, Out>
+where
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec, Out>>,
+    Io: AsyncRead + AsyncWrite,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
+{
     /// Construct framed handler service with specified connect service
-    pub fn service<Io, C, F>(self, connect: F) -> ServiceBuilder<St, C, Io, Codec>
+    pub fn new<F>(connect: F) -> Builder<St, C, Io, Codec, Out>
     where
         F: IntoService<C>,
         Io: AsyncRead + AsyncWrite,
-        C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
+        C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec, Out>>,
         Codec: Decoder + Encoder,
+        Out: Stream<Item = <Codec as Encoder>::Item>,
     {
-        ServiceBuilder {
+        Builder {
             connect: connect.into_service(),
-            disconnect: None,
             _t: PhantomData,
         }
     }
 
+    /// Provide stream items handler service and construct service factory.
+    pub fn build<F, T>(self, service: F) -> FramedServiceImpl<St, C, T, Io, Codec, Out>
+    where
+        F: IntoServiceFactory<T>,
+        T: ServiceFactory<
+            Config = St,
+            Request = RequestItem<Codec>,
+            Response = ResponseItem<Codec>,
+            Error = C::Error,
+            InitError = C::Error,
+        >,
+    {
+        FramedServiceImpl {
+            connect: self.connect,
+            handler: Rc::new(service.into_factory()),
+            _t: PhantomData,
+        }
+    }
+}
+
+/// Service builder - structure that follows the builder pattern
+/// for building instances for framed services.
+pub struct FactoryBuilder<St, C, Io, Codec, Out> {
+    connect: C,
+    _t: PhantomData<(St, Io, Codec, Out)>,
+}
+
+impl<St, C, Io, Codec, Out> FactoryBuilder<St, C, Io, Codec, Out>
+where
+    Io: AsyncRead + AsyncWrite,
+    C: ServiceFactory<
+        Config = (),
+        Request = Connect<Io, Codec>,
+        Response = ConnectResult<Io, St, Codec, Out>,
+    >,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
+{
     /// Construct framed handler new service with specified connect service
-    pub fn factory<Io, C, F>(self, connect: F) -> NewServiceBuilder<St, C, Io, Codec>
+    pub fn new<F>(connect: F) -> FactoryBuilder<St, C, Io, Codec, Out>
     where
         F: IntoServiceFactory<C>,
         Io: AsyncRead + AsyncWrite,
         C: ServiceFactory<
             Config = (),
-            Request = Connect<Io>,
-            Response = ConnectResult<Io, St, Codec>,
+            Request = Connect<Io, Codec>,
+            Response = ConnectResult<Io, St, Codec, Out>,
         >,
-        C::Error: 'static,
-        C::Future: 'static,
         Codec: Decoder + Encoder,
+        Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
     {
-        NewServiceBuilder {
+        FactoryBuilder {
             connect: connect.into_factory(),
-            disconnect: None,
             _t: PhantomData,
         }
     }
-}
 
-pub struct ServiceBuilder<St, C, Io, Codec> {
-    connect: C,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
-    _t: PhantomData<(St, Io, Codec)>,
-}
-
-impl<St, C, Io, Codec> ServiceBuilder<St, C, Io, Codec>
-where
-    St: 'static,
-    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
-    C::Error: 'static,
-    Io: AsyncRead + AsyncWrite,
-    Codec: Decoder + Encoder,
-    <Codec as Encoder>::Item: 'static,
-    <Codec as Encoder>::Error: std::fmt::Debug,
-{
-    /// Callback to execute on disconnect
-    ///
-    /// Second parameter indicates error occured during disconnect.
-    pub fn disconnect<F, Out>(mut self, disconnect: F) -> Self
-    where
-        F: Fn(&mut St, bool) + 'static,
-    {
-        self.disconnect = Some(Rc::new(disconnect));
-        self
-    }
-
-    /// Provide stream items handler service and construct service factory.
-    pub fn finish<F, T>(self, service: F) -> FramedServiceImpl<St, C, T, Io, Codec>
+    pub fn build<F, T, Cfg>(self, service: F) -> FramedService<St, C, T, Io, Codec, Out, Cfg>
     where
         F: IntoServiceFactory<T>,
         T: ServiceFactory<
-                Config = St,
-                Request = RequestItem<St, Codec>,
-                Response = ResponseItem<Codec>,
-                Error = C::Error,
-                InitError = C::Error,
-            > + 'static,
-    {
-        FramedServiceImpl {
-            connect: self.connect,
-            handler: Rc::new(service.into_factory()),
-            disconnect: self.disconnect.clone(),
-            _t: PhantomData,
-        }
-    }
-}
-
-pub struct NewServiceBuilder<St, C, Io, Codec> {
-    connect: C,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
-    _t: PhantomData<(St, Io, Codec)>,
-}
-
-impl<St, C, Io, Codec> NewServiceBuilder<St, C, Io, Codec>
-where
-    St: 'static,
-    Io: AsyncRead + AsyncWrite,
-    C: ServiceFactory<
-        Config = (),
-        Request = Connect<Io>,
-        Response = ConnectResult<Io, St, Codec>,
-    >,
-    C::Error: 'static,
-    C::Future: 'static,
-    Codec: Decoder + Encoder,
-    <Codec as Encoder>::Item: 'static,
-    <Codec as Encoder>::Error: std::fmt::Debug,
-{
-    /// Callback to execute on disconnect
-    ///
-    /// Second parameter indicates error occured during disconnect.
-    pub fn disconnect<F>(mut self, disconnect: F) -> Self
-    where
-        F: Fn(&mut St, bool) + 'static,
-    {
-        self.disconnect = Some(Rc::new(disconnect));
-        self
-    }
-
-    pub fn finish<F, T, Cfg>(self, service: F) -> FramedService<St, C, T, Io, Codec, Cfg>
-    where
-        F: IntoServiceFactory<T>,
-        T: ServiceFactory<
-                Config = St,
-                Request = RequestItem<St, Codec>,
-                Response = ResponseItem<Codec>,
-                Error = C::Error,
-                InitError = C::Error,
-            > + 'static,
+            Config = St,
+            Request = RequestItem<Codec>,
+            Response = ResponseItem<Codec>,
+            Error = C::Error,
+            InitError = C::Error,
+        >,
     {
         FramedService {
             connect: self.connect,
             handler: Rc::new(service.into_factory()),
-            disconnect: self.disconnect,
             _t: PhantomData,
         }
     }
 }
 
-pub struct FramedService<St, C, T, Io, Codec, Cfg> {
+pub struct FramedService<St, C, T, Io, Codec, Out, Cfg> {
     connect: C,
     handler: Rc<T>,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
-    _t: PhantomData<(St, Io, Codec, Cfg)>,
+    _t: PhantomData<(St, Io, Codec, Out, Cfg)>,
 }
 
-impl<St, C, T, Io, Codec, Cfg> ServiceFactory for FramedService<St, C, T, Io, Codec, Cfg>
+impl<St, C, T, Io, Codec, Out, Cfg> ServiceFactory
+    for FramedService<St, C, T, Io, Codec, Out, Cfg>
 where
-    St: 'static,
     Io: AsyncRead + AsyncWrite,
     C: ServiceFactory<
         Config = (),
-        Request = Connect<Io>,
-        Response = ConnectResult<Io, St, Codec>,
+        Request = Connect<Io, Codec>,
+        Response = ConnectResult<Io, St, Codec, Out>,
     >,
-    C::Error: 'static,
-    C::Future: 'static,
     T: ServiceFactory<
-            Config = St,
-            Request = RequestItem<St, Codec>,
-            Response = ResponseItem<Codec>,
-            Error = C::Error,
-            InitError = C::Error,
-        > + 'static,
+        Config = St,
+        Request = RequestItem<Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <T::Service as Service>::Error: 'static,
     <T::Service as Service>::Future: 'static,
     Codec: Decoder + Encoder,
     <Codec as Encoder>::Item: 'static,
     <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
     type Config = Cfg;
     type Request = Io;
     type Response = ();
     type Error = ServiceError<C::Error, Codec>;
     type InitError = C::InitError;
-    type Service = FramedServiceImpl<St, C::Service, T, Io, Codec>;
-    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, _: &Cfg) -> Self::Future {
-        let handler = self.handler.clone();
-        let disconnect = self.disconnect.clone();
+    type Service = FramedServiceImpl<St, C::Service, T, Io, Codec, Out>;
+    type Future = FramedServiceResponse<St, C, T, Io, Codec, Out>;
 
+    fn new_service(&self, _: Cfg) -> Self::Future {
         // create connect service and then create service impl
-        self.connect
-            .new_service(&())
-            .map(move |result| {
-                result.map(move |connect| FramedServiceImpl {
-                    connect,
-                    handler,
-                    disconnect,
-                    _t: PhantomData,
-                })
-            })
-            .boxed_local()
+        FramedServiceResponse {
+            fut: self.connect.new_service(()),
+            handler: self.handler.clone(),
+        }
     }
 }
 
-pub struct FramedServiceImpl<St, C, T, Io, Codec> {
-    connect: C,
-    handler: Rc<T>,
-    disconnect: Option<Rc<dyn Fn(&mut St, bool)>>,
-    _t: PhantomData<(St, Io, Codec)>,
-}
-
-impl<St, C, T, Io, Codec> Service for FramedServiceImpl<St, C, T, Io, Codec>
+#[pin_project::pin_project]
+pub struct FramedServiceResponse<St, C, T, Io, Codec, Out>
 where
     Io: AsyncRead + AsyncWrite,
-    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
-    C::Error: 'static,
+    C: ServiceFactory<
+        Config = (),
+        Request = Connect<Io, Codec>,
+        Response = ConnectResult<Io, St, Codec, Out>,
+    >,
     T: ServiceFactory<
         Config = St,
-        Request = RequestItem<St, Codec>,
+        Request = RequestItem<Codec>,
         Response = ResponseItem<Codec>,
         Error = C::Error,
         InitError = C::Error,
     >,
+    <T::Service as Service>::Error: 'static,
     <T::Service as Service>::Future: 'static,
     Codec: Decoder + Encoder,
     <Codec as Encoder>::Item: 'static,
     <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
+{
+    #[pin]
+    fut: C::Future,
+    handler: Rc<T>,
+}
+
+impl<St, C, T, Io, Codec, Out> Future for FramedServiceResponse<St, C, T, Io, Codec, Out>
+where
+    Io: AsyncRead + AsyncWrite,
+    C: ServiceFactory<
+        Config = (),
+        Request = Connect<Io, Codec>,
+        Response = ConnectResult<Io, St, Codec, Out>,
+    >,
+    T: ServiceFactory<
+        Config = St,
+        Request = RequestItem<Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <T::Service as Service>::Error: 'static,
+    <T::Service as Service>::Future: 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
+{
+    type Output = Result<FramedServiceImpl<St, C::Service, T, Io, Codec, Out>, C::InitError>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+        let connect = ready!(this.fut.poll(cx))?;
+
+        Poll::Ready(Ok(FramedServiceImpl {
+            connect,
+            handler: this.handler.clone(),
+            _t: PhantomData,
+        }))
+    }
+}
+
+pub struct FramedServiceImpl<St, C, T, Io, Codec, Out> {
+    connect: C,
+    handler: Rc<T>,
+    _t: PhantomData<(St, Io, Codec, Out)>,
+}
+
+impl<St, C, T, Io, Codec, Out> Service for FramedServiceImpl<St, C, T, Io, Codec, Out>
+where
+    Io: AsyncRead + AsyncWrite,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec, Out>>,
+    T: ServiceFactory<
+        Config = St,
+        Request = RequestItem<Codec>,
+        Response = ResponseItem<Codec>,
+        Error = C::Error,
+        InitError = C::Error,
+    >,
+    <T::Service as Service>::Error: 'static,
+    <T::Service as Service>::Future: 'static,
+    Codec: Decoder + Encoder,
+    <Codec as Encoder>::Item: 'static,
+    <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
     type Request = Io;
     type Response = ();
     type Error = ServiceError<C::Error, Codec>;
-    type Future = FramedServiceImplResponse<St, Io, Codec, C, T>;
+    type Future = FramedServiceImplResponse<St, Io, Codec, Out, C, T>;
 
-    fn poll_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         self.connect.poll_ready(cx).map_err(|e| e.into())
     }
 
@@ -260,54 +273,55 @@ where
             inner: FramedServiceImplResponseInner::Connect(
                 self.connect.call(Connect::new(req)),
                 self.handler.clone(),
-                self.disconnect.clone(),
             ),
         }
     }
 }
 
 #[pin_project::pin_project]
-pub struct FramedServiceImplResponse<St, Io, Codec, C, T>
+pub struct FramedServiceImplResponse<St, Io, Codec, Out, C, T>
 where
-    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
-    C::Error: 'static,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec, Out>>,
     T: ServiceFactory<
         Config = St,
-        Request = RequestItem<St, Codec>,
+        Request = RequestItem<Codec>,
         Response = ResponseItem<Codec>,
         Error = C::Error,
         InitError = C::Error,
     >,
+    <T::Service as Service>::Error: 'static,
     <T::Service as Service>::Future: 'static,
     Io: AsyncRead + AsyncWrite,
     Codec: Encoder + Decoder,
     <Codec as Encoder>::Item: 'static,
     <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
     #[pin]
-    inner: FramedServiceImplResponseInner<St, Io, Codec, C, T>,
+    inner: FramedServiceImplResponseInner<St, Io, Codec, Out, C, T>,
 }
 
-impl<St, Io, Codec, C, T> Future for FramedServiceImplResponse<St, Io, Codec, C, T>
+impl<St, Io, Codec, Out, C, T> Future for FramedServiceImplResponse<St, Io, Codec, Out, C, T>
 where
-    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
-    C::Error: 'static,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec, Out>>,
     T: ServiceFactory<
         Config = St,
-        Request = RequestItem<St, Codec>,
+        Request = RequestItem<Codec>,
         Response = ResponseItem<Codec>,
         Error = C::Error,
         InitError = C::Error,
     >,
+    <T::Service as Service>::Error: 'static,
     <T::Service as Service>::Future: 'static,
     Io: AsyncRead + AsyncWrite,
     Codec: Encoder + Decoder,
     <Codec as Encoder>::Item: 'static,
     <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
     type Output = Result<(), ServiceError<C::Error, Codec>>;
 
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.as_mut().project();
 
         loop {
@@ -323,90 +337,77 @@ where
 }
 
 #[pin_project::pin_project]
-enum FramedServiceImplResponseInner<St, Io, Codec, C, T>
+enum FramedServiceImplResponseInner<St, Io, Codec, Out, C, T>
 where
-    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
-    C::Error: 'static,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec, Out>>,
     T: ServiceFactory<
         Config = St,
-        Request = RequestItem<St, Codec>,
+        Request = RequestItem<Codec>,
         Response = ResponseItem<Codec>,
         Error = C::Error,
         InitError = C::Error,
     >,
+    <T::Service as Service>::Error: 'static,
     <T::Service as Service>::Future: 'static,
     Io: AsyncRead + AsyncWrite,
     Codec: Encoder + Decoder,
     <Codec as Encoder>::Item: 'static,
     <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
-    Connect(#[pin] C::Future, Rc<T>, Option<Rc<dyn Fn(&mut St, bool)>>),
-    Handler(
-        #[pin] T::Future,
-        Option<ConnectResult<Io, St, Codec>>,
-        Option<Rc<dyn Fn(&mut St, bool)>>,
-    ),
-    Dispatcher(#[pin] FramedDispatcher<St, T::Service, Io, Codec>),
+    Connect(#[pin] C::Future, Rc<T>),
+    Handler(#[pin] T::Future, Option<Framed<Io, Codec>>, Option<Out>),
+    Dispatcher(Dispatcher<T::Service, Io, Codec, Out>),
 }
 
-impl<St, Io, Codec, C, T> FramedServiceImplResponseInner<St, Io, Codec, C, T>
+impl<St, Io, Codec, Out, C, T> FramedServiceImplResponseInner<St, Io, Codec, Out, C, T>
 where
-    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
-    C::Error: 'static,
+    C: Service<Request = Connect<Io, Codec>, Response = ConnectResult<Io, St, Codec, Out>>,
     T: ServiceFactory<
         Config = St,
-        Request = RequestItem<St, Codec>,
+        Request = RequestItem<Codec>,
         Response = ResponseItem<Codec>,
         Error = C::Error,
         InitError = C::Error,
     >,
+    <T::Service as Service>::Error: 'static,
     <T::Service as Service>::Future: 'static,
     Io: AsyncRead + AsyncWrite,
     Codec: Encoder + Decoder,
     <Codec as Encoder>::Item: 'static,
     <Codec as Encoder>::Error: std::fmt::Debug,
+    Out: Stream<Item = <Codec as Encoder>::Item> + Unpin,
 {
     #[project]
     fn poll(
         self: Pin<&mut Self>,
-        cx: &mut Context,
+        cx: &mut Context<'_>,
     ) -> Either<
-        FramedServiceImplResponseInner<St, Io, Codec, C, T>,
+        FramedServiceImplResponseInner<St, Io, Codec, Out, C, T>,
         Poll<Result<(), ServiceError<C::Error, Codec>>>,
     > {
         #[project]
         match self.project() {
-            FramedServiceImplResponseInner::Connect(fut, handler, disconnect) => {
+            FramedServiceImplResponseInner::Connect(fut, handler) => match fut.poll(cx) {
+                Poll::Ready(Ok(res)) => Either::Left(FramedServiceImplResponseInner::Handler(
+                    handler.new_service(res.state),
+                    Some(res.framed),
+                    res.out,
+                )),
+                Poll::Pending => Either::Right(Poll::Pending),
+                Poll::Ready(Err(e)) => Either::Right(Poll::Ready(Err(e.into()))),
+            },
+            FramedServiceImplResponseInner::Handler(fut, framed, out) => {
                 match fut.poll(cx) {
-                    Poll::Ready(Ok(res)) => {
-                        Either::Left(FramedServiceImplResponseInner::Handler(
-                            handler.new_service(&res.state),
-                            Some(res),
-                            disconnect.take(),
+                    Poll::Ready(Ok(handler)) => {
+                        Either::Left(FramedServiceImplResponseInner::Dispatcher(
+                            Dispatcher::new(framed.take().unwrap(), handler, out.take()),
                         ))
                     }
                     Poll::Pending => Either::Right(Poll::Pending),
                     Poll::Ready(Err(e)) => Either::Right(Poll::Ready(Err(e.into()))),
                 }
             }
-            FramedServiceImplResponseInner::Handler(fut, res, disconnect) => match fut.poll(cx)
-            {
-                Poll::Ready(Ok(handler)) => {
-                    let res = res.take().unwrap();
-                    Either::Left(FramedServiceImplResponseInner::Dispatcher(
-                        FramedDispatcher::new(
-                            res.framed,
-                            State::new(res.state),
-                            handler,
-                            res.rx,
-                            res.sink,
-                            disconnect.take(),
-                        ),
-                    ))
-                }
-                Poll::Pending => Either::Right(Poll::Pending),
-                Poll::Ready(Err(e)) => Either::Right(Poll::Ready(Err(e.into()))),
-            },
             FramedServiceImplResponseInner::Dispatcher(ref mut fut) => {
                 Either::Right(fut.poll(cx))
             }

actix-ioframe/src/sink.rs

@@ -1,44 +0,0 @@
-use std::fmt;
-
-use actix_utils::{mpsc, oneshot};
-use futures::future::{Future, FutureExt};
-
-use crate::dispatcher::FramedMessage;
-
-pub struct Sink<T>(mpsc::Sender<FramedMessage<T>>);
-
-impl<T> Clone for Sink<T> {
-    fn clone(&self) -> Self {
-        Sink(self.0.clone())
-    }
-}
-
-impl<T> Sink<T> {
-    pub(crate) fn new(tx: mpsc::Sender<FramedMessage<T>>) -> Self {
-        Sink(tx)
-    }
-
-    /// Close connection
-    pub fn close(&self) {
-        let _ = self.0.send(FramedMessage::Close);
-    }
-
-    /// Close connection
-    pub fn wait_close(&self) -> impl Future<Output = ()> {
-        let (tx, rx) = oneshot::channel();
-        let _ = self.0.send(FramedMessage::WaitClose(tx));
-
-        rx.map(|_| ())
-    }
-
-    /// Send item
-    pub fn send(&self, item: T) {
-        let _ = self.0.send(FramedMessage::Message(item));
-    }
-}
-
-impl<T> fmt::Debug for Sink<T> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("Sink").finish()
-    }
-}

actix-ioframe/src/state.rs

@@ -1,30 +0,0 @@
-use std::cell::{Ref, RefCell, RefMut};
-use std::rc::Rc;
-
-/// Connection state
-///
-/// Connection state is an arbitrary data attached to the each incoming message.
-#[derive(Debug)]
-pub struct State<T>(Rc<RefCell<T>>);
-
-impl<T> State<T> {
-    pub(crate) fn new(st: T) -> Self {
-        State(Rc::new(RefCell::new(st)))
-    }
-
-    #[inline]
-    pub fn get_ref(&self) -> Ref<T> {
-        self.0.borrow()
-    }
-
-    #[inline]
-    pub fn get_mut(&mut self) -> RefMut<T> {
-        self.0.borrow_mut()
-    }
-}
-
-impl<T> Clone for State<T> {
-    fn clone(&self) -> Self {
-        State(self.0.clone())
-    }
-}

actix-ioframe/tests/test_server.rs

@@ -1,57 +1,55 @@
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
-use std::time::Duration;
+use std::cell::Cell;
+use std::rc::Rc;
 
 use actix_codec::BytesCodec;
-use actix_server_config::Io;
-use actix_service::{apply_fn_factory, service_fn, Service};
-use actix_testing::{self as test, TestServer};
+use actix_service::{fn_factory_with_config, fn_service, IntoService, Service};
+use actix_testing::TestServer;
+use actix_utils::mpsc;
+use bytes::{Bytes, BytesMut};
 use futures::future::ok;
-use tokio_net::tcp::TcpStream;
-use tokio_timer::delay_for;
 
-use actix_ioframe::{Builder, Connect};
+use actix_ioframe::{Builder, Connect, FactoryBuilder};
 
-struct State;
+#[derive(Clone)]
+struct State(Option<mpsc::Sender<Bytes>>);
 
-#[test]
-fn test_disconnect() -> std::io::Result<()> {
-    let disconnect = Arc::new(AtomicBool::new(false));
-    let disconnect1 = disconnect.clone();
+#[actix_rt::test]
+async fn test_basic() {
+    let client_item = Rc::new(Cell::new(false));
 
     let srv = TestServer::with(move || {
-        let disconnect1 = disconnect1.clone();
-
-        apply_fn_factory(
-            Builder::new()
-                .factory(service_fn(|conn: Connect<_>| {
-                    ok(conn.codec(BytesCodec).state(State))
-                }))
-                .disconnect(move |_, _| {
-                    disconnect1.store(true, Ordering::Relaxed);
-                })
-                .finish(service_fn(|_t| ok(None))),
-            |io: Io<TcpStream>, srv| srv.call(io.into_parts().0),
-        )
+        FactoryBuilder::new(fn_service(|conn: Connect<_, _>| {
+            ok(conn.codec(BytesCodec).state(State(None)))
+        }))
+        // echo
+        .build(fn_service(|t: BytesMut| ok(Some(t.freeze()))))
     });
 
-    let mut client = Builder::new()
-        .service(|conn: Connect<_>| {
-            let conn = conn.codec(BytesCodec).state(State);
-            conn.sink().close();
-            ok(conn)
+    let item = client_item.clone();
+    let mut client = Builder::new(fn_service(move |conn: Connect<_, _>| {
+        async move {
+            let (tx, rx) = mpsc::channel();
+            let _ = tx.send(Bytes::from_static(b"Hello"));
+            Ok(conn.codec(BytesCodec).out(rx).state(State(Some(tx))))
+        }
+    }))
+    .build(fn_factory_with_config(move |mut cfg: State| {
+        let item = item.clone();
+        ok((move |t: BytesMut| {
+            assert_eq!(t.freeze(), Bytes::from_static(b"Hello"));
+            item.set(true);
+            // drop Sender, which will close connection
+            cfg.0.take();
+            ok::<_, ()>(None)
         })
-        .finish(service_fn(|_t| ok(None)));
+        .into_service())
+    }));
 
-    let conn = test::block_on(
-        actix_connect::default_connector()
-            .call(actix_connect::Connect::with(String::new(), srv.addr())),
-    )
-    .unwrap();
+    let conn = actix_connect::default_connector()
+        .call(actix_connect::Connect::with(String::new(), srv.addr()))
+        .await
+        .unwrap();
 
-    test::block_on(client.call(conn.into_parts().0)).unwrap();
-    let _ = test::block_on(delay_for(Duration::from_millis(100)));
-    assert!(disconnect.load(Ordering::Relaxed));
-
-    Ok(())
+    client.call(conn.into_parts().0).await.unwrap();
+    assert!(client_item.get());
 }

actix-macros/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "actix-macros"
+version = "0.1.1"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix runtime macros"
+repository = "https://github.com/actix/actix-net"
+documentation = "https://docs.rs/actix-macros/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+edition = "2018"
+workspace = ".."
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "^1"
+syn = { version = "^1", features = ["full"] }
+
+[dev-dependencies]
+actix-rt = { version = "1.0.0" }

actix-macros/src/lib.rs

@@ -0,0 +1,100 @@
+//! Macros for use with Tokio
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+use quote::quote;
+
+/// Marks async function to be executed by actix system.
+///
+/// ## Usage
+///
+/// ```rust
+/// #[actix_rt::main]
+/// async fn main() {
+///     println!("Hello world");
+/// }
+/// ```
+#[proc_macro_attribute]
+#[cfg(not(test))] // Work around for rust-lang/rust#62127
+pub fn main(_: TokenStream, item: TokenStream) -> TokenStream {
+    let mut input = syn::parse_macro_input!(item as syn::ItemFn);
+    let attrs = &input.attrs;
+    let vis = &input.vis;
+    let sig = &mut input.sig;
+    let body = &input.block;
+    let name = &sig.ident;
+
+    if sig.asyncness.is_none() {
+        return syn::Error::new_spanned(sig.fn_token, "only async fn is supported")
+            .to_compile_error()
+            .into();
+    }
+
+    sig.asyncness = None;
+
+    (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.
+///
+/// ## Usage
+///
+/// ```no_run
+/// #[actix_rt::test]
+/// async fn my_test() {
+///     assert!(true);
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn test(_: TokenStream, item: TokenStream) -> TokenStream {
+    let input = syn::parse_macro_input!(item as syn::ItemFn);
+
+    let ret = &input.sig.output;
+    let name = &input.sig.ident;
+    let body = &input.block;
+    let attrs = &input.attrs;
+    let mut has_test_attr = false;
+
+    for attr in attrs {
+        if attr.path.is_ident("test") {
+            has_test_attr = true;
+        }
+    }
+
+    if input.sig.asyncness.is_none() {
+        return syn::Error::new_spanned(
+            input.sig.fn_token,
+            format!("only async fn is supported, {}", input.sig.ident),
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let result = if has_test_attr {
+        quote! {
+            #(#attrs)*
+            fn #name() #ret {
+                actix_rt::System::new("test")
+                    .block_on(async { #body })
+            }
+        }
+    } else {
+        quote! {
+            #[test]
+            #(#attrs)*
+            fn #name() #ret {
+                actix_rt::System::new("test")
+                    .block_on(async { #body })
+            }
+        }
+    };
+
+    result.into()
+}

actix-rt/CHANGES.md

@@ -1,5 +1,38 @@
 # Changes
 
+## [1.0.0] - 2019-12-11
+
+* Update dependencies
+
+## [1.0.0-alpha.3] - 2019-12-07
+
+### Fixed
+
+* Fix compilation on non-unix platforms
+
+### Changed
+
+* Migrate to tokio 0.2
+
+
+## [1.0.0-alpha.2] - 2019-12-02
+
+Added
+
+* Export `main` and `test` attribute macros
+
+* Export `time` module (re-export of tokio-timer)
+
+* Export `net` module (re-export of tokio-net)
+
+
+## [1.0.0-alpha.1] - 2019-11-22
+
+### Changed
+
+* Migrate to std::future and tokio 0.2
+
+
 ## [0.2.6] - 2019-11-14
 
 ### Fixed

actix-rt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-rt"
-version = "1.0.0-alpha.1"
+version = "1.0.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix runtime"
 keywords = ["network", "framework", "async", "futures"]
@@ -9,22 +9,15 @@ repository = "https://github.com/actix/actix-net.git"
 documentation = "https://docs.rs/actix-rt/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
-workspace = ".."
 
 [lib]
 name = "actix_rt"
 path = "src/lib.rs"
 
 [dependencies]
-actix-threadpool = "0.2"
+actix-macros = "0.1.0"
+actix-threadpool = "0.3"
 futures = "0.3.1"
-
-# TODO: Replace this with dependency on tokio-runtime once it is ready
-tokio = { version = "0.2.0-alpha.6" }
-tokio-timer = "=0.3.0-alpha.6"
-tokio-executor = "=0.2.0-alpha.6"
-tokio-net = "=0.2.0-alpha.6"
-
 copyless = "0.1.4"
+tokio = { version = "0.2.6", default-features=false, features = ["rt-core", "rt-util", "io-driver", "tcp", "uds", "udp", "time", "signal", "stream"] }

actix-rt/src/arbiter.rs

@@ -9,9 +9,8 @@ use std::{fmt, thread};
 use futures::channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
 use futures::channel::oneshot::{channel, Canceled, Sender};
 use futures::{future, Future, FutureExt, Stream};
-use tokio::runtime::current_thread::spawn;
 
-use crate::builder::Builder;
+use crate::runtime::Runtime;
 use crate::system::System;
 
 use copyless::BoxHelper;
@@ -19,7 +18,7 @@ use copyless::BoxHelper;
 thread_local!(
     static ADDR: RefCell<Option<Arbiter>> = RefCell::new(None);
     static RUNNING: Cell<bool> = Cell::new(false);
-    static Q: RefCell<Vec<Box<dyn Future<Output = ()>>>> = RefCell::new(Vec::new());
+    static Q: RefCell<Vec<Pin<Box<dyn Future<Output = ()>>>>> = RefCell::new(Vec::new());
     static STORAGE: RefCell<HashMap<TypeId, Box<dyn Any>>> = RefCell::new(HashMap::new());
 );
 
@@ -32,7 +31,7 @@ pub(crate) enum ArbiterCommand {
 }
 
 impl fmt::Debug for ArbiterCommand {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             ArbiterCommand::Stop => write!(f, "ArbiterCommand::Stop"),
             ArbiterCommand::Execute(_) => write!(f, "ArbiterCommand::Execute"),
@@ -101,7 +100,7 @@ impl Arbiter {
         let handle = thread::Builder::new()
             .name(name.clone())
             .spawn(move || {
-                let mut rt = Builder::new().build_rt().expect("Can not create Runtime");
+                let mut rt = Runtime::new().expect("Can not create Runtime");
                 let arb = Arbiter::with_sender(arb_tx);
 
                 let (stop, stop_rx) = channel();
@@ -143,14 +142,16 @@ impl Arbiter {
         }
     }
 
-    pub(crate) fn run_system() {
+    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(..) {
-                // We pin the boxed future, so it can never again be moved.
-                let fut = unsafe { Pin::new_unchecked(fut) };
-                tokio_executor::current_thread::spawn(fut);
+                if let Some(rt) = rt {
+                    rt.spawn(fut);
+                } else {
+                    tokio::task::spawn_local(fut);
+                }
             }
         });
     }
@@ -169,11 +170,14 @@ impl Arbiter {
         RUNNING.with(move |cell| {
             if cell.get() {
                 // Spawn the future on running executor
-                spawn(future);
+                tokio::task::spawn_local(future);
             } 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(Box::alloc().init(future)));
+                Q.with(move |cell| {
+                    cell.borrow_mut()
+                        .push(unsafe { Pin::new_unchecked(Box::alloc().init(future)) })
+                });
             }
         });
     }
@@ -325,7 +329,7 @@ impl Future for ArbiterController {
                         return Poll::Ready(());
                     }
                     ArbiterCommand::Execute(fut) => {
-                        spawn(fut);
+                        tokio::task::spawn_local(fut);
                     }
                     ArbiterCommand::ExecuteFn(f) => {
                         f.call_box();

actix-rt/src/builder.rs

@@ -3,17 +3,12 @@ use std::io;
 
 use futures::channel::mpsc::unbounded;
 use futures::channel::oneshot::{channel, Receiver};
-use futures::future::{lazy, Future};
-use futures::{future, FutureExt};
-
-use tokio::runtime::current_thread::Handle;
-use tokio_net::driver::Reactor;
-use tokio_timer::{clock::Clock, timer::Timer};
+use futures::future::{lazy, Future, FutureExt};
+use tokio::task::LocalSet;
 
 use crate::arbiter::{Arbiter, SystemArbiter};
 use crate::runtime::Runtime;
 use crate::system::System;
-use tokio_executor::current_thread::CurrentThread;
 
 /// Builder struct for a actix runtime.
 ///
@@ -24,9 +19,6 @@ pub struct Builder {
     /// Name of the System. Defaults to "actix" if unset.
     name: Cow<'static, str>,
 
-    /// The clock to use
-    clock: Clock,
-
     /// Whether the Arbiter will stop the whole System on uncaught panic. Defaults to false.
     stop_on_panic: bool,
 }
@@ -35,7 +27,6 @@ impl Builder {
     pub(crate) fn new() -> Self {
         Builder {
             name: Cow::Borrowed("actix"),
-            clock: Clock::new(),
             stop_on_panic: false,
         }
     }
@@ -46,14 +37,6 @@ impl Builder {
         self
     }
 
-    /// Set the Clock instance that will be used by this System.
-    ///
-    /// Defaults to the system clock.
-    pub fn clock(mut self, clock: Clock) -> Self {
-        self.clock = clock;
-        self
-    }
-
     /// Sets the option 'stop_on_panic' which controls whether the System is stopped when an
     /// uncaught panic is thrown from a worker thread.
     ///
@@ -73,8 +56,8 @@ impl Builder {
     /// Create new System that can run asynchronously.
     ///
     /// This method panics if it cannot start the system arbiter
-    pub(crate) fn build_async(self, executor: Handle) -> AsyncSystemRunner {
-        self.create_async_runtime(executor)
+    pub(crate) fn build_async(self, local: &LocalSet) -> AsyncSystemRunner {
+        self.create_async_runtime(local)
     }
 
     /// This function will start tokio runtime and will finish once the
@@ -87,7 +70,7 @@ impl Builder {
         self.create_runtime(f).run()
     }
 
-    fn create_async_runtime(self, executor: Handle) -> AsyncSystemRunner {
+    fn create_async_runtime(self, local: &LocalSet) -> AsyncSystemRunner {
         let (stop_tx, stop) = channel();
         let (sys_sender, sys_receiver) = unbounded();
 
@@ -97,7 +80,7 @@ impl Builder {
         let arb = SystemArbiter::new(stop_tx, sys_receiver);
 
         // start the system arbiter
-        executor.spawn(arb).expect("could not start system arbiter");
+        let _ = local.spawn_local(arb);
 
         AsyncSystemRunner { stop, system }
     }
@@ -114,40 +97,14 @@ impl Builder {
         // system arbiter
         let arb = SystemArbiter::new(stop_tx, sys_receiver);
 
-        let mut rt = self.build_rt().unwrap();
+        let mut rt = Runtime::new().unwrap();
         rt.spawn(arb);
 
         // init system arbiter and run configuration method
-        let _ = rt.block_on(lazy(move |_| {
-            f();
-            Ok::<_, ()>(())
-        }));
+        rt.block_on(lazy(move |_| f()));
 
         SystemRunner { rt, stop, system }
     }
-
-    pub(crate) fn build_rt(&self) -> io::Result<Runtime> {
-        // We need a reactor to receive events about IO objects from kernel
-        let reactor = Reactor::new()?;
-        let reactor_handle = reactor.handle();
-
-        // Place a timer wheel on top of the reactor. If there are no timeouts to fire, it'll let the
-        // reactor pick up some new external events.
-        let timer = Timer::new_with_now(reactor, self.clock.clone());
-        let timer_handle = timer.handle();
-
-        // And now put a single-threaded executor on top of the timer. When there are no futures ready
-        // to do something, it'll let the timer or the reactor to generate some new stimuli for the
-        // futures to continue in their life.
-        let executor = CurrentThread::new_with_park(timer);
-
-        Ok(Runtime::new2(
-            reactor_handle,
-            timer_handle,
-            self.clock.clone(),
-            executor,
-        ))
-    }
 }
 
 #[derive(Debug)]
@@ -163,8 +120,8 @@ impl AsyncSystemRunner {
         let AsyncSystemRunner { stop, .. } = self;
 
         // run loop
-        future::lazy(|_| {
-            Arbiter::run_system();
+        lazy(|_| {
+            Arbiter::run_system(None);
             async {
                 let res = match stop.await {
                     Ok(code) => {
@@ -203,10 +160,7 @@ impl SystemRunner {
         let SystemRunner { mut rt, stop, .. } = self;
 
         // run loop
-        let _ = rt.block_on(async {
-            Arbiter::run_system();
-            Ok::<_, ()>(())
-        });
+        Arbiter::run_system(Some(&rt));
         let result = match rt.block_on(stop) {
             Ok(code) => {
                 if code != 0 {
@@ -227,17 +181,11 @@ impl SystemRunner {
     /// Execute a future and wait for result.
     pub fn block_on<F, O>(&mut self, fut: F) -> O
     where
-        F: Future<Output = O>,
+        F: Future<Output = O> + 'static,
     {
-        self.rt.block_on(async {
-            Arbiter::run_system();
-        });
-
+        Arbiter::run_system(Some(&self.rt));
         let res = self.rt.block_on(fut);
-        self.rt.block_on(async {
-            Arbiter::stop_system();
-        });
-
+        Arbiter::stop_system();
         res
     }
 }

actix-rt/src/lib.rs

@@ -1,4 +1,9 @@
 //! A runtime implementation that runs everything on the current thread.
+#![deny(rust_2018_idioms, warnings)]
+#![allow(clippy::type_complexity)]
+
+#[cfg(not(test))] // Work around for rust-lang/rust#62127
+pub use actix_macros::{main, test};
 
 mod arbiter;
 mod builder;
@@ -28,3 +33,34 @@ where
 
     Arbiter::spawn(f);
 }
+
+/// Asynchronous signal handling
+pub mod signal {
+    #[cfg(unix)]
+    pub mod unix {
+        pub use tokio::signal::unix::*;
+    }
+    pub use tokio::signal::ctrl_c;
+}
+
+/// TCP/UDP/Unix bindings
+pub mod net {
+    pub use tokio::net::UdpSocket;
+    pub use tokio::net::{TcpListener, TcpStream};
+
+    #[cfg(unix)]
+    mod unix {
+        pub use tokio::net::{UnixDatagram, UnixListener, UnixStream};
+    }
+
+    #[cfg(unix)]
+    pub use self::unix::*;
+}
+
+/// 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::{timeout, Timeout};
+}

actix-rt/src/mod.rs

@@ -1,92 +0,0 @@
-//! A runtime implementation that runs everything on the current thread.
-//!
-//! [`current_thread::Runtime`][rt] is similar to the primary
-//! [`Runtime`][concurrent-rt] except that it runs all components on the current
-//! thread instead of using a thread pool. This means that it is able to spawn
-//! futures that do not implement `Send`.
-//!
-//! Same as the default [`Runtime`][concurrent-rt], the
-//! [`current_thread::Runtime`][rt] includes:
-//!
-//! * A [reactor] to drive I/O resources.
-//! * An [executor] to execute tasks that use these I/O resources.
-//! * A [timer] for scheduling work to run after a set period of time.
-//!
-//! Note that [`current_thread::Runtime`][rt] does not implement `Send` itself
-//! and cannot be safely moved to other threads.
-//!
-//! # Spawning from other threads
-//!
-//! While [`current_thread::Runtime`][rt] does not implement `Send` and cannot
-//! safely be moved to other threads, it provides a `Handle` that can be sent
-//! to other threads and allows to spawn new tasks from there.
-//!
-//! For example:
-//!
-//! ```
-//! # extern crate tokio;
-//! # extern crate futures;
-//! use tokio::runtime::current_thread::Runtime;
-//! use tokio::prelude::*;
-//! use std::thread;
-//!
-//! # fn main() {
-//! let mut runtime = Runtime::new().unwrap();
-//! let handle = runtime.handle();
-//!
-//! thread::spawn(move || {
-//!     handle.spawn(future::ok(()));
-//! }).join().unwrap();
-//!
-//! # /*
-//! runtime.run().unwrap();
-//! # */
-//! # }
-//! ```
-//!
-//! # Examples
-//!
-//! Creating a new `Runtime` and running a future `f` until its completion and
-//! returning its result.
-//!
-//! ```
-//! use tokio::runtime::current_thread::Runtime;
-//! use tokio::prelude::*;
-//!
-//! let mut runtime = Runtime::new().unwrap();
-//!
-//! // Use the runtime...
-//! // runtime.block_on(f); // where f is a future
-//! ```
-//!
-//! [rt]: struct.Runtime.html
-//! [concurrent-rt]: ../struct.Runtime.html
-//! [chan]: https://docs.rs/futures/0.1/futures/sync/mpsc/fn.channel.html
-//! [reactor]: ../../reactor/struct.Reactor.html
-//! [executor]: https://tokio.rs/docs/getting-started/runtime-model/#executors
-//! [timer]: ../../timer/index.html
-
-mod builder;
-mod runtime;
-
-pub use self::builder::Builder;
-pub use self::runtime::{Runtime, Handle};
-pub use tokio_current_thread::spawn;
-pub use tokio_current_thread::TaskExecutor;
-
-use futures::Future;
-
-/// Run the provided future to completion using a runtime running on the current thread.
-///
-/// This first creates a new [`Runtime`], and calls [`Runtime::block_on`] with the provided future,
-/// which blocks the current thread until the provided future completes. It then calls
-/// [`Runtime::run`] to wait for any other spawned futures to resolve.
-pub fn block_on_all<F>(future: F) -> Result<F::Item, F::Error>
-where
-    F: Future,
-{
-    let mut r = Runtime::new().expect("failed to start runtime on current thread");
-    let v = r.block_on(future)?;
-    r.run().expect("failed to resolve remaining futures");
-    Ok(v)
-}

actix-rt/src/runtime.rs

@@ -1,73 +1,36 @@
-use std::error::Error;
-use std::{fmt, io};
-
-use futures::Future;
-use tokio_executor::current_thread::{self, CurrentThread};
-use tokio_net::driver::{Handle as ReactorHandle, Reactor};
-use tokio_timer::{
-    clock::Clock,
-    timer::{self, Timer},
-};
-
-use crate::builder::Builder;
+use std::future::Future;
+use std::io;
+use tokio::{runtime, task::LocalSet};
 
 /// Single-threaded runtime provides a way to start reactor
-/// and executor on the current thread.
+/// and runtime on the current thread.
 ///
 /// See [module level][mod] documentation for more details.
 ///
 /// [mod]: index.html
 #[derive(Debug)]
 pub struct Runtime {
-    reactor_handle: ReactorHandle,
-    timer_handle: timer::Handle,
-    clock: Clock,
-    executor: CurrentThread<Timer<Reactor>>,
-}
-
-/// Error returned by the `run` function.
-#[derive(Debug)]
-pub struct RunError {
-    inner: current_thread::RunError,
-}
-
-impl fmt::Display for RunError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "{}", self.inner)
-    }
-}
-
-impl Error for RunError {
-    fn description(&self) -> &str {
-        self.inner.description()
-    }
-    fn cause(&self) -> Option<&dyn Error> {
-        self.inner.source()
-    }
+    local: LocalSet,
+    rt: runtime::Runtime,
 }
 
 impl Runtime {
     #[allow(clippy::new_ret_no_self)]
     /// Returns a new runtime initialized with default configuration values.
     pub fn new() -> io::Result<Runtime> {
-        Builder::new().build_rt()
+        let rt = runtime::Builder::new()
+            .enable_io()
+            .enable_time()
+            .basic_scheduler()
+            .build()?;
+
+        Ok(Runtime {
+            rt,
+            local: LocalSet::new(),
+        })
     }
 
-    pub(super) fn new2(
-        reactor_handle: ReactorHandle,
-        timer_handle: timer::Handle,
-        clock: Clock,
-        executor: CurrentThread<Timer<Reactor>>,
-    ) -> Runtime {
-        Runtime {
-            reactor_handle,
-            timer_handle,
-            clock,
-            executor,
-        }
-    }
-
-    /// Spawn a future onto the single-threaded Tokio runtime.
+    /// Spawn a future onto the single-threaded runtime.
     ///
     /// See [module level][mod] documentation for more details.
     ///
@@ -75,7 +38,7 @@ impl Runtime {
     ///
     /// # Examples
     ///
-    /// ```rust
+    /// ```rust,ignore
     /// # use futures::{future, Future, Stream};
     /// use actix_rt::Runtime;
     ///
@@ -95,11 +58,11 @@ impl Runtime {
     ///
     /// This function panics if the spawn fails. Failure occurs if the executor
     /// is currently at capacity and is unable to spawn a new future.
-    pub fn spawn<F>(&mut self, future: F) -> &mut Self
+    pub fn spawn<F>(&self, future: F) -> &Self
     where
         F: Future<Output = ()> + 'static,
     {
-        self.executor.spawn(future);
+        self.local.spawn_local(future);
         self
     }
 
@@ -121,41 +84,9 @@ impl Runtime {
     /// complete execution by calling `block_on` or `run`.
     pub fn block_on<F>(&mut self, f: F) -> F::Output
     where
-        F: Future,
+        F: Future + 'static,
     {
-        self.enter(|executor| {
-            // Run the provided future
-            executor.block_on(f)
-        })
-    }
-
-    /// Run the executor to completion, blocking the thread until **all**
-    /// spawned futures have completed.
-    pub fn run(&mut self) -> Result<(), RunError> {
-        self.enter(|executor| executor.run())
-            .map_err(|e| RunError { inner: e })
-    }
-
-    fn enter<F, R>(&mut self, f: F) -> R
-    where
-        F: FnOnce(&mut CurrentThread<Timer<Reactor>>) -> R,
-    {
-        let Runtime {
-            ref reactor_handle,
-            ref timer_handle,
-            ref clock,
-            ref mut executor,
-            ..
-        } = *self;
-
-        // WARN: We do not enter the executor here, since in tokio 0.2 the executor is entered
-        // automatically inside its `block_on` and `run` methods
-        tokio_executor::with_default(&mut current_thread::TaskExecutor::current(), || {
-            tokio_timer::clock::with_default(clock, || {
-                let _reactor_guard = tokio_net::driver::set_default(reactor_handle);
-                let _timer_guard = tokio_timer::set_default(timer_handle);
-                f(executor)
-            })
-        })
+        let res = self.local.block_on(&mut self.rt, f);
+        res
     }
 }

actix-rt/src/system.rs

@@ -1,10 +1,10 @@
 use std::cell::RefCell;
+use std::future::Future;
 use std::io;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 use futures::channel::mpsc::UnboundedSender;
-use futures::Future;
-use tokio::runtime::current_thread::Handle;
+use tokio::task::LocalSet;
 
 use crate::arbiter::{Arbiter, SystemCommand};
 use crate::builder::{Builder, SystemRunner};
@@ -58,16 +58,16 @@ impl System {
     }
 
     #[allow(clippy::new_ret_no_self)]
-    /// Create new system using provided CurrentThread Handle.
+    /// Create new system using provided tokio Handle.
     ///
     /// This method panics if it can not spawn system arbiter
-    pub fn run_in_executor<T: Into<String>>(
+    pub fn run_in_tokio<T: Into<String>>(
         name: T,
-        executor: Handle,
-    ) -> impl Future<Output = Result<(), io::Error>> + Send {
+        local: &LocalSet,
+    ) -> impl Future<Output = io::Result<()>> {
         Self::builder()
             .name(name)
-            .build_async(executor)
+            .build_async(local)
             .run_nonblocking()
     }
 

actix-server-config/Cargo.toml

@@ -1,29 +0,0 @@
-[package]
-name = "actix-server-config"
-version = "0.3.0-alpha.1"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix server config utils"
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-net.git"
-license = "MIT/Apache-2.0"
-edition = "2018"
-workspace = ".."
-
-[lib]
-name = "actix_server_config"
-path = "src/lib.rs"
-
-[package.metadata.docs.rs]
-features = ["openssl", "rustls"]
-
-[features]
-default = []
-openssl = ["tokio-openssl"]
-rustls = ["tokio-rustls"]
-
-[dependencies]
-tokio-io = "=0.2.0-alpha.6"
-tokio-net = { version = "=0.2.0-alpha.6", features = ["tcp", "uds"] }
-tokio-openssl = { version = "0.4.0-alpha.6", optional = true }
-#tokio-rustls = { version = "0.12.0-alpha.8", optional = true }
-tokio-rustls = { git = "https://github.com/quininer/tokio-rustls.git", branch = "tokio-0.2", optional = true }

actix-server-config/changes.md

@@ -1,21 +0,0 @@
-# Changes
-
-## [0.2.0] - 2019-10-03
-
-### Changed
-
-* Update `rustls` to 0.16
-* Minimum required Rust version upped to 1.37.0
-
-## [0.1.2] - 2019-07-18
-
-### Added
-
-* Add unix domnain sockets support
-
-
-## [0.1.1] - 2019-04-16
-
-### Added
-
-* `IoStream` trait and impls for TcpStream, SslStream and TlsStream

actix-server-config/src/lib.rs

@@ -1,249 +0,0 @@
-//! Actix server config utils.
-
-use std::cell::Cell;
-use std::net::SocketAddr;
-use std::rc::Rc;
-use std::{fmt, io, net, ops, time};
-
-use tokio_io::{AsyncRead, AsyncWrite};
-use tokio_net::tcp::TcpStream;
-
-#[derive(Debug, Clone)]
-pub struct ServerConfig {
-    addr: SocketAddr,
-    secure: Rc<Cell<bool>>,
-}
-
-impl ServerConfig {
-    #[inline]
-    pub fn new(addr: SocketAddr) -> Self {
-        ServerConfig {
-            addr,
-            secure: Rc::new(Cell::new(false)),
-        }
-    }
-
-    /// Returns the address of the local half of this TCP server socket
-    #[inline]
-    pub fn local_addr(&self) -> SocketAddr {
-        self.addr
-    }
-
-    /// Returns true if connection is secure (tls enabled)
-    #[inline]
-    pub fn secure(&self) -> bool {
-        self.secure.as_ref().get()
-    }
-
-    /// Set secure flag
-    #[inline]
-    pub fn set_secure(&self) {
-        self.secure.as_ref().set(true)
-    }
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum Protocol {
-    Unknown,
-    Http10,
-    Http11,
-    Http2,
-    Proto1,
-    Proto2,
-    Proto3,
-    Proto4,
-    Proto5,
-    Proto6,
-}
-
-pub struct Io<T, P = ()> {
-    io: T,
-    proto: Protocol,
-    params: P,
-}
-
-impl<T: Unpin> Unpin for Io<T> {}
-
-impl<T> Io<T, ()> {
-    pub fn new(io: T) -> Self {
-        Self {
-            io,
-            proto: Protocol::Unknown,
-            params: (),
-        }
-    }
-}
-
-impl<T, P> Io<T, P> {
-    /// Reconstruct from a parts.
-    pub fn from_parts(io: T, params: P, proto: Protocol) -> Self {
-        Self { io, params, proto }
-    }
-
-    /// Deconstruct into a parts.
-    pub fn into_parts(self) -> (T, P, Protocol) {
-        (self.io, self.params, self.proto)
-    }
-
-    /// Returns a shared reference to the underlying stream.
-    pub fn get_ref(&self) -> &T {
-        &self.io
-    }
-
-    /// Returns a mutable reference to the underlying stream.
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.io
-    }
-
-    /// Get selected protocol
-    pub fn protocol(&self) -> Protocol {
-        self.proto
-    }
-
-    /// Return new Io object with new parameter.
-    pub fn set<U>(self, params: U) -> Io<T, U> {
-        Io {
-            params,
-            io: self.io,
-            proto: self.proto,
-        }
-    }
-
-    /// Maps an Io<_, P> to Io<_, U> by applying a function to a contained value.
-    pub fn map<U, F>(self, op: F) -> Io<T, U>
-    where
-        F: FnOnce(P) -> U,
-    {
-        Io {
-            io: self.io,
-            proto: self.proto,
-            params: op(self.params),
-        }
-    }
-}
-
-impl<T, P> ops::Deref for Io<T, P> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        &self.io
-    }
-}
-
-impl<T, P> ops::DerefMut for Io<T, P> {
-    fn deref_mut(&mut self) -> &mut T {
-        &mut self.io
-    }
-}
-
-impl<T: fmt::Debug, P> fmt::Debug for Io<T, P> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Io {{{:?}}}", self.io)
-    }
-}
-
-/// Low-level io stream operations
-pub trait IoStream: AsyncRead + AsyncWrite + Unpin {
-    /// Returns the socket address of the remote peer of this TCP connection.
-    fn peer_addr(&self) -> Option<SocketAddr> {
-        None
-    }
-
-    /// Sets the value of the TCP_NODELAY option on this socket.
-    fn set_nodelay(&mut self, nodelay: bool) -> io::Result<()>;
-
-    fn set_linger(&mut self, dur: Option<time::Duration>) -> io::Result<()>;
-
-    fn set_keepalive(&mut self, dur: Option<time::Duration>) -> io::Result<()>;
-}
-
-impl IoStream for TcpStream {
-    #[inline]
-    fn peer_addr(&self) -> Option<net::SocketAddr> {
-        TcpStream::peer_addr(self).ok()
-    }
-
-    #[inline]
-    fn set_nodelay(&mut self, nodelay: bool) -> io::Result<()> {
-        TcpStream::set_nodelay(self, nodelay)
-    }
-
-    #[inline]
-    fn set_linger(&mut self, dur: Option<time::Duration>) -> io::Result<()> {
-        TcpStream::set_linger(self, dur)
-    }
-
-    #[inline]
-    fn set_keepalive(&mut self, dur: Option<time::Duration>) -> io::Result<()> {
-        TcpStream::set_keepalive(self, dur)
-    }
-}
-
-#[cfg(feature = "openssl")]
-impl<T: IoStream + Unpin> IoStream for tokio_openssl::SslStream<T> {
-    #[inline]
-    fn peer_addr(&self) -> Option<net::SocketAddr> {
-        self.get_ref().peer_addr()
-    }
-
-    #[inline]
-    fn set_nodelay(&mut self, nodelay: bool) -> io::Result<()> {
-        self.get_mut().set_nodelay(nodelay)
-    }
-
-    #[inline]
-    fn set_linger(&mut self, dur: Option<time::Duration>) -> io::Result<()> {
-        self.get_mut().set_linger(dur)
-    }
-
-    #[inline]
-    fn set_keepalive(&mut self, dur: Option<time::Duration>) -> io::Result<()> {
-        self.get_mut().set_keepalive(dur)
-    }
-}
-
-#[cfg(feature = "rustls")]
-impl<T: IoStream + Unpin> IoStream for tokio_rustls::server::TlsStream<T> {
-    #[inline]
-    fn peer_addr(&self) -> Option<net::SocketAddr> {
-        self.get_ref().0.peer_addr()
-    }
-
-    #[inline]
-    fn set_nodelay(&mut self, nodelay: bool) -> io::Result<()> {
-        self.get_mut().0.set_nodelay(nodelay)
-    }
-
-    #[inline]
-    fn set_linger(&mut self, dur: Option<time::Duration>) -> io::Result<()> {
-        self.get_mut().0.set_linger(dur)
-    }
-
-    #[inline]
-    fn set_keepalive(&mut self, dur: Option<time::Duration>) -> io::Result<()> {
-        self.get_mut().0.set_keepalive(dur)
-    }
-}
-
-#[cfg(unix)]
-impl IoStream for tokio_net::uds::UnixStream {
-    #[inline]
-    fn peer_addr(&self) -> Option<net::SocketAddr> {
-        None
-    }
-
-    #[inline]
-    fn set_nodelay(&mut self, _: bool) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn set_linger(&mut self, _: Option<time::Duration>) -> io::Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    fn set_keepalive(&mut self, _: Option<time::Duration>) -> io::Result<()> {
-        Ok(())
-    }
-}

actix-server/CHANGES.md

@@ -1,5 +1,53 @@
 # Changes
 
+## [1.0.1] - 2019-12-29
+
+### Changed
+
+* Rename `.start()` method to `.run()`
+
+## [1.0.0] - 2019-12-11
+
+### Changed
+
+* Use actix-net releases
+
+
+## [1.0.0-alpha.4] - 2019-12-08
+
+### Changed
+
+* Use actix-service 1.0.0-alpha.4
+
+## [1.0.0-alpha.3] - 2019-12-07
+
+### Changed
+
+* Migrate to tokio 0.2
+
+### Fixed
+
+* Fix compilation on non-unix platforms
+
+* Better handling server configuration
+
+
+## [1.0.0-alpha.2] - 2019-12-02
+
+### Changed
+
+* Simplify server service (remove actix-server-config)
+
+* Allow to wait on `Server` until server stops
+
+
+## [0.8.0-alpha.1] - 2019-11-22
+
+### Changed
+
+* Migrate to `std::future`
+
+
 ## [0.7.0] - 2019-10-04
 
 ### Changed

actix-server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-server"
-version = "0.8.0-alpha.1"
+version = "1.0.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix server - General purpose tcp server"
 keywords = ["network", "framework", "async", "futures"]
@@ -13,55 +13,30 @@ exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
 workspace = ".."
 
-[package.metadata.docs.rs]
-features = ["nativetls", "openssl", "rustls", "uds"]
-
 [lib]
 name = "actix_server"
 path = "src/lib.rs"
 
 [features]
 default = []
-nativetls = ["native-tls", "tokio-tls"]
-openssl = ["open-ssl", "tokio-openssl", "actix-server-config/openssl"]
-#rustls = ["rust-tls", "tokio-rustls", "webpki", "webpki-roots", "actix-server-config/rustls"]
 
 [dependencies]
-actix-rt = "1.0.0-alpha.1"
-actix-service = "1.0.0-alpha.1"
-actix-server-config = "0.3.0-alpha.1"
+actix-service = "1.0.1"
+actix-rt = "1.0.0"
+actix-codec = "0.2.0"
+actix-utils = "1.0.4"
 
 log = "0.4"
-num_cpus = "1.0"
+num_cpus = "1.11"
 mio = "0.6.19"
 net2 = "0.2"
 futures = "0.3.1"
 slab = "0.4"
 
-tokio = "0.2.0-alpha.6"
-tokio-io = "0.2.0-alpha.6"
-tokio-net = { version = "0.2.0-alpha.6", features = ["signal", "tcp", "uds"] }
-tokio-timer = "0.3.0-alpha.6"
-
 # unix domain sockets
 mio-uds = { version = "0.6.7" }
 
-# nativetls
-native-tls = { version = "0.2", optional = true }
-tokio-tls = { version = "0.3.0-alpha.6", optional = true }
-
-# openssl
-open-ssl = { version = "0.10", package = "openssl", optional = true }
-tokio-openssl = { version = "0.4.0-alpha.6", optional = true }
-
-# rustls
-rust-tls = { version = "0.16.0", package = "rustls", optional = true }
-# tokio-rustls = { version = "0.12.0-alpha.2", optional = true }
-tokio-rustls = { git = "https://github.com/quininer/tokio-rustls.git", branch = "tokio-0.2", optional = true }
-webpki = { version = "0.21", optional = true }
-webpki-roots = { version = "0.17", optional = true }
-
 [dev-dependencies]
-bytes = "0.4"
-actix-codec = "0.2.0-alpha.1"
-env_logger = "0.6"
+bytes = "0.5"
+env_logger = "0.7"
+actix-testing = "1.0.0"

actix-server/src/accept.rs

@@ -1,12 +1,11 @@
 use std::sync::mpsc as sync_mpsc;
-use std::time::{Duration, Instant};
+use std::time::Duration;
 use std::{io, thread};
 
+use actix_rt::time::{delay_until, Instant};
 use actix_rt::System;
-use futures::FutureExt;
 use log::{error, info};
 use slab::Slab;
-use tokio_timer::delay;
 
 use crate::server::Server;
 use crate::socket::{SocketAddr, SocketListener, StdListener};
@@ -440,13 +439,10 @@ impl Accept {
                         info.timeout = Some(Instant::now() + Duration::from_millis(500));
 
                         let r = self.timer.1.clone();
-                        System::current().arbiter().send(
-                            async move {
-                                delay(Instant::now() + Duration::from_millis(510)).await;
-                                let _ = r.set_readiness(mio::Ready::readable());
-                            }
-                                .boxed(),
-                        );
+                        System::current().arbiter().send(Box::pin(async move {
+                            delay_until(Instant::now() + Duration::from_millis(510)).await;
+                            let _ = r.set_readiness(mio::Ready::readable());
+                        }));
                         return;
                     }
                 }

actix-server/src/builder.rs

@@ -1,27 +1,28 @@
 use std::pin::Pin;
 use std::task::{Context, Poll};
-use std::time::{Duration, Instant};
+use std::time::Duration;
 use std::{io, mem, net};
 
-use actix_rt::{spawn, Arbiter, System};
+use actix_rt::net::TcpStream;
+use actix_rt::time::{delay_until, Instant};
+use actix_rt::{spawn, System};
 use futures::channel::mpsc::{unbounded, UnboundedReceiver};
+use futures::channel::oneshot;
 use futures::future::ready;
 use futures::stream::FuturesUnordered;
 use futures::{ready, Future, FutureExt, Stream, StreamExt};
 use log::{error, info};
 use net2::TcpBuilder;
 use num_cpus;
-use tokio_net::tcp::TcpStream;
-use tokio_timer::delay;
 
 use crate::accept::{AcceptLoop, AcceptNotify, Command};
 use crate::config::{ConfiguredService, ServiceConfig};
 use crate::server::{Server, ServerCommand};
 use crate::service::{InternalServiceFactory, ServiceFactory, StreamNewService};
-// use crate::signals::{Signal, Signals};
+use crate::signals::{Signal, Signals};
 use crate::socket::StdListener;
 use crate::worker::{self, Worker, WorkerAvailability, WorkerClient};
-use crate::{ssl, Token};
+use crate::Token;
 
 /// Server builder
 pub struct ServerBuilder {
@@ -30,13 +31,14 @@ pub struct ServerBuilder {
     backlog: i32,
     workers: Vec<(usize, WorkerClient)>,
     services: Vec<Box<dyn InternalServiceFactory>>,
-    sockets: Vec<(Token, StdListener)>,
+    sockets: Vec<(Token, String, StdListener)>,
     accept: AcceptLoop,
     exit: bool,
     shutdown_timeout: Duration,
     no_signals: bool,
     cmd: UnboundedReceiver<ServerCommand>,
     server: Server,
+    notify: Vec<oneshot::Sender<()>>,
 }
 
 impl Default for ServerBuilder {
@@ -63,6 +65,7 @@ impl ServerBuilder {
             shutdown_timeout: Duration::from_secs(30),
             no_signals: false,
             cmd: rx,
+            notify: Vec::new(),
             server,
         }
     }
@@ -102,17 +105,6 @@ impl ServerBuilder {
         self
     }
 
-    /// Sets the maximum per-worker concurrent connection establish process.
-    ///
-    /// All listeners will stop accepting connections when this limit is reached. It
-    /// can be used to limit the global SSL CPU usage.
-    ///
-    /// By default max connections is set to a 256.
-    pub fn maxconnrate(self, num: usize) -> Self {
-        ssl::max_concurrent_ssl_connect(num);
-        self
-    }
-
     /// Stop actix system.
     pub fn system_exit(mut self) -> Self {
         self.exit = true;
@@ -154,8 +146,8 @@ impl ServerBuilder {
             let mut srv = ConfiguredService::new(apply);
             for (name, lst) in cfg.services {
                 let token = self.token.next();
-                srv.stream(token, name, lst.local_addr()?);
-                self.sockets.push((token, StdListener::Tcp(lst)));
+                srv.stream(token, name.clone(), lst.local_addr()?);
+                self.sockets.push((token, name, StdListener::Tcp(lst)));
             }
             self.services.push(Box::new(srv));
         }
@@ -180,7 +172,8 @@ impl ServerBuilder {
                 factory.clone(),
                 lst.local_addr()?,
             ));
-            self.sockets.push((token, StdListener::Tcp(lst)));
+            self.sockets
+                .push((token, name.as_ref().to_string(), StdListener::Tcp(lst)));
         }
         Ok(self)
     }
@@ -189,7 +182,7 @@ impl ServerBuilder {
     /// Add new unix domain service to the server.
     pub fn bind_uds<F, U, N>(self, name: N, addr: U, factory: F) -> io::Result<Self>
     where
-        F: ServiceFactory<tokio_net::uds::UnixStream>,
+        F: ServiceFactory<actix_rt::net::UnixStream>,
         N: AsRef<str>,
         U: AsRef<std::path::Path>,
     {
@@ -219,7 +212,7 @@ impl ServerBuilder {
         factory: F,
     ) -> io::Result<Self>
     where
-        F: ServiceFactory<tokio_net::uds::UnixStream>,
+        F: ServiceFactory<actix_rt::net::UnixStream>,
     {
         use std::net::{IpAddr, Ipv4Addr, SocketAddr};
         let token = self.token.next();
@@ -230,7 +223,8 @@ impl ServerBuilder {
             factory.clone(),
             addr,
         ));
-        self.sockets.push((token, StdListener::Uds(lst)));
+        self.sockets
+            .push((token, name.as_ref().to_string(), StdListener::Uds(lst)));
         Ok(self)
     }
 
@@ -251,36 +245,18 @@ impl ServerBuilder {
             factory,
             lst.local_addr()?,
         ));
-        self.sockets.push((token, StdListener::Tcp(lst)));
+        self.sockets
+            .push((token, name.as_ref().to_string(), StdListener::Tcp(lst)));
         Ok(self)
     }
 
-    /// Spawn new thread and start listening for incoming connections.
-    ///
-    /// This method spawns new thread and starts new actix system. Other than
-    /// that it is similar to `start()` method. This method blocks.
-    ///
-    /// This methods panics if no socket addresses get bound.
-    ///
-    /// ```rust,ignore
-    /// use actix_web::*;
-    ///
-    /// fn main() -> std::io::Result<()> {
-    ///     Server::new().
-    ///         .service(
-    ///            HttpServer::new(|| App::new().service(web::service("/").to(|| HttpResponse::Ok())))
-    ///                .bind("127.0.0.1:0")
-    ///         .run()
-    /// }
-    /// ```
-    pub fn run(self) -> io::Result<()> {
-        let sys = System::new("http-server");
-        self.start();
-        sys.run()
+    #[doc(hidden)]
+    pub fn start(self) -> Server {
+        self.run()
     }
 
     /// Starts processing incoming connections and return server controller.
-    pub fn start(mut self) -> Server {
+    pub fn run(mut self) -> Server {
         if self.sockets.is_empty() {
             panic!("Server should have at least one bound socket");
         } else {
@@ -296,14 +272,19 @@ impl ServerBuilder {
 
             // start accept thread
             for sock in &self.sockets {
-                info!("Starting server on {}", sock.1);
+                info!("Starting \"{}\" service on {}", sock.1, sock.2);
             }
-            self.accept
-                .start(mem::replace(&mut self.sockets, Vec::new()), workers);
+            self.accept.start(
+                mem::replace(&mut self.sockets, Vec::new())
+                    .into_iter()
+                    .map(|t| (t.0, t.2))
+                    .collect(),
+                workers,
+            );
 
             // handle signals
             if !self.no_signals {
-                // Signals::start(self.server.clone());
+                Signals::start(self.server.clone()).unwrap();
             }
 
             // start http server actor
@@ -314,22 +295,11 @@ impl ServerBuilder {
     }
 
     fn start_worker(&self, idx: usize, notify: AcceptNotify) -> WorkerClient {
-        let (tx1, rx1) = unbounded();
-        let (tx2, rx2) = unbounded();
-        let timeout = self.shutdown_timeout;
         let avail = WorkerAvailability::new(notify);
-        let worker = WorkerClient::new(idx, tx1, tx2, avail.clone());
         let services: Vec<Box<dyn InternalServiceFactory>> =
             self.services.iter().map(|v| v.clone_factory()).collect();
 
-        Arbiter::new().send(
-            async move {
-                Worker::start(rx1, rx2, services, avail, timeout);
-            }
-                .boxed(),
-        );
-
-        worker
+        Worker::start(idx, services, avail, self.shutdown_timeout)
     }
 
     fn handle_cmd(&mut self, item: ServerCommand) {
@@ -342,37 +312,40 @@ impl ServerBuilder {
                 self.accept.send(Command::Resume);
                 let _ = tx.send(());
             }
-            // ServerCommand::Signal(sig) => {
-            // Signals support
-            // Handle `SIGINT`, `SIGTERM`, `SIGQUIT` signals and stop actix system
-            // match sig {
-            //     Signal::Int => {
-            //         info!("SIGINT received, exiting");
-            //         self.exit = true;
-            //         self.handle_cmd(ServerCommand::Stop {
-            //             graceful: false,
-            //             completion: None,
-            //         })
-            //     }
-            //     Signal::Term => {
-            //         info!("SIGTERM received, stopping");
-            //         self.exit = true;
-            //         self.handle_cmd(ServerCommand::Stop {
-            //             graceful: true,
-            //             completion: None,
-            //         })
-            //     }
-            //     Signal::Quit => {
-            //         info!("SIGQUIT received, exiting");
-            //         self.exit = true;
-            //         self.handle_cmd(ServerCommand::Stop {
-            //             graceful: false,
-            //             completion: None,
-            //         })
-            //     }
-            //     _ => (),
-            // }
-            // }
+            ServerCommand::Signal(sig) => {
+                // Signals support
+                // Handle `SIGINT`, `SIGTERM`, `SIGQUIT` signals and stop actix system
+                match sig {
+                    Signal::Int => {
+                        info!("SIGINT received, exiting");
+                        self.exit = true;
+                        self.handle_cmd(ServerCommand::Stop {
+                            graceful: false,
+                            completion: None,
+                        })
+                    }
+                    Signal::Term => {
+                        info!("SIGTERM received, stopping");
+                        self.exit = true;
+                        self.handle_cmd(ServerCommand::Stop {
+                            graceful: true,
+                            completion: None,
+                        })
+                    }
+                    Signal::Quit => {
+                        info!("SIGQUIT received, exiting");
+                        self.exit = true;
+                        self.handle_cmd(ServerCommand::Stop {
+                            graceful: false,
+                            completion: None,
+                        })
+                    }
+                    _ => (),
+                }
+            }
+            ServerCommand::Notify(tx) => {
+                self.notify.push(tx);
+            }
             ServerCommand::Stop {
                 graceful,
                 completion,
@@ -381,6 +354,7 @@ impl ServerBuilder {
 
                 // stop accept thread
                 self.accept.send(Command::Stop);
+                let notify = std::mem::replace(&mut self.notify, Vec::new());
 
                 // stop workers
                 if !self.workers.is_empty() && graceful {
@@ -394,14 +368,19 @@ impl ServerBuilder {
                                 if let Some(tx) = completion {
                                     let _ = tx.send(());
                                 }
+                                for tx in notify {
+                                    let _ = tx.send(());
+                                }
                                 if exit {
                                     spawn(
                                         async {
-                                            delay(Instant::now() + Duration::from_millis(300))
-                                                .await;
+                                            delay_until(
+                                                Instant::now() + Duration::from_millis(300),
+                                            )
+                                            .await;
                                             System::current().stop();
                                         }
-                                            .boxed(),
+                                        .boxed(),
                                     );
                                 }
                                 ready(())
@@ -411,15 +390,20 @@ impl ServerBuilder {
                     // we need to stop system if server was spawned
                     if self.exit {
                         spawn(
-                            delay(Instant::now() + Duration::from_millis(300)).then(|_| {
-                                System::current().stop();
-                                ready(())
-                            }),
+                            delay_until(Instant::now() + Duration::from_millis(300)).then(
+                                |_| {
+                                    System::current().stop();
+                                    ready(())
+                                },
+                            ),
                         );
                     }
                     if let Some(tx) = completion {
                         let _ = tx.send(());
                     }
+                    for tx in notify {
+                        let _ = tx.send(());
+                    }
                 }
             }
             ServerCommand::WorkerFaulted(idx) => {

actix-server/src/config.rs

@@ -1,18 +1,17 @@
 use std::collections::HashMap;
 use std::{fmt, io, net};
 
-use actix_server_config::{Io, ServerConfig};
+use actix_rt::net::TcpStream;
 use actix_service as actix;
-use futures::future::{Future, FutureExt, LocalBoxFuture};
+use actix_utils::counter::CounterGuard;
+use futures::future::{ok, Future, FutureExt, LocalBoxFuture};
 use log::error;
-use tokio_net::tcp::TcpStream;
 
 use super::builder::bind_addr;
 use super::service::{
     BoxedServerService, InternalServiceFactory, ServerMessage, StreamService,
 };
 use super::Token;
-use crate::counter::CounterGuard;
 
 pub struct ServiceConfig {
     pub(crate) services: Vec<(String, net::TcpListener)>,
@@ -76,7 +75,8 @@ impl ServiceConfig {
 pub(super) struct ConfiguredService {
     rt: Box<dyn ServiceRuntimeConfiguration>,
     names: HashMap<Token, (String, net::SocketAddr)>,
-    services: HashMap<String, Token>,
+    topics: HashMap<String, Token>,
+    services: Vec<Token>,
 }
 
 impl ConfiguredService {
@@ -84,13 +84,15 @@ impl ConfiguredService {
         ConfiguredService {
             rt,
             names: HashMap::new(),
-            services: HashMap::new(),
+            topics: HashMap::new(),
+            services: Vec::new(),
         }
     }
 
     pub(super) fn stream(&mut self, token: Token, name: String, addr: net::SocketAddr) {
         self.names.insert(token, (name.clone(), addr));
-        self.services.insert(name, token);
+        self.topics.insert(name.clone(), token);
+        self.services.push(token);
     }
 }
 
@@ -103,43 +105,55 @@ impl InternalServiceFactory for ConfiguredService {
         Box::new(Self {
             rt: self.rt.clone(),
             names: self.names.clone(),
+            topics: self.topics.clone(),
             services: self.services.clone(),
         })
     }
 
     fn create(&self) -> LocalBoxFuture<'static, Result<Vec<(Token, BoxedServerService)>, ()>> {
         // configure services
-        let mut rt = ServiceRuntime::new(self.services.clone());
+        let mut rt = ServiceRuntime::new(self.topics.clone());
         self.rt.configure(&mut rt);
         rt.validate();
-
-        let names = self.names.clone();
+        let mut names = self.names.clone();
+        let tokens = self.services.clone();
 
         // construct services
         async move {
-            let services = rt.services;
+            let mut services = rt.services;
             // TODO: Proper error handling here
             for f in rt.onstart.into_iter() {
                 f.await;
             }
             let mut res = vec![];
-            for (token, ns) in services.into_iter() {
-                let config = ServerConfig::new(names[&token].1);
-
-                let newserv = ns.new_service(&config);
-                match newserv.await {
-                    Ok(serv) => {
-                        res.push((token, serv));
-                    }
-                    Err(e) => {
-                        error!("Can not construct service {:?}", e);
-                        return Err(e);
+            for token in tokens {
+                if let Some(srv) = services.remove(&token) {
+                    let newserv = srv.new_service(());
+                    match newserv.await {
+                        Ok(serv) => {
+                            res.push((token, serv));
+                        }
+                        Err(_) => {
+                            error!("Can not construct service");
+                            return Err(());
+                        }
                     }
+                } else {
+                    let name = names.remove(&token).unwrap().0;
+                    res.push((
+                        token,
+                        Box::new(StreamService::new(actix::fn_service(
+                            move |_: TcpStream| {
+                                error!("Service {:?} is not configured", name);
+                                ok::<_, ()>(())
+                            },
+                        ))),
+                    ));
                 };
             }
             return Ok(res);
         }
-            .boxed_local()
+        .boxed_local()
     }
 }
 
@@ -196,7 +210,7 @@ impl ServiceRuntime {
     pub fn service<T, F>(&mut self, name: &str, service: F)
     where
         F: actix::IntoServiceFactory<T>,
-        T: actix::ServiceFactory<Config = ServerConfig, Request = Io<TcpStream>> + 'static,
+        T: actix::ServiceFactory<Config = (), Request = TcpStream> + 'static,
         T::Future: 'static,
         T::Service: 'static,
         T::InitError: fmt::Debug,
@@ -229,7 +243,7 @@ type BoxedNewService = Box<
         Response = (),
         Error = (),
         InitError = (),
-        Config = ServerConfig,
+        Config = (),
         Service = BoxedServerService,
         Future = LocalBoxFuture<'static, Result<BoxedServerService, ()>>,
     >,
@@ -241,7 +255,7 @@ struct ServiceFactory<T> {
 
 impl<T> actix::ServiceFactory for ServiceFactory<T>
 where
-    T: actix::ServiceFactory<Config = ServerConfig, Request = Io<TcpStream>>,
+    T: actix::ServiceFactory<Config = (), Request = TcpStream>,
     T::Future: 'static,
     T::Service: 'static,
     T::Error: 'static,
@@ -251,12 +265,12 @@ where
     type Response = ();
     type Error = ();
     type InitError = ();
-    type Config = ServerConfig;
+    type Config = ();
     type Service = BoxedServerService;
     type Future = LocalBoxFuture<'static, Result<BoxedServerService, ()>>;
 
-    fn new_service(&self, cfg: &ServerConfig) -> Self::Future {
-        let fut = self.inner.new_service(cfg);
+    fn new_service(&self, _: ()) -> Self::Future {
+        let fut = self.inner.new_service(());
         async move {
             return match fut.await {
                 Ok(s) => Ok(Box::new(StreamService::new(s)) as BoxedServerService),
@@ -266,6 +280,6 @@ where
                 }
             };
         }
-            .boxed_local()
+        .boxed_local()
     }
 }

actix-server/src/counter.rs

@@ -1,81 +0,0 @@
-use std::cell::Cell;
-use std::rc::Rc;
-
-use futures::task::AtomicWaker;
-use std::task;
-
-#[derive(Clone)]
-/// Simple counter with ability to notify task on reaching specific number
-///
-/// Counter could be cloned, total ncount is shared across all clones.
-pub struct Counter(Rc<CounterInner>);
-
-#[derive(Debug)]
-struct CounterInner {
-    count: Cell<usize>,
-    capacity: usize,
-    task: AtomicWaker,
-}
-
-impl Counter {
-    /// Create `Counter` instance and set max value.
-    pub fn new(capacity: usize) -> Self {
-        Counter(Rc::new(CounterInner {
-            capacity,
-            count: Cell::new(0),
-            task: AtomicWaker::new(),
-        }))
-    }
-
-    pub fn get(&self) -> CounterGuard {
-        CounterGuard::new(self.0.clone())
-    }
-
-    /// Check if counter is not at capacity
-    pub fn available(&self, cx: &mut task::Context) -> bool {
-        self.0.available(cx)
-    }
-
-    /// Get total number of acquired counts
-    pub fn total(&self) -> usize {
-        self.0.count.get()
-    }
-}
-
-#[derive(Debug)]
-pub struct CounterGuard(Rc<CounterInner>);
-
-impl CounterGuard {
-    fn new(inner: Rc<CounterInner>) -> Self {
-        inner.inc();
-        CounterGuard(inner)
-    }
-}
-
-impl Drop for CounterGuard {
-    fn drop(&mut self) {
-        self.0.dec();
-    }
-}
-
-impl CounterInner {
-    fn inc(&self) {
-        self.count.set(self.count.get() + 1);
-    }
-
-    fn dec(&self) {
-        let num = self.count.get();
-        self.count.set(num - 1);
-        if num == self.capacity {
-            self.task.wake();
-        }
-    }
-
-    fn available(&self, cx: &mut task::Context) -> bool {
-        let avail = self.count.get() < self.capacity;
-        if !avail {
-            self.task.register(cx.waker());
-        }
-        avail
-    }
-}

actix-server/src/lib.rs

@@ -1,18 +1,16 @@
 //! General purpose tcp server
+#![deny(rust_2018_idioms, warnings)]
+#![allow(clippy::type_complexity)]
 
 mod accept;
 mod builder;
 mod config;
-mod counter;
 mod server;
 mod service;
-// mod signals;
+mod signals;
 mod socket;
-pub mod ssl;
 mod worker;
 
-pub use actix_server_config::{Io, IoStream, Protocol, ServerConfig};
-
 pub use self::builder::ServerBuilder;
 pub use self::config::{ServiceConfig, ServiceRuntime};
 pub use self::server::Server;
@@ -27,7 +25,7 @@ pub(crate) struct Token(usize);
 
 impl Token {
     pub(crate) fn next(&mut self) -> Token {
-        let token = Token(self.0 + 1);
+        let token = Token(self.0);
         self.0 += 1;
         token
     }

actix-server/src/server.rs

@@ -1,29 +1,39 @@
+use std::future::Future;
+use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
 use futures::channel::mpsc::UnboundedSender;
 use futures::channel::oneshot;
-use futures::{Future, TryFutureExt};
+use futures::FutureExt;
 
 use crate::builder::ServerBuilder;
-// use crate::signals::Signal;
+use crate::signals::Signal;
 
 #[derive(Debug)]
 pub(crate) enum ServerCommand {
     WorkerFaulted(usize),
     Pause(oneshot::Sender<()>),
     Resume(oneshot::Sender<()>),
-    // Signal(Signal),
+    Signal(Signal),
     /// Whether to try and shut down gracefully
     Stop {
         graceful: bool,
         completion: Option<oneshot::Sender<()>>,
     },
+    /// Notify of server stop
+    Notify(oneshot::Sender<()>),
 }
 
-#[derive(Debug, Clone)]
-pub struct Server(UnboundedSender<ServerCommand>);
+#[derive(Debug)]
+pub struct Server(
+    UnboundedSender<ServerCommand>,
+    Option<oneshot::Receiver<()>>,
+);
 
 impl Server {
     pub(crate) fn new(tx: UnboundedSender<ServerCommand>) -> Self {
-        Server(tx)
+        Server(tx, None)
     }
 
     /// Start server building process
@@ -31,9 +41,9 @@ impl Server {
         ServerBuilder::default()
     }
 
-    // pub(crate) fn signal(&self, sig: Signal) {
-    //     let _ = self.0.unbounded_send(ServerCommand::Signal(sig));
-    // }
+    pub(crate) fn signal(&self, sig: Signal) {
+        let _ = self.0.unbounded_send(ServerCommand::Signal(sig));
+    }
 
     pub(crate) fn worker_faulted(&self, idx: usize) {
         let _ = self.0.unbounded_send(ServerCommand::WorkerFaulted(idx));
@@ -43,28 +53,56 @@ impl Server {
     ///
     /// If socket contains some pending connection, they might be dropped.
     /// All opened connection remains active.
-    pub fn pause(&self) -> impl Future<Output = Result<(), ()>> {
+    pub fn pause(&self) -> impl Future<Output = ()> {
         let (tx, rx) = oneshot::channel();
         let _ = self.0.unbounded_send(ServerCommand::Pause(tx));
-        rx.map_err(|_| ())
+        rx.map(|_| ())
     }
 
     /// Resume accepting incoming connections
-    pub fn resume(&self) -> impl Future<Output = Result<(), ()>> {
+    pub fn resume(&self) -> impl Future<Output = ()> {
         let (tx, rx) = oneshot::channel();
         let _ = self.0.unbounded_send(ServerCommand::Resume(tx));
-        rx.map_err(|_| ())
+        rx.map(|_| ())
     }
 
     /// Stop incoming connection processing, stop all workers and exit.
     ///
     /// If server starts with `spawn()` method, then spawned thread get terminated.
-    pub fn stop(&self, graceful: bool) -> impl Future<Output = Result<(), ()>> {
+    pub fn stop(&self, graceful: bool) -> impl Future<Output = ()> {
         let (tx, rx) = oneshot::channel();
         let _ = self.0.unbounded_send(ServerCommand::Stop {
             graceful,
             completion: Some(tx),
         });
-        rx.map_err(|_| ())
+        rx.map(|_| ())
+    }
+}
+
+impl Clone for Server {
+    fn clone(&self) -> Self {
+        Self(self.0.clone(), None)
+    }
+}
+
+impl Future for Server {
+    type Output = io::Result<()>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.get_mut();
+
+        if this.1.is_none() {
+            let (tx, rx) = oneshot::channel();
+            if this.0.unbounded_send(ServerCommand::Notify(tx)).is_err() {
+                return Poll::Ready(Ok(()));
+            }
+            this.1 = Some(rx);
+        }
+
+        match Pin::new(this.1.as_mut().unwrap()).poll(cx) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(Ok(_)) => Poll::Ready(Ok(())),
+            Poll::Ready(Err(_)) => Poll::Ready(Ok(())),
+        }
     }
 }

actix-server/src/service.rs

@@ -4,14 +4,13 @@ use std::task::{Context, Poll};
 use std::time::Duration;
 
 use actix_rt::spawn;
-use actix_server_config::{Io, ServerConfig};
 use actix_service::{self as actix, Service, ServiceFactory as ActixServiceFactory};
+use actix_utils::counter::CounterGuard;
 use futures::future::{err, ok, LocalBoxFuture, Ready};
 use futures::{FutureExt, TryFutureExt};
 use log::error;
 
 use super::Token;
-use crate::counter::CounterGuard;
 use crate::socket::{FromStream, StdStream};
 
 /// Server message
@@ -25,7 +24,7 @@ pub(crate) enum ServerMessage {
 }
 
 pub trait ServiceFactory<Stream: FromStream>: Send + Clone + 'static {
-    type Factory: actix::ServiceFactory<Config = ServerConfig, Request = Io<Stream>>;
+    type Factory: actix::ServiceFactory<Config = (), Request = Stream>;
 
     fn create(&self) -> Self::Factory;
 }
@@ -59,7 +58,7 @@ impl<T> StreamService<T> {
 
 impl<T, I> Service for StreamService<T>
 where
-    T: Service<Request = Io<I>>,
+    T: Service<Request = I>,
     T::Future: 'static,
     T::Error: 'static,
     I: FromStream,
@@ -81,14 +80,11 @@ where
                 });
 
                 if let Ok(stream) = stream {
-                    let f = self.service.call(Io::new(stream));
-                    spawn(
-                        async move {
-                            let _ = f.await;
-                            drop(guard);
-                        }
-                            .boxed_local(),
-                    );
+                    let f = self.service.call(stream);
+                    spawn(async move {
+                        let _ = f.await;
+                        drop(guard);
+                    });
                     ok(())
                 } else {
                     err(())
@@ -149,11 +145,9 @@ where
 
     fn create(&self) -> LocalBoxFuture<'static, Result<Vec<(Token, BoxedServerService)>, ()>> {
         let token = self.token;
-        let config = ServerConfig::new(self.addr);
-
         self.inner
             .create()
-            .new_service(&config)
+            .new_service(())
             .map_err(|_| ())
             .map_ok(move |inner| {
                 let service: BoxedServerService = Box::new(StreamService::new(inner));
@@ -180,7 +174,7 @@ impl InternalServiceFactory for Box<dyn InternalServiceFactory> {
 impl<F, T, I> ServiceFactory<I> for F
 where
     F: Fn() -> T + Send + Clone + 'static,
-    T: actix::ServiceFactory<Config = ServerConfig, Request = Io<I>>,
+    T: actix::ServiceFactory<Config = (), Request = I>,
     I: FromStream,
 {
     type Factory = T;

actix-server/src/signals.rs

@@ -3,15 +3,12 @@ use std::io;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use actix_rt::spawn;
-use futures::future::LocalBoxFuture;
-use futures::stream::{futures_unordered, FuturesUnordered, LocalBoxStream};
-use futures::{FutureExt, Stream, StreamExt, TryFutureExt, TryStream, TryStreamExt};
-use tokio_net::signal::unix::signal;
+use futures::future::lazy;
 
 use crate::server::Server;
 
 /// Different types of process signals
+#[allow(dead_code)]
 #[derive(PartialEq, Clone, Copy, Debug)]
 pub(crate) enum Signal {
     /// SIGHUP
@@ -27,126 +24,80 @@ pub(crate) enum Signal {
 pub(crate) struct Signals {
     srv: Server,
     #[cfg(not(unix))]
-    stream: SigStream,
+    stream: Pin<Box<dyn Future<Output = io::Result<()>>>>,
     #[cfg(unix)]
-    streams: Vec<SigStream>,
+    streams: Vec<(Signal, actix_rt::signal::unix::Signal)>,
 }
 
-type SigStream = LocalBoxStream<'static, Result<Signal, io::Error>>;
-
 impl Signals {
-    pub(crate) fn start(srv: Server) {
-        let fut = {
+    pub(crate) fn start(srv: Server) -> io::Result<()> {
+        actix_rt::spawn(lazy(|_| {
             #[cfg(not(unix))]
             {
-                tokio_net::signal::ctrl_c()
-                    .map_err(|_| ())
-                    .and_then(move |stream| Signals {
-                        srv,
-                        stream: Box::new(stream.map(|_| Signal::Int)),
-                    })
+                actix_rt::spawn(Signals {
+                    srv,
+                    stream: Box::pin(actix_rt::signal::ctrl_c()),
+                });
             }
-
             #[cfg(unix)]
             {
-                use tokio_net::signal::unix;
+                use actix_rt::signal::unix;
 
-                let mut sigs: Vec<_> = Vec::new();
+                let mut streams = Vec::new();
 
-                let mut SIG_MAP = [
-                    (
-                        tokio_net::signal::unix::SignalKind::interrupt(),
-                        Signal::Int,
-                    ),
-                    (tokio_net::signal::unix::SignalKind::hangup(), Signal::Hup),
-                    (
-                        tokio_net::signal::unix::SignalKind::terminate(),
-                        Signal::Term,
-                    ),
-                    (tokio_net::signal::unix::SignalKind::quit(), Signal::Quit),
+                let sig_map = [
+                    (unix::SignalKind::interrupt(), Signal::Int),
+                    (unix::SignalKind::hangup(), Signal::Hup),
+                    (unix::SignalKind::terminate(), Signal::Term),
+                    (unix::SignalKind::quit(), Signal::Quit),
                 ];
 
-                for (kind, sig) in SIG_MAP.into_iter() {
-                    let sig = sig.clone();
-                    let fut = signal(*kind).unwrap();
-                    sigs.push(fut.map(move |_| Ok(sig)).boxed_local());
+                for (kind, sig) in sig_map.iter() {
+                    match unix::signal(*kind) {
+                        Ok(stream) => streams.push((*sig, stream)),
+                        Err(e) => log::error!(
+                            "Can not initialize stream handler for {:?} err: {}",
+                            sig,
+                            e
+                        ),
+                    }
                 }
-                /* TODO: Finish rewriting this
-                sigs.push(
-                    tokio_net::signal::unix::signal(tokio_net::signal::si).unwrap()
-                        .map(|stream| {
-                            let s: SigStream = Box::new(stream.map(|_| Signal::Int));
-                            s
-                        }).boxed()
-                );
-                sigs.push(
 
-                    tokio_net::signal::unix::signal(tokio_net::signal::unix::SignalKind::hangup()).unwrap()
-                        .map(|stream: unix::Signal| {
-                            let s: SigStream = Box::new(stream.map(|_| Signal::Hup));
-                            s
-                        }).boxed()
-                );
-                sigs.push(
-                    tokio_net::signal::unix::signal(
-                        tokio_net::signal::unix::SignalKind::terminate()
-                    ).unwrap()
-                        .map(|stream| {
-                            let s: SigStream = Box::new(stream.map(|_| Signal::Term));
-                            s
-                        }).boxed(),
-                );
-                sigs.push(
-                    tokio_net::signal::unix::signal(
-                        tokio_net::signal::unix::SignalKind::quit()
-                    ).unwrap()
-                        .map(|stream| {
-                            let s: SigStream = Box::new(stream.map(|_| Signal::Quit));
-                            s
-                        }).boxed()
-                );
-                */
-
-                Signals { srv, streams: sigs }
+                actix_rt::spawn(Signals { srv, streams })
             }
-        };
-        spawn(async {});
+        }));
+
+        Ok(())
     }
 }
 
 impl Future for Signals {
     type Output = ();
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        unimplemented!()
-    }
-
-    /*
-    type Item = ();
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         #[cfg(not(unix))]
-        loop {
-            match self.stream.poll() {
-                Ok(Async::Ready(None)) | Err(_) => return Ok(Async::Ready(())),
-                Ok(Async::Ready(Some(sig))) => self.srv.signal(sig),
-                Ok(Async::NotReady) => return Ok(Async::NotReady),
+        match Pin::new(&mut self.stream).poll(cx) {
+            Poll::Ready(_) => {
+                self.srv.signal(Signal::Int);
+                Poll::Ready(())
             }
+            Poll::Pending => return Poll::Pending,
         }
         #[cfg(unix)]
         {
-            for s in &mut self.streams {
+            for idx in 0..self.streams.len() {
                 loop {
-                    match s.poll() {
-                        Ok(Async::Ready(None)) | Err(_) => return Ok(Async::Ready(())),
-                        Ok(Async::NotReady) => break,
-                        Ok(Async::Ready(Some(sig))) => self.srv.signal(sig),
+                    match self.streams[idx].1.poll_recv(cx) {
+                        Poll::Ready(None) => return Poll::Ready(()),
+                        Poll::Pending => break,
+                        Poll::Ready(Some(_)) => {
+                            let sig = self.streams[idx].0;
+                            self.srv.signal(sig);
+                        }
                     }
                 }
             }
-            Ok(Async::NotReady)
+            Poll::Pending
         }
     }
-    */
 }

actix-server/src/socket.rs

@@ -1,8 +1,7 @@
 use std::{fmt, io, net};
 
-use tokio_io::{AsyncRead, AsyncWrite};
-use tokio_net::driver::Handle;
-use tokio_net::tcp::TcpStream;
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_rt::net::TcpStream;
 
 pub(crate) enum StdListener {
     Tcp(net::TcpListener),
@@ -151,7 +150,7 @@ pub trait FromStream: AsyncRead + AsyncWrite + Sized {
 impl FromStream for TcpStream {
     fn from_stdstream(sock: StdStream) -> io::Result<Self> {
         match sock {
-            StdStream::Tcp(stream) => TcpStream::from_std(stream, &Handle::default()),
+            StdStream::Tcp(stream) => TcpStream::from_std(stream),
             #[cfg(all(unix))]
             StdStream::Uds(_) => {
                 panic!("Should not happen, bug in server impl");
@@ -161,13 +160,11 @@ impl FromStream for TcpStream {
 }
 
 #[cfg(all(unix))]
-impl FromStream for tokio_net::uds::UnixStream {
+impl FromStream for actix_rt::net::UnixStream {
     fn from_stdstream(sock: StdStream) -> io::Result<Self> {
         match sock {
             StdStream::Tcp(_) => panic!("Should not happen, bug in server impl"),
-            StdStream::Uds(stream) => {
-                tokio_net::uds::UnixStream::from_std(stream, &Handle::default())
-            }
+            StdStream::Uds(stream) => actix_rt::net::UnixStream::from_std(stream),
         }
     }
 }

actix-server/src/ssl/openssl.rs

@@ -1,138 +0,0 @@
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-use actix_service::{Service, ServiceFactory};
-use futures::future::{ok, FutureExt, LocalBoxFuture, Ready};
-use open_ssl::ssl::SslAcceptor;
-use tokio_io::{AsyncRead, AsyncWrite};
-use tokio_openssl::{HandshakeError, SslStream};
-
-use crate::counter::{Counter, CounterGuard};
-use crate::ssl::MAX_CONN_COUNTER;
-use crate::{Io, Protocol, ServerConfig};
-
-/// Support `SSL` connections via openssl package
-///
-/// `ssl` feature enables `OpensslAcceptor` type
-pub struct OpensslAcceptor<T: AsyncRead + AsyncWrite, P = ()> {
-    acceptor: SslAcceptor,
-    io: PhantomData<(T, P)>,
-}
-
-impl<T: AsyncRead + AsyncWrite, P> OpensslAcceptor<T, P> {
-    /// Create default `OpensslAcceptor`
-    pub fn new(acceptor: SslAcceptor) -> Self {
-        OpensslAcceptor {
-            acceptor,
-            io: PhantomData,
-        }
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite, P> Clone for OpensslAcceptor<T, P> {
-    fn clone(&self) -> Self {
-        Self {
-            acceptor: self.acceptor.clone(),
-            io: PhantomData,
-        }
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite + Unpin + 'static, P> ServiceFactory for OpensslAcceptor<T, P> {
-    type Request = Io<T, P>;
-    type Response = Io<SslStream<T>, P>;
-    type Error = HandshakeError<T>;
-    type Config = ServerConfig;
-    type Service = OpensslAcceptorService<T, P>;
-    type InitError = ();
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, cfg: &ServerConfig) -> Self::Future {
-        cfg.set_secure();
-
-        MAX_CONN_COUNTER.with(|conns| {
-            ok(OpensslAcceptorService {
-                acceptor: self.acceptor.clone(),
-                conns: conns.clone(),
-                io: PhantomData,
-            })
-        })
-    }
-}
-
-pub struct OpensslAcceptorService<T, P> {
-    acceptor: SslAcceptor,
-    conns: Counter,
-    io: PhantomData<(T, P)>,
-}
-
-impl<T: AsyncRead + AsyncWrite + Unpin + 'static, P> Service for OpensslAcceptorService<T, P> {
-    type Request = Io<T, P>;
-    type Response = Io<SslStream<T>, P>;
-    type Error = HandshakeError<T>;
-    type Future = OpensslAcceptorServiceFut<T, P>;
-
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        if self.conns.available(ctx) {
-            Poll::Ready(Ok(()))
-        } else {
-            Poll::Pending
-        }
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        let (io, params, _) = req.into_parts();
-        let acc = self.acceptor.clone();
-        OpensslAcceptorServiceFut {
-            _guard: self.conns.get(),
-            fut: async move {
-                let acc = acc;
-                tokio_openssl::accept(&acc, io).await
-            }
-                .boxed_local(),
-            params: Some(params),
-        }
-    }
-}
-
-pub struct OpensslAcceptorServiceFut<T, P>
-where
-    T: AsyncRead + AsyncWrite,
-{
-    fut: LocalBoxFuture<'static, Result<SslStream<T>, HandshakeError<T>>>,
-    params: Option<P>,
-    _guard: CounterGuard,
-}
-
-impl<T: AsyncRead + AsyncWrite + Unpin, P> Unpin for OpensslAcceptorServiceFut<T, P> {}
-
-impl<T: AsyncRead + AsyncWrite + Unpin, P> Future for OpensslAcceptorServiceFut<T, P> {
-    type Output = Result<Io<SslStream<T>, P>, HandshakeError<T>>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.get_mut();
-
-        let io = futures::ready!(Pin::new(&mut this.fut).poll(cx))?;
-        let proto = if let Some(protos) = io.ssl().selected_alpn_protocol() {
-            const H2: &[u8] = b"\x02h2";
-            const HTTP10: &[u8] = b"\x08http/1.0";
-            const HTTP11: &[u8] = b"\x08http/1.1";
-
-            if protos.windows(3).any(|window| window == H2) {
-                Protocol::Http2
-            } else if protos.windows(9).any(|window| window == HTTP11) {
-                Protocol::Http11
-            } else if protos.windows(9).any(|window| window == HTTP10) {
-                Protocol::Http10
-            } else {
-                Protocol::Unknown
-            }
-        } else {
-            Protocol::Unknown
-        };
-
-        Poll::Ready(Ok(Io::from_parts(io, this.params.take().unwrap(), proto)))
-    }
-}

actix-server/src/ssl/rustls.rs

@@ -1,124 +0,0 @@
-use std::future::Future;
-use std::io;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::sync::Arc;
-use std::task::{Context, Poll};
-
-use actix_service::{Service, ServiceFactory};
-use futures::future::{ok, Ready};
-use rust_tls::ServerConfig;
-use tokio_io::{AsyncRead, AsyncWrite};
-use tokio_rustls::{server::TlsStream, Accept, TlsAcceptor};
-
-use crate::counter::{Counter, CounterGuard};
-use crate::ssl::MAX_CONN_COUNTER;
-use crate::{Io, Protocol, ServerConfig as SrvConfig};
-
-/// Support `SSL` connections via rustls package
-///
-/// `rust-tls` feature enables `RustlsAcceptor` type
-pub struct RustlsAcceptor<T, P = ()> {
-    config: Arc<ServerConfig>,
-    io: PhantomData<(T, P)>,
-}
-
-impl<T: AsyncRead + AsyncWrite, P> RustlsAcceptor<T, P> {
-    /// Create `RustlsAcceptor` new service
-    pub fn new(config: ServerConfig) -> Self {
-        RustlsAcceptor {
-            config: Arc::new(config),
-            io: PhantomData,
-        }
-    }
-}
-
-impl<T, P> Clone for RustlsAcceptor<T, P> {
-    fn clone(&self) -> Self {
-        Self {
-            config: self.config.clone(),
-            io: PhantomData,
-        }
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite + Unpin, P> ServiceFactory for RustlsAcceptor<T, P> {
-    type Request = Io<T, P>;
-    type Response = Io<TlsStream<T>, P>;
-    type Error = io::Error;
-
-    type Config = SrvConfig;
-    type Service = RustlsAcceptorService<T, P>;
-    type InitError = ();
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
-
-    fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
-        cfg.set_secure();
-
-        MAX_CONN_COUNTER.with(|conns| {
-            ok(RustlsAcceptorService {
-                acceptor: self.config.clone().into(),
-                conns: conns.clone(),
-                io: PhantomData,
-            })
-        })
-    }
-}
-
-pub struct RustlsAcceptorService<T, P> {
-    acceptor: TlsAcceptor,
-    io: PhantomData<(T, P)>,
-    conns: Counter,
-}
-
-impl<T: AsyncRead + AsyncWrite + Unpin, P> Service for RustlsAcceptorService<T, P> {
-    type Request = Io<T, P>;
-    type Response = Io<TlsStream<T>, P>;
-    type Error = io::Error;
-    type Future = RustlsAcceptorServiceFut<T, P>;
-
-    fn poll_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
-        if self.conns.available(cx) {
-            Poll::Ready(Ok(()))
-        } else {
-            Poll::Pending
-        }
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        let (io, params, _) = req.into_parts();
-        RustlsAcceptorServiceFut {
-            _guard: self.conns.get(),
-            fut: self.acceptor.accept(io),
-            params: Some(params),
-        }
-    }
-}
-
-pub struct RustlsAcceptorServiceFut<T, P>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-{
-    fut: Accept<T>,
-    params: Option<P>,
-    _guard: CounterGuard,
-}
-
-impl<T: AsyncRead + AsyncWrite + Unpin, P> Unpin for RustlsAcceptorServiceFut<T, P> {}
-
-impl<T: AsyncRead + AsyncWrite + Unpin, P> Future for RustlsAcceptorServiceFut<T, P> {
-    type Output = Result<Io<TlsStream<T>, P>, io::Error>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-        let this = self.get_mut();
-
-        let res = futures::ready!(Pin::new(&mut this.fut).poll(cx));
-        match res {
-            Ok(io) => {
-                let params = this.params.take().unwrap();
-                Poll::Ready(Ok(Io::from_parts(io, params, Protocol::Unknown)))
-            }
-            Err(e) => Poll::Ready(Err(e)),
-        }
-    }
-}

actix-server/src/worker.rs

@@ -2,18 +2,18 @@ use std::pin::Pin;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::task::{Context, Poll};
-use std::{mem, time};
+use std::time;
 
+use actix_rt::time::{delay_until, Delay, Instant};
 use actix_rt::{spawn, Arbiter};
-use futures::channel::mpsc::{UnboundedReceiver, UnboundedSender};
+use actix_utils::counter::Counter;
+use futures::channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
 use futures::channel::oneshot;
 use futures::future::{join_all, LocalBoxFuture, MapOk};
 use futures::{Future, FutureExt, Stream, TryFutureExt};
 use log::{error, info, trace};
-use tokio_timer::{delay, Delay};
 
 use crate::accept::AcceptNotify;
-use crate::counter::Counter;
 use crate::service::{BoxedServerService, InternalServiceFactory, ServerMessage};
 use crate::socket::{SocketAddr, StdStream};
 use crate::Token;
@@ -128,7 +128,7 @@ impl WorkerAvailability {
 pub(crate) struct Worker {
     rx: UnboundedReceiver<WorkerCommand>,
     rx2: UnboundedReceiver<StopCommand>,
-    services: Vec<Option<(usize, BoxedServerService)>>,
+    services: Vec<WorkerService>,
     availability: WorkerAvailability,
     conns: Counter,
     factories: Vec<Box<dyn InternalServiceFactory>>,
@@ -136,103 +136,155 @@ pub(crate) struct Worker {
     shutdown_timeout: time::Duration,
 }
 
+struct WorkerService {
+    factory: usize,
+    status: WorkerServiceStatus,
+    service: BoxedServerService,
+}
+
+impl WorkerService {
+    fn created(&mut self, service: BoxedServerService) {
+        self.service = service;
+        self.status = WorkerServiceStatus::Unavailable;
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+enum WorkerServiceStatus {
+    Available,
+    Unavailable,
+    Failed,
+    Restarting,
+    Stopping,
+    Stopped,
+}
+
 impl Worker {
     pub(crate) fn start(
-        rx: UnboundedReceiver<WorkerCommand>,
-        rx2: UnboundedReceiver<StopCommand>,
+        idx: usize,
         factories: Vec<Box<dyn InternalServiceFactory>>,
         availability: WorkerAvailability,
         shutdown_timeout: time::Duration,
-    ) {
-        availability.set(false);
-        let mut wrk = MAX_CONNS_COUNTER.with(|conns| Worker {
-            rx,
-            rx2,
-            availability,
-            factories,
-            shutdown_timeout,
-            services: Vec::new(),
-            conns: conns.clone(),
-            state: WorkerState::Unavailable(Vec::new()),
-        });
+    ) -> WorkerClient {
+        let (tx1, rx) = unbounded();
+        let (tx2, rx2) = unbounded();
+        let avail = availability.clone();
 
-        let mut fut: Vec<MapOk<LocalBoxFuture<'static, _>, _>> = Vec::new();
-        for (idx, factory) in wrk.factories.iter().enumerate() {
-            fut.push(factory.create().map_ok(move |r| {
-                r.into_iter()
-                    .map(|(t, s): (Token, _)| (idx, t, s))
-                    .collect::<Vec<_>>()
-            }));
-        }
-
-        spawn(
+        Arbiter::new().send(
             async move {
-                let res = join_all(fut).await;
-                let res: Result<Vec<_>, _> = res.into_iter().collect();
-                match res {
-                    Ok(services) => {
-                        for item in services {
-                            for (idx, token, service) in item {
-                                while token.0 >= wrk.services.len() {
-                                    wrk.services.push(None);
+                availability.set(false);
+                let mut wrk = MAX_CONNS_COUNTER.with(move |conns| Worker {
+                    rx,
+                    rx2,
+                    availability,
+                    factories,
+                    shutdown_timeout,
+                    services: Vec::new(),
+                    conns: conns.clone(),
+                    state: WorkerState::Unavailable(Vec::new()),
+                });
+
+                let mut fut: Vec<MapOk<LocalBoxFuture<'static, _>, _>> = Vec::new();
+                for (idx, factory) in wrk.factories.iter().enumerate() {
+                    fut.push(factory.create().map_ok(move |r| {
+                        r.into_iter()
+                            .map(|(t, s): (Token, _)| (idx, t, s))
+                            .collect::<Vec<_>>()
+                    }));
+                }
+
+                spawn(async move {
+                    let res = join_all(fut).await;
+                    let res: Result<Vec<_>, _> = res.into_iter().collect();
+                    match res {
+                        Ok(services) => {
+                            for item in services {
+                                for (factory, token, service) in item {
+                                    assert_eq!(token.0, wrk.services.len());
+                                    wrk.services.push(WorkerService {
+                                        factory,
+                                        service,
+                                        status: WorkerServiceStatus::Unavailable,
+                                    });
                                 }
-                                wrk.services[token.0] = Some((idx, service));
                             }
                         }
+                        Err(e) => {
+                            error!("Can not start worker: {:?}", e);
+                            Arbiter::current().stop();
+                        }
                     }
-                    Err(e) => {
-                        error!("Can not start worker: {:?}", e);
-                        Arbiter::current().stop();
-                    }
-                }
-                wrk.await
+                    wrk.await
+                });
             }
-                .boxed_local(),
+            .boxed(),
         );
+
+        WorkerClient::new(idx, tx1, tx2, avail)
     }
 
     fn shutdown(&mut self, force: bool) {
         if force {
-            self.services.iter_mut().for_each(|h| {
-                if let Some(h) = h {
-                    let _ = h.1.call((None, ServerMessage::ForceShutdown));
+            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 |h| {
-                if let Some(h) = h {
-                    let _ = h.1.call((None, ServerMessage::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(|_| ()),
+                    );
                 }
             });
         }
     }
 
-    fn check_readiness(
-        &mut self,
-        trace: bool,
-        cx: &mut Context<'_>,
-    ) -> Result<bool, (Token, usize)> {
+    fn check_readiness(&mut self, cx: &mut Context<'_>) -> Result<bool, (Token, usize)> {
         let mut ready = self.conns.available(cx);
         let mut failed = None;
-        for (token, service) in &mut self.services.iter_mut().enumerate() {
-            if let Some(service) = service {
-                match service.1.poll_ready(cx) {
+        for (idx, srv) in &mut self.services.iter_mut().enumerate() {
+            if srv.status == WorkerServiceStatus::Available
+                || srv.status == WorkerServiceStatus::Unavailable
+            {
+                match srv.service.poll_ready(cx) {
                     Poll::Ready(Ok(_)) => {
-                        if trace {
+                        if srv.status == WorkerServiceStatus::Unavailable {
                             trace!(
                                 "Service {:?} is available",
-                                self.factories[service.0].name(Token(token))
+                                self.factories[srv.factory].name(Token(idx))
                             );
+                            srv.status = WorkerServiceStatus::Available;
+                        }
+                    }
+                    Poll::Pending => {
+                        ready = false;
+
+                        if srv.status == WorkerServiceStatus::Available {
+                            trace!(
+                                "Service {:?} is unavailable",
+                                self.factories[srv.factory].name(Token(idx))
+                            );
+                            srv.status = WorkerServiceStatus::Unavailable;
                         }
                     }
-                    Poll::Pending => ready = false,
                     Poll::Ready(Err(_)) => {
                         error!(
                             "Service {:?} readiness check returned error, restarting",
-                            self.factories[service.0].name(Token(token))
+                            self.factories[srv.factory].name(Token(idx))
                         );
-                        failed = Some((Token(token), service.0));
+                        failed = Some((Token(idx), srv.factory));
+                        srv.status = WorkerServiceStatus::Failed;
                     }
                 }
             }
@@ -246,7 +298,6 @@ impl Worker {
 }
 
 enum WorkerState {
-    None,
     Available,
     Unavailable(Vec<Conn>),
     Restarting(
@@ -254,7 +305,11 @@ enum WorkerState {
         Token,
         Pin<Box<dyn Future<Output = Result<Vec<(Token, BoxedServerService)>, ()>>>>,
     ),
-    Shutdown(Delay, Delay, oneshot::Sender<bool>),
+    Shutdown(
+        Pin<Box<Delay>>,
+        Pin<Box<Delay>>,
+        Option<oneshot::Sender<bool>>,
+    ),
 }
 
 impl Future for Worker {
@@ -277,9 +332,9 @@ impl Future for Worker {
                 if num != 0 {
                     info!("Graceful worker shutdown, {} connections", num);
                     self.state = WorkerState::Shutdown(
-                        delay(time::Instant::now() + time::Duration::from_secs(1)),
-                        delay(time::Instant::now() + self.shutdown_timeout),
-                        result,
+                        Box::pin(delay_until(Instant::now() + time::Duration::from_secs(1))),
+                        Box::pin(delay_until(Instant::now() + self.shutdown_timeout)),
+                        Some(result),
                     );
                 } else {
                     let _ = result.send(true);
@@ -293,72 +348,58 @@ impl Future for Worker {
             }
         }
 
-        let state = mem::replace(&mut self.state, WorkerState::None);
-
-        match state {
-            WorkerState::Unavailable(mut conns) => {
-                match self.check_readiness(true, cx) {
+        match self.state {
+            WorkerState::Unavailable(ref mut conns) => {
+                let conn = conns.pop();
+                match self.check_readiness(cx) {
                     Ok(true) => {
-                        self.state = WorkerState::Available;
-
                         // process requests from wait queue
-                        while let Some(msg) = conns.pop() {
-                            match self.check_readiness(false, cx) {
-                                Ok(true) => {
-                                    let guard = self.conns.get();
-                                    let _ = self.services[msg.token.0]
-                                        .as_mut()
-                                        .expect("actix net bug")
-                                        .1
-                                        .call((Some(guard), ServerMessage::Connect(msg.io)));
-                                }
-                                Ok(false) => {
-                                    trace!("Worker is unavailable");
-                                    self.state = WorkerState::Unavailable(conns);
-                                    return self.poll(cx);
-                                }
-                                Err((token, idx)) => {
-                                    trace!(
-                                        "Service {:?} failed, restarting",
-                                        self.factories[idx].name(token)
-                                    );
-                                    self.state = WorkerState::Restarting(
-                                        idx,
-                                        token,
-                                        self.factories[idx].create(),
-                                    );
-                                    return self.poll(cx);
-                                }
-                            }
+                        if let Some(conn) = conn {
+                            let guard = self.conns.get();
+                            let _ = self.services[conn.token.0]
+                                .service
+                                .call((Some(guard), ServerMessage::Connect(conn.io)));
+                        } else {
+                            self.state = WorkerState::Available;
+                            self.availability.set(true);
                         }
-                        self.availability.set(true);
-                        return self.poll(cx);
+                        self.poll(cx)
                     }
                     Ok(false) => {
-                        self.state = WorkerState::Unavailable(conns);
-                        return Poll::Pending;
+                        // push connection back to queue
+                        if let Some(conn) = conn {
+                            match self.state {
+                                WorkerState::Unavailable(ref mut conns) => {
+                                    conns.push(conn);
+                                }
+                                _ => (),
+                            }
+                        }
+                        Poll::Pending
                     }
                     Err((token, idx)) => {
                         trace!(
                             "Service {:?} failed, restarting",
                             self.factories[idx].name(token)
                         );
+                        self.services[token.0].status = WorkerServiceStatus::Restarting;
                         self.state =
                             WorkerState::Restarting(idx, token, self.factories[idx].create());
-                        return self.poll(cx);
+                        self.poll(cx)
                     }
                 }
             }
-            WorkerState::Restarting(idx, token, mut fut) => {
-                match Pin::new(&mut fut).poll(cx) {
+            WorkerState::Restarting(idx, token, ref mut fut) => {
+                match Pin::new(fut).poll(cx) {
                     Poll::Ready(Ok(item)) => {
                         for (token, service) in item {
                             trace!(
                                 "Service {:?} has been restarted",
                                 self.factories[idx].name(token)
                             );
-                            self.services[token.0] = Some((idx, service));
+                            self.services[token.0].created(service);
                             self.state = WorkerState::Unavailable(Vec::new());
+                            return self.poll(cx);
                         }
                     }
                     Poll::Ready(Err(_)) => {
@@ -368,54 +409,52 @@ impl Future for Worker {
                         );
                     }
                     Poll::Pending => {
-                        self.state = WorkerState::Restarting(idx, token, fut);
                         return Poll::Pending;
                     }
                 }
-                return self.poll(cx);
+                self.poll(cx)
             }
-            WorkerState::Shutdown(mut t1, mut t2, tx) => {
+            WorkerState::Shutdown(ref mut t1, ref mut t2, ref mut tx) => {
                 let num = num_connections();
                 if num == 0 {
-                    let _ = tx.send(true);
+                    let _ = tx.take().unwrap().send(true);
                     Arbiter::current().stop();
                     return Poll::Ready(());
                 }
 
                 // check graceful timeout
-                match Pin::new(&mut t2).poll(cx) {
+                match t2.as_mut().poll(cx) {
                     Poll::Pending => (),
                     Poll::Ready(_) => {
+                        let _ = tx.take().unwrap().send(false);
                         self.shutdown(true);
-                        let _ = tx.send(false);
                         Arbiter::current().stop();
                         return Poll::Ready(());
                     }
                 }
 
                 // sleep for 1 second and then check again
-                match Pin::new(&mut t1).poll(cx) {
+                match t1.as_mut().poll(cx) {
                     Poll::Pending => (),
                     Poll::Ready(_) => {
-                        t1 = delay(time::Instant::now() + time::Duration::from_secs(1));
-                        let _ = Pin::new(&mut t1).poll(cx);
+                        *t1 = Box::pin(delay_until(
+                            Instant::now() + time::Duration::from_secs(1),
+                        ));
+                        let _ = t1.as_mut().poll(cx);
                     }
                 }
-                self.state = WorkerState::Shutdown(t1, t2, tx);
-                return Poll::Pending;
+                Poll::Pending
             }
             WorkerState::Available => {
                 loop {
                     match Pin::new(&mut self.rx).poll_next(cx) {
-                        // handle incoming tcp stream
+                        // handle incoming io stream
                         Poll::Ready(Some(WorkerCommand(msg))) => {
-                            match self.check_readiness(false, cx) {
+                            match self.check_readiness(cx) {
                                 Ok(true) => {
                                     let guard = self.conns.get();
                                     let _ = self.services[msg.token.0]
-                                        .as_mut()
-                                        .expect("actix-server bug")
-                                        .1
+                                        .service
                                         .call((Some(guard), ServerMessage::Connect(msg.io)));
                                     continue;
                                 }
@@ -430,6 +469,8 @@ impl Future for Worker {
                                         self.factories[idx].name(token)
                                     );
                                     self.availability.set(false);
+                                    self.services[token.0].status =
+                                        WorkerServiceStatus::Restarting;
                                     self.state = WorkerState::Restarting(
                                         idx,
                                         token,
@@ -447,7 +488,6 @@ impl Future for Worker {
                     }
                 }
             }
-            WorkerState::None => panic!(),
-        };
+        }
     }
 }

actix-server/tests/test_server.rs

@@ -1,14 +1,16 @@
 use std::io::Read;
-use std::sync::mpsc;
+use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
+use std::sync::{mpsc, Arc};
 use std::{net, thread, time};
 
 use actix_codec::{BytesCodec, Framed};
-use actix_server::{Io, Server, ServerConfig};
-use actix_service::{factory_fn_cfg, service_fn, service_fn2};
+use actix_rt::net::TcpStream;
+use actix_server::Server;
+use actix_service::fn_service;
 use bytes::Bytes;
-use futures::{future::ok, SinkExt};
+use futures::future::{lazy, ok};
+use futures::SinkExt;
 use net2::TcpBuilder;
-use tokio_net::tcp::TcpStream;
 
 fn unused_addr() -> net::SocketAddr {
     let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
@@ -27,12 +29,9 @@ fn test_bind() {
     let h = thread::spawn(move || {
         let sys = actix_rt::System::new("test");
         let srv = Server::build()
-            .bind("test", addr, move || {
-                factory_fn_cfg(move |cfg: &ServerConfig| {
-                    assert_eq!(cfg.local_addr(), addr);
-                    ok::<_, ()>(service_fn2(|_| ok::<_, ()>(())))
-                })
-            })
+            .workers(1)
+            .disable_signals()
+            .bind("test", addr, move || fn_service(|_| ok::<_, ()>(())))
             .unwrap()
             .start();
         let _ = tx.send((srv, actix_rt::System::current()));
@@ -46,26 +45,6 @@ fn test_bind() {
     let _ = h.join();
 }
 
-#[test]
-fn test_bind_no_config() {
-    let addr = unused_addr();
-    let (tx, rx) = mpsc::channel();
-
-    let h = thread::spawn(move || {
-        let sys = actix_rt::System::new("test");
-        let srv = Server::build()
-            .bind("test", addr, move || service_fn(|_| ok::<_, ()>(())))
-            .unwrap()
-            .start();
-        let _ = tx.send((srv, actix_rt::System::current()));
-        let _ = sys.run();
-    });
-    let (_, sys) = rx.recv().unwrap();
-    assert!(net::TcpStream::connect(addr).is_ok());
-    let _ = sys.stop();
-    let _ = h.join();
-}
-
 #[test]
 fn test_listen() {
     let addr = unused_addr();
@@ -74,19 +53,16 @@ fn test_listen() {
     let h = thread::spawn(move || {
         let sys = actix_rt::System::new("test");
         let lst = net::TcpListener::bind(addr).unwrap();
-        let srv = Server::build()
-            .listen("test", lst, move || {
-                factory_fn_cfg(move |cfg: &ServerConfig| {
-                    assert_eq!(cfg.local_addr(), addr);
-                    ok::<_, ()>(service_fn2(|_| ok::<_, ()>(())))
-                })
-            })
+        Server::build()
+            .disable_signals()
+            .workers(1)
+            .listen("test", lst, move || fn_service(|_| ok::<_, ()>(())))
             .unwrap()
             .start();
-        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = tx.send(actix_rt::System::current());
         let _ = sys.run();
     });
-    let (_, sys) = rx.recv().unwrap();
+    let sys = rx.recv().unwrap();
 
     thread::sleep(time::Duration::from_millis(500));
     assert!(net::TcpStream::connect(addr).is_ok());
@@ -104,19 +80,14 @@ fn test_start() {
         let sys = actix_rt::System::new("test");
         let srv: Server = Server::build()
             .backlog(100)
+            .disable_signals()
             .bind("test", addr, move || {
-                factory_fn_cfg(move |cfg: &ServerConfig| {
-                    assert_eq!(cfg.local_addr(), addr);
-
-                    let srv = service_fn2(|io: Io<TcpStream>| {
-                        async {
-                            let mut f = Framed::new(io.into_parts().0, BytesCodec);
-                            f.send(Bytes::from_static(b"test")).await.unwrap();
-                            Ok::<_, ()>(())
-                        }
-                    });
-
-                    ok::<_, ()>(srv)
+                fn_service(|io: TcpStream| {
+                    async move {
+                        let mut f = Framed::new(io, BytesCodec);
+                        f.send(Bytes::from_static(b"test")).await.unwrap();
+                        Ok::<_, ()>(())
+                    }
                 })
             })
             .unwrap()
@@ -162,3 +133,51 @@ fn test_start() {
     let _ = sys.stop();
     let _ = h.join();
 }
+
+#[test]
+fn test_configure() {
+    let addr1 = unused_addr();
+    let addr2 = unused_addr();
+    let addr3 = unused_addr();
+    let (tx, rx) = mpsc::channel();
+    let num = Arc::new(AtomicUsize::new(0));
+    let num2 = num.clone();
+
+    let h = thread::spawn(move || {
+        let num = num2.clone();
+        let sys = actix_rt::System::new("test");
+        let srv = Server::build()
+            .disable_signals()
+            .configure(move |cfg| {
+                let num = num.clone();
+                let lst = net::TcpListener::bind(addr3).unwrap();
+                cfg.bind("addr1", addr1)
+                    .unwrap()
+                    .bind("addr2", addr2)
+                    .unwrap()
+                    .listen("addr3", lst)
+                    .apply(move |rt| {
+                        let num = num.clone();
+                        rt.service("addr1", fn_service(|_| ok::<_, ()>(())));
+                        rt.service("addr3", fn_service(|_| ok::<_, ()>(())));
+                        rt.on_start(lazy(move |_| {
+                            let _ = num.fetch_add(1, Relaxed);
+                        }))
+                    })
+            })
+            .unwrap()
+            .workers(1)
+            .start();
+        let _ = tx.send((srv, actix_rt::System::current()));
+        let _ = sys.run();
+    });
+    let (_, sys) = rx.recv().unwrap();
+    thread::sleep(time::Duration::from_millis(500));
+
+    assert!(net::TcpStream::connect(addr1).is_ok());
+    assert!(net::TcpStream::connect(addr2).is_ok());
+    assert!(net::TcpStream::connect(addr3).is_ok());
+    assert_eq!(num.load(Relaxed), 1);
+    let _ = sys.stop();
+    let _ = h.join();
+}

actix-service/CHANGES.md

@@ -1,5 +1,63 @@
 # Changes
 
+## [1.0.1] - 2019-12-22
+
+### Changed
+
+* `map_config()` and `unit_config()` accepts `IntoServiceFactory` type
+
+
+## [1.0.0] - 2019-12-11
+
+### Added
+
+* Add Clone impl for Apply service
+
+
+## [1.0.0-alpha.4] - 2019-12-08
+
+### Changed
+
+* Renamed `service_fn` to `fn_service`
+
+* Renamed `factory_fn` to `fn_factory`
+
+* Renamed `factory_fn_cfg` to `fn_factory_with_config`
+
+
+## [1.0.0-alpha.3] - 2019-12-06
+
+### Changed
+
+* Add missing Clone impls
+
+* Restore `Transform::map_init_err()` combinator
+
+* Restore `Service/Factory::apply_fn()` in form of `Pipeline/Factory::and_then_apply_fn()`
+
+* Optimize service combinators and futures memory layout
+
+
+## [1.0.0-alpha.2] - 2019-12-02
+
+### Changed
+
+* Use owned config value for service factory
+
+* Renamed BoxedNewService/BoxedService to BoxServiceFactory/BoxService
+
+
+## [1.0.0-alpha.1] - 2019-11-25
+
+### Changed
+
+* Migraded to `std::future`
+
+* `NewService` renamed to `ServiceFactory`
+
+* Added `pipeline` and `pipeline_factory` function
+
+
 ## [0.4.2] - 2019-08-27
 
 ### Fixed

actix-service/Cargo.toml

@@ -1,15 +1,14 @@
 [package]
 name = "actix-service"
-version = "1.0.0-alpha.1"
+version = "1.0.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix Service"
+description = "Actix service"
 keywords = ["network", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-net.git"
 documentation = "https://docs.rs/actix-service/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
 workspace = ".."
 
@@ -23,9 +22,8 @@ name = "actix_service"
 path = "src/lib.rs"
 
 [dependencies]
-futures = "0.3.1"
-pin-project = "0.4.5"
+futures-util = "0.3.1"
+pin-project = "0.4.6"
 
 [dev-dependencies]
-tokio = "0.2.0-alpha.6"
-# actix-rt = "1.0.0-alpha.1"
+actix-rt = "1.0.0"

actix-service/src/and_then.rs

@@ -9,10 +9,7 @@ use crate::cell::Cell;
 /// of another service which completes successfully.
 ///
 /// This is created by the `ServiceExt::and_then` method.
-pub struct AndThenService<A, B> {
-    a: A,
-    b: Cell<B>,
-}
+pub struct AndThenService<A, B>(Cell<(A, B)>);
 
 impl<A, B> AndThenService<A, B> {
     /// Create new `AndThen` combinator
@@ -21,19 +18,13 @@ impl<A, B> AndThenService<A, B> {
         A: Service,
         B: Service<Request = A::Response, Error = A::Error>,
     {
-        Self { a, b: Cell::new(b) }
+        Self(Cell::new((a, b)))
     }
 }
 
-impl<A, B> Clone for AndThenService<A, B>
-where
-    A: Clone,
-{
+impl<A, B> Clone for AndThenService<A, B> {
     fn clone(&self) -> Self {
-        AndThenService {
-            a: self.a.clone(),
-            b: self.b.clone(),
-        }
+        AndThenService(self.0.clone())
     }
 }
 
@@ -48,8 +39,10 @@ where
     type Future = AndThenServiceResponse<A, B>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        let not_ready = !self.a.poll_ready(cx)?.is_ready();
-        if !self.b.get_mut().poll_ready(cx)?.is_ready() || not_ready {
+        let srv = self.0.get_mut();
+
+        let not_ready = !srv.0.poll_ready(cx)?.is_ready();
+        if !srv.1.poll_ready(cx)?.is_ready() || not_ready {
             Poll::Pending
         } else {
             Poll::Ready(Ok(()))
@@ -57,7 +50,9 @@ where
     }
 
     fn call(&mut self, req: A::Request) -> Self::Future {
-        AndThenServiceResponse::new(self.a.call(req), self.b.clone())
+        AndThenServiceResponse {
+            state: State::A(self.0.get_mut().0.call(req), Some(self.0.clone())),
+        }
     }
 }
 
@@ -67,25 +62,19 @@ where
     A: Service,
     B: Service<Request = A::Response, Error = A::Error>,
 {
-    b: Cell<B>,
     #[pin]
-    fut_b: Option<B::Future>,
-    #[pin]
-    fut_a: Option<A::Future>,
+    state: State<A, B>,
 }
 
-impl<A, B> AndThenServiceResponse<A, B>
+#[pin_project::pin_project]
+enum State<A, B>
 where
     A: Service,
     B: Service<Request = A::Response, Error = A::Error>,
 {
-    fn new(a: A::Future, b: Cell<B>) -> Self {
-        AndThenServiceResponse {
-            b,
-            fut_a: Some(a),
-            fut_b: None,
-        }
-    }
+    A(#[pin] A::Future, Option<Cell<(A, B)>>),
+    B(#[pin] B::Future),
+    Empty,
 }
 
 impl<A, B> Future for AndThenServiceResponse<A, B>
@@ -95,28 +84,27 @@ where
 {
     type Output = Result<B::Response, A::Error>;
 
+    #[pin_project::project]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.as_mut().project();
 
-        loop {
-            if let Some(fut) = this.fut_b.as_pin_mut() {
-                return fut.poll(cx);
-            }
-
-            match this
-                .fut_a
-                .as_pin_mut()
-                .expect("Bug in actix-service")
-                .poll(cx)
-            {
-                Poll::Ready(Ok(resp)) => {
-                    this = self.as_mut().project();
-                    this.fut_a.set(None);
-                    this.fut_b.set(Some(this.b.get_mut().call(resp)));
+        #[project]
+        match this.state.as_mut().project() {
+            State::A(fut, b) => match fut.poll(cx)? {
+                Poll::Ready(res) => {
+                    let mut b = b.take().unwrap();
+                    this.state.set(State::Empty); // drop fut A
+                    let fut = b.get_mut().1.call(res);
+                    this.state.set(State::B(fut));
+                    self.poll(cx)
                 }
-                Poll::Ready(Err(e)) => return Poll::Ready(Err(e)),
-                Poll::Pending => return Poll::Pending,
-            }
+                Poll::Pending => Poll::Pending,
+            },
+            State::B(fut) => fut.poll(cx).map(|r| {
+                this.state.set(State::Empty);
+                r
+            }),
+            State::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
         }
     }
 }
@@ -125,7 +113,13 @@ where
 pub struct AndThenServiceFactory<A, B>
 where
     A: ServiceFactory,
-    B: ServiceFactory,
+    A::Config: Clone,
+    B: ServiceFactory<
+        Config = A::Config,
+        Request = A::Response,
+        Error = A::Error,
+        InitError = A::InitError,
+    >,
 {
     a: A,
     b: B,
@@ -134,6 +128,7 @@ where
 impl<A, B> AndThenServiceFactory<A, B>
 where
     A: ServiceFactory,
+    A::Config: Clone,
     B: ServiceFactory<
         Config = A::Config,
         Request = A::Response,
@@ -142,7 +137,7 @@ where
     >,
 {
     /// Create new `AndThenFactory` combinator
-    pub fn new(a: A, b: B) -> Self {
+    pub(crate) fn new(a: A, b: B) -> Self {
         Self { a, b }
     }
 }
@@ -150,6 +145,7 @@ where
 impl<A, B> ServiceFactory for AndThenServiceFactory<A, B>
 where
     A: ServiceFactory,
+    A::Config: Clone,
     B: ServiceFactory<
         Config = A::Config,
         Request = A::Response,
@@ -166,15 +162,24 @@ where
     type InitError = A::InitError;
     type Future = AndThenServiceFactoryResponse<A, B>;
 
-    fn new_service(&self, cfg: &A::Config) -> Self::Future {
-        AndThenServiceFactoryResponse::new(self.a.new_service(cfg), self.b.new_service(cfg))
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
+        AndThenServiceFactoryResponse::new(
+            self.a.new_service(cfg.clone()),
+            self.b.new_service(cfg),
+        )
     }
 }
 
 impl<A, B> Clone for AndThenServiceFactory<A, B>
 where
     A: ServiceFactory + Clone,
-    B: ServiceFactory + Clone,
+    A::Config: Clone,
+    B: ServiceFactory<
+            Config = A::Config,
+            Request = A::Response,
+            Error = A::Error,
+            InitError = A::InitError,
+        > + Clone,
 {
     fn clone(&self) -> Self {
         Self {
@@ -190,10 +195,10 @@ where
     A: ServiceFactory,
     B: ServiceFactory<Request = A::Response>,
 {
-    #[pin]
-    fut_b: B::Future,
     #[pin]
     fut_a: A::Future,
+    #[pin]
+    fut_b: B::Future,
 
     a: Option<A::Service>,
     b: Option<B::Service>,
@@ -251,9 +256,9 @@ mod tests {
     use std::rc::Rc;
     use std::task::{Context, Poll};
 
-    use futures::future::{lazy, ok, ready, Ready};
+    use futures_util::future::{lazy, ok, ready, Ready};
 
-    use crate::{factory_fn, pipeline, pipeline_factory, Service, ServiceFactory};
+    use crate::{fn_factory, pipeline, pipeline_factory, Service, ServiceFactory};
 
     struct Srv1(Rc<Cell<usize>>);
 
@@ -282,7 +287,7 @@ mod tests {
         type Error = ();
         type Future = Ready<Result<Self::Response, ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             self.0.set(self.0.get() + 1);
             Poll::Ready(Ok(()))
         }
@@ -292,7 +297,7 @@ mod tests {
         }
     }
 
-    #[tokio::test]
+    #[actix_rt::test]
     async fn test_poll_ready() {
         let cnt = Rc::new(Cell::new(0));
         let mut srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt.clone()));
@@ -301,7 +306,7 @@ mod tests {
         assert_eq!(cnt.get(), 2);
     }
 
-    #[tokio::test]
+    #[actix_rt::test]
     async fn test_call() {
         let cnt = Rc::new(Cell::new(0));
         let mut srv = pipeline(Srv1(cnt.clone())).and_then(Srv2(cnt));
@@ -310,15 +315,15 @@ mod tests {
         assert_eq!(res.unwrap(), (("srv1", "srv2")));
     }
 
-    #[tokio::test]
+    #[actix_rt::test]
     async fn test_new_service() {
         let cnt = Rc::new(Cell::new(0));
         let cnt2 = cnt.clone();
         let new_srv =
-            pipeline_factory(factory_fn(move || ready(Ok::<_, ()>(Srv1(cnt2.clone())))))
+            pipeline_factory(fn_factory(move || ready(Ok::<_, ()>(Srv1(cnt2.clone())))))
                 .and_then(move || ready(Ok(Srv2(cnt.clone()))));
 
-        let mut srv = new_srv.new_service(&()).await.unwrap();
+        let mut srv = new_srv.new_service(()).await.unwrap();
         let res = srv.call("srv1").await;
         assert!(res.is_ok());
         assert_eq!(res.unwrap(), ("srv1", "srv2"));

actix-service/src/and_then_apply_fn.rs

@@ -0,0 +1,334 @@
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use crate::cell::Cell;
+use crate::{Service, ServiceFactory};
+
+/// `Apply` service combinator
+pub 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>,
+{
+    a: A,
+    b: Cell<(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 {
+            a,
+            b: Cell::new((b, f)),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFn<A, B, F, Fut, Res, Err>
+where
+    A: Service + Clone,
+    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 {
+            a: self.a.clone(),
+            b: self.b.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 not_ready = self.a.poll_ready(cx)?.is_pending();
+        if self.b.get_mut().0.poll_ready(cx)?.is_pending() || not_ready {
+            Poll::Pending
+        } else {
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    fn call(&mut self, req: A::Request) -> Self::Future {
+        AndThenApplyFnFuture {
+            state: State::A(self.a.call(req), Some(self.b.clone())),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub 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]
+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<Cell<(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>;
+
+    #[pin_project::project]
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
+
+        #[project]
+        match this.state.as_mut().project() {
+            State::A(fut, b) => match fut.poll(cx)? {
+                Poll::Ready(res) => {
+                    let mut b = b.take().unwrap();
+                    this.state.set(State::Empty);
+                    let b = b.get_mut();
+                    let fut = (&mut b.1)(res, &mut b.0);
+                    this.state.set(State::B(fut));
+                    self.poll(cx)
+                }
+                Poll::Pending => Poll::Pending,
+            },
+            State::B(fut) => fut.poll(cx).map(|r| {
+                this.state.set(State::Empty);
+                r
+            }),
+            State::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
+        }
+    }
+}
+
+/// `AndThenApplyFn` service factory
+pub struct AndThenApplyFnFactory<A, B, F, Fut, Res, Err> {
+    a: A,
+    b: B,
+    f: 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 {
+            a: a,
+            b: b,
+            f: f,
+            r: PhantomData,
+        }
+    }
+}
+
+impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFnFactory<A, B, F, Fut, Res, Err>
+where
+    A: Clone,
+    B: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            a: self.a.clone(),
+            b: self.b.clone(),
+            f: self.f.clone(),
+            r: PhantomData,
+        }
+    }
+}
+
+impl<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 {
+        AndThenApplyFnFactoryResponse {
+            a: None,
+            b: None,
+            f: self.f.clone(),
+            fut_a: self.a.new_service(cfg.clone()),
+            fut_b: self.b.new_service(cfg),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub 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 {
+                a: this.a.take().unwrap(),
+                b: Cell::new((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(()))
+        }
+
+        fn call(&mut self, req: Self::Request) -> Self::Future {
+            ok(req)
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_service() {
+        let mut srv = pipeline(|r: &'static str| ok(r))
+            .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(|r: &'static str| ok(r))))
+            .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

@@ -5,7 +5,7 @@ use std::task::{Context, Poll};
 
 use super::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
-/// Apply tranform function to a service
+/// Apply tranform 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>
 where
     T: Service<Error = Err>,
@@ -16,7 +16,7 @@ where
     Apply::new(service.into_service(), f)
 }
 
-/// Create factory for `apply` service.
+/// Service factory that prodices `apply_fn` service.
 pub fn apply_fn_factory<T, F, R, In, Out, Err, U>(
     service: U,
     f: F,
@@ -56,6 +56,21 @@ where
     }
 }
 
+impl<T, F, R, In, Out, Err> Clone for Apply<T, F, R, In, Out, Err>
+where
+    T: Service<Error = Err> + Clone,
+    F: FnMut(In, &mut T) -> R + Clone,
+    R: Future<Output = Result<Out, Err>>,
+{
+    fn clone(&self) -> Self {
+        Apply {
+            service: self.service.clone(),
+            f: self.f.clone(),
+            r: PhantomData,
+        }
+    }
+}
+
 impl<T, F, R, In, Out, Err> Service for Apply<T, F, R, In, Out, Err>
 where
     T: Service<Error = Err>,
@@ -67,8 +82,8 @@ where
     type Error = Err;
     type Future = R;
 
-    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(futures::ready!(self.service.poll_ready(ctx)))
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(futures_util::ready!(self.service.poll_ready(cx)))
     }
 
     fn call(&mut self, req: In) -> Self::Future {
@@ -80,6 +95,8 @@ where
 pub struct ApplyServiceFactory<T, F, R, In, Out, Err>
 where
     T: ServiceFactory<Error = Err>,
+    F: FnMut(In, &mut T::Service) -> R + Clone,
+    R: Future<Output = Result<Out, Err>>,
 {
     service: T,
     f: F,
@@ -102,6 +119,21 @@ where
     }
 }
 
+impl<T, F, R, In, Out, Err> Clone for ApplyServiceFactory<T, F, R, In, Out, Err>
+where
+    T: ServiceFactory<Error = Err> + Clone,
+    F: FnMut(In, &mut T::Service) -> R + Clone,
+    R: Future<Output = Result<Out, Err>>,
+{
+    fn clone(&self) -> Self {
+        Self {
+            service: self.service.clone(),
+            f: self.f.clone(),
+            r: PhantomData,
+        }
+    }
+}
+
 impl<T, F, R, In, Out, Err> ServiceFactory for ApplyServiceFactory<T, F, R, In, Out, Err>
 where
     T: ServiceFactory<Error = Err>,
@@ -117,7 +149,7 @@ where
     type InitError = T::InitError;
     type Future = ApplyServiceFactoryResponse<T, F, R, In, Out, Err>;
 
-    fn new_service(&self, cfg: &T::Config) -> Self::Future {
+    fn new_service(&self, cfg: T::Config) -> Self::Future {
         ApplyServiceFactoryResponse::new(self.service.new_service(cfg), self.f.clone())
     }
 }
@@ -126,7 +158,7 @@ where
 pub struct ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
 where
     T: ServiceFactory<Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R + Clone,
+    F: FnMut(In, &mut T::Service) -> R,
     R: Future<Output = Result<Out, Err>>,
 {
     #[pin]
@@ -138,7 +170,7 @@ where
 impl<T, F, R, In, Out, Err> ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
 where
     T: ServiceFactory<Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R + Clone,
+    F: FnMut(In, &mut T::Service) -> R,
     R: Future<Output = Result<Out, Err>>,
 {
     fn new(fut: T::Future, f: F) -> Self {
@@ -153,7 +185,7 @@ where
 impl<T, F, R, In, Out, Err> Future for ApplyServiceFactoryResponse<T, F, R, In, Out, Err>
 where
     T: ServiceFactory<Error = Err>,
-    F: FnMut(In, &mut T::Service) -> R + Clone,
+    F: FnMut(In, &mut T::Service) -> R,
     R: Future<Output = Result<Out, Err>>,
 {
     type Output = Result<Apply<T::Service, F, R, In, Out, Err>, T::InitError>;
@@ -173,7 +205,7 @@ where
 mod tests {
     use std::task::{Context, Poll};
 
-    use futures::future::{lazy, ok, Ready};
+    use futures_util::future::{lazy, ok, Ready};
 
     use super::*;
     use crate::{pipeline, pipeline_factory, Service, ServiceFactory};
@@ -187,7 +219,7 @@ mod tests {
         type Error = ();
         type Future = Ready<Result<(), ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             Poll::Ready(Ok(()))
         }
 
@@ -196,7 +228,7 @@ mod tests {
         }
     }
 
-    #[tokio::test]
+    #[actix_rt::test]
     async fn test_call() {
         let mut srv = pipeline(apply_fn(Srv, |req: &'static str, srv| {
             let fut = srv.call(());
@@ -213,7 +245,7 @@ mod tests {
         assert_eq!(res.unwrap(), (("srv", ())));
     }
 
-    #[tokio::test]
+    #[actix_rt::test]
     async fn test_new_service() {
         let new_srv = pipeline_factory(apply_fn_factory(
             || ok::<_, ()>(Srv),
@@ -226,7 +258,7 @@ mod tests {
             },
         ));
 
-        let mut srv = new_srv.new_service(&()).await.unwrap();
+        let mut srv = new_srv.new_service(()).await.unwrap();
 
         assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
 

actix-service/src/apply_cfg.rs

@@ -6,65 +6,61 @@ use std::task::{Context, Poll};
 use crate::cell::Cell;
 use crate::{Service, ServiceFactory};
 
-/// Convert `Fn(&Config, &mut Service) -> Future<Service>` fn to a NewService
+/// Convert `Fn(Config, &mut Service1) -> Future<Service2>` fn to a service factory
 pub fn apply_cfg<F, C, T, R, S, E>(srv: T, f: F) -> ApplyConfigService<F, C, T, R, S, E>
 where
-    F: FnMut(&C, &mut T) -> R,
+    F: FnMut(C, &mut T) -> R,
     T: Service,
     R: Future<Output = Result<S, E>>,
     S: Service,
 {
     ApplyConfigService {
-        f: Cell::new(f),
-        srv: Cell::new(srv),
+        srv: Cell::new((srv, f)),
         _t: PhantomData,
     }
 }
 
-/// Convert `Fn(&Config, &mut Service) -> Future<Service>` fn to a NewService
-/// Service get constructor from NewService.
+/// Convert `Fn(Config, &mut Service1) -> Future<Service2>` fn to a service factory
+///
+/// Service1 get constructed from `T` factory.
 pub fn apply_cfg_factory<F, C, T, R, S>(
-    srv: T,
+    factory: T,
     f: F,
 ) -> ApplyConfigServiceFactory<F, C, T, R, S>
 where
-    C: Clone,
-    F: FnMut(&C, &mut T::Service) -> R,
+    F: FnMut(C, &mut T::Service) -> R,
     T: ServiceFactory<Config = ()>,
     T::InitError: From<T::Error>,
     R: Future<Output = Result<S, T::InitError>>,
     S: Service,
 {
     ApplyConfigServiceFactory {
-        f: Cell::new(f),
-        srv: Cell::new(srv),
+        srv: Cell::new((factory, f)),
         _t: PhantomData,
     }
 }
 
-/// Convert `Fn(&Config) -> Future<Service>` fn to NewService\
+/// Convert `Fn(Config, &mut Server) -> Future<Service>` fn to NewService\
 pub struct ApplyConfigService<F, C, T, R, S, E>
 where
-    F: FnMut(&C, &mut T) -> R,
+    F: FnMut(C, &mut T) -> R,
     T: Service,
     R: Future<Output = Result<S, E>>,
     S: Service,
 {
-    f: Cell<F>,
-    srv: Cell<T>,
+    srv: Cell<(T, F)>,
     _t: PhantomData<(C, R, S)>,
 }
 
 impl<F, C, T, R, S, E> Clone for ApplyConfigService<F, C, T, R, S, E>
 where
-    F: FnMut(&C, &mut T) -> R,
+    F: FnMut(C, &mut T) -> R,
     T: Service,
     R: Future<Output = Result<S, E>>,
     S: Service,
 {
     fn clone(&self) -> Self {
         ApplyConfigService {
-            f: self.f.clone(),
             srv: self.srv.clone(),
             _t: PhantomData,
         }
@@ -73,7 +69,7 @@ where
 
 impl<F, C, T, R, S, E> ServiceFactory for ApplyConfigService<F, C, T, R, S, E>
 where
-    F: FnMut(&C, &mut T) -> R,
+    F: FnMut(C, &mut T) -> R,
     T: Service,
     R: Future<Output = Result<S, E>>,
     S: Service,
@@ -87,36 +83,35 @@ where
     type InitError = E;
     type Future = R;
 
-    fn new_service(&self, cfg: &C) -> Self::Future {
-        unsafe { (self.f.get_mut_unsafe())(cfg, self.srv.get_mut_unsafe()) }
+    fn new_service(&self, cfg: C) -> Self::Future {
+        unsafe {
+            let srv = self.srv.get_mut_unsafe();
+            (srv.1)(cfg, &mut srv.0)
+        }
     }
 }
 
 /// Convert `Fn(&Config) -> Future<Service>` fn to NewService
 pub struct ApplyConfigServiceFactory<F, C, T, R, S>
 where
-    C: Clone,
-    F: FnMut(&C, &mut T::Service) -> R,
+    F: FnMut(C, &mut T::Service) -> R,
     T: ServiceFactory<Config = ()>,
     R: Future<Output = Result<S, T::InitError>>,
     S: Service,
 {
-    f: Cell<F>,
-    srv: Cell<T>,
+    srv: Cell<(T, F)>,
     _t: PhantomData<(C, R, S)>,
 }
 
 impl<F, C, T, R, S> Clone for ApplyConfigServiceFactory<F, C, T, R, S>
 where
-    C: Clone,
-    F: FnMut(&C, &mut T::Service) -> R,
+    F: FnMut(C, &mut T::Service) -> R,
     T: ServiceFactory<Config = ()>,
     R: Future<Output = Result<S, T::InitError>>,
     S: Service,
 {
     fn clone(&self) -> Self {
         Self {
-            f: self.f.clone(),
             srv: self.srv.clone(),
             _t: PhantomData,
         }
@@ -125,8 +120,7 @@ where
 
 impl<F, C, T, R, S> ServiceFactory for ApplyConfigServiceFactory<F, C, T, R, S>
 where
-    C: Clone,
-    F: FnMut(&C, &mut T::Service) -> R,
+    F: FnMut(C, &mut T::Service) -> R,
     T: ServiceFactory<Config = ()>,
     T::InitError: From<T::Error>,
     R: Future<Output = Result<S, T::InitError>>,
@@ -141,14 +135,11 @@ where
     type InitError = T::InitError;
     type Future = ApplyConfigServiceFactoryResponse<F, C, T, R, S>;
 
-    fn new_service(&self, cfg: &C) -> Self::Future {
+    fn new_service(&self, cfg: C) -> Self::Future {
         ApplyConfigServiceFactoryResponse {
-            f: self.f.clone(),
-            cfg: cfg.clone(),
-            fut: None,
-            srv: None,
-            srv_fut: Some(self.srv.get_ref().new_service(&())),
-            _t: PhantomData,
+            cfg: Some(cfg),
+            store: self.srv.clone(),
+            state: State::A(self.srv.get_ref().0.new_service(())),
         }
     }
 }
@@ -156,27 +147,34 @@ where
 #[pin_project::pin_project]
 pub struct ApplyConfigServiceFactoryResponse<F, C, T, R, S>
 where
-    C: Clone,
-    F: FnMut(&C, &mut T::Service) -> R,
+    F: FnMut(C, &mut T::Service) -> R,
     T: ServiceFactory<Config = ()>,
     T::InitError: From<T::Error>,
     R: Future<Output = Result<S, T::InitError>>,
     S: Service,
 {
-    cfg: C,
-    f: Cell<F>,
-    srv: Option<T::Service>,
+    cfg: Option<C>,
+    store: Cell<(T, F)>,
     #[pin]
-    srv_fut: Option<T::Future>,
-    #[pin]
-    fut: Option<R>,
-    _t: PhantomData<(S,)>,
+    state: State<T, R, S>,
+}
+
+#[pin_project::pin_project]
+enum State<T, R, S>
+where
+    T: ServiceFactory<Config = ()>,
+    T::InitError: From<T::Error>,
+    R: Future<Output = Result<S, T::InitError>>,
+    S: Service,
+{
+    A(#[pin] T::Future),
+    B(T::Service),
+    C(#[pin] R),
 }
 
 impl<F, C, T, R, S> Future for ApplyConfigServiceFactoryResponse<F, C, T, R, S>
 where
-    C: Clone,
-    F: FnMut(&C, &mut T::Service) -> R,
+    F: FnMut(C, &mut T::Service) -> R,
     T: ServiceFactory<Config = ()>,
     T::InitError: From<T::Error>,
     R: Future<Output = Result<S, T::InitError>>,
@@ -184,37 +182,28 @@ where
 {
     type Output = Result<S, T::InitError>;
 
+    #[pin_project::project]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.as_mut().project();
 
-        loop {
-            if let Some(fut) = this.srv_fut.as_pin_mut() {
-                match fut.poll(cx)? {
-                    Poll::Pending => return Poll::Pending,
-                    Poll::Ready(srv) => {
-                        this = self.as_mut().project();
-                        this.srv_fut.set(None);
-                        *this.srv = Some(srv);
-                        continue;
-                    }
+        #[project]
+        match this.state.as_mut().project() {
+            State::A(fut) => match fut.poll(cx)? {
+                Poll::Pending => Poll::Pending,
+                Poll::Ready(srv) => {
+                    this.state.set(State::B(srv));
+                    self.poll(cx)
                 }
-            }
-
-            if let Some(fut) = this.fut.as_pin_mut() {
-                return fut.poll(cx);
-            } else if let Some(srv) = this.srv {
-                match srv.poll_ready(cx)? {
-                    Poll::Ready(_) => {
-                        let fut = this.f.get_mut()(&this.cfg, srv);
-                        this = self.as_mut().project();
-                        this.fut.set(Some(fut));
-                        continue;
-                    }
-                    Poll::Pending => return Poll::Pending,
+            },
+            State::B(srv) => match srv.poll_ready(cx)? {
+                Poll::Ready(_) => {
+                    let fut = (this.store.get_mut().1)(this.cfg.take().unwrap(), srv);
+                    this.state.set(State::C(fut));
+                    self.poll(cx)
                 }
-            } else {
-                return Poll::Pending;
-            }
+                Poll::Pending => Poll::Pending,
+            },
+            State::C(fut) => fut.poll(cx),
         }
     }
 }

actix-service/src/boxed.rs

@@ -1,26 +1,22 @@
+use std::future::Future;
+use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use futures::future::{FutureExt, LocalBoxFuture};
+use futures_util::future::FutureExt;
 
 use crate::{Service, ServiceFactory};
 
-pub type BoxedService<Req, Res, Err> = Box<
-    dyn Service<
-        Request = Req,
-        Response = Res,
-        Error = Err,
-        Future = BoxedServiceResponse<Res, Err>,
-    >,
->;
+pub type BoxFuture<I, E> = Pin<Box<dyn Future<Output = Result<I, E>>>>;
 
-pub type BoxedServiceResponse<Res, Err> = LocalBoxFuture<'static, Result<Res, Err>>;
+pub type BoxService<Req, Res, Err> =
+    Box<dyn Service<Request = Req, Response = Res, Error = Err, Future = BoxFuture<Res, Err>>>;
 
-pub struct BoxedNewService<C, Req, Res, Err, InitErr>(Inner<C, Req, Res, Err, InitErr>);
+pub struct BoxServiceFactory<C, Req, Res, Err, InitErr>(Inner<C, Req, Res, Err, InitErr>);
 
-/// Create boxed new service
+/// Create boxed service factory
 pub fn factory<T>(
     factory: T,
-) -> BoxedNewService<T::Config, T::Request, T::Response, T::Error, T::InitError>
+) -> BoxServiceFactory<T::Config, T::Request, T::Response, T::Error, T::InitError>
 where
     T: ServiceFactory + 'static,
     T::Request: 'static,
@@ -30,14 +26,14 @@ where
     T::Error: 'static,
     T::InitError: 'static,
 {
-    BoxedNewService(Box::new(FactoryWrapper {
+    BoxServiceFactory(Box::new(FactoryWrapper {
         factory,
         _t: std::marker::PhantomData,
     }))
 }
 
 /// Create boxed service
-pub fn service<T>(service: T) -> BoxedService<T::Request, T::Response, T::Error>
+pub fn service<T>(service: T) -> BoxService<T::Request, T::Response, T::Error>
 where
     T: Service + 'static,
     T::Future: 'static,
@@ -52,12 +48,12 @@ type Inner<C, Req, Res, Err, InitErr> = Box<
         Response = Res,
         Error = Err,
         InitError = InitErr,
-        Service = BoxedService<Req, Res, Err>,
-        Future = LocalBoxFuture<'static, Result<BoxedService<Req, Res, Err>, InitErr>>,
+        Service = BoxService<Req, Res, Err>,
+        Future = BoxFuture<BoxService<Req, Res, Err>, InitErr>,
     >,
 >;
 
-impl<C, Req, Res, Err, InitErr> ServiceFactory for BoxedNewService<C, Req, Res, Err, InitErr>
+impl<C, Req, Res, Err, InitErr> ServiceFactory for BoxServiceFactory<C, Req, Res, Err, InitErr>
 where
     Req: 'static,
     Res: 'static,
@@ -69,11 +65,11 @@ where
     type Error = Err;
     type InitError = InitErr;
     type Config = C;
-    type Service = BoxedService<Req, Res, Err>;
+    type Service = BoxService<Req, Res, Err>;
 
-    type Future = LocalBoxFuture<'static, Result<Self::Service, InitErr>>;
+    type Future = BoxFuture<Self::Service, InitErr>;
 
-    fn new_service(&self, cfg: &C) -> Self::Future {
+    fn new_service(&self, cfg: C) -> Self::Future {
         self.0.new_service(cfg)
     }
 }
@@ -105,14 +101,15 @@ where
     type Error = Err;
     type InitError = InitErr;
     type Config = C;
-    type Service = BoxedService<Req, Res, Err>;
-    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
+    type Service = BoxService<Req, Res, Err>;
+    type Future = BoxFuture<Self::Service, Self::InitError>;
 
-    fn new_service(&self, cfg: &C) -> Self::Future {
-        self.factory
-            .new_service(cfg)
-            .map(|res| res.map(ServiceWrapper::boxed))
-            .boxed_local()
+    fn new_service(&self, cfg: C) -> Self::Future {
+        Box::pin(
+            self.factory
+                .new_service(cfg)
+                .map(|res| res.map(ServiceWrapper::boxed)),
+        )
     }
 }
 
@@ -123,7 +120,7 @@ where
     T: Service + 'static,
     T::Future: 'static,
 {
-    fn boxed(service: T) -> BoxedService<T::Request, T::Response, T::Error> {
+    fn boxed(service: T) -> BoxService<T::Request, T::Response, T::Error> {
         Box::new(ServiceWrapper(service))
     }
 }
@@ -136,13 +133,13 @@ where
     type Request = Req;
     type Response = Res;
     type Error = Err;
-    type Future = LocalBoxFuture<'static, Result<Res, Err>>;
+    type Future = BoxFuture<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 {
-        self.0.call(req).boxed_local()
+        Box::pin(self.0.call(req))
     }
 }

actix-service/src/cell.rs

@@ -1,4 +1,5 @@
 //! Custom cell impl, internal use only
+use std::task::{Context, Poll};
 use std::{cell::UnsafeCell, fmt, rc::Rc};
 
 pub(crate) struct Cell<T> {
@@ -14,7 +15,7 @@ impl<T> Clone for Cell<T> {
 }
 
 impl<T: fmt::Debug> fmt::Debug for Cell<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.inner.fmt(f)
     }
 }
@@ -39,3 +40,18 @@ impl<T> Cell<T> {
         &mut *self.inner.as_ref().get()
     }
 }
+
+impl<T: crate::Service> crate::Service for Cell<T> {
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Future = T::Future;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.get_mut().poll_ready(cx)
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        self.get_mut().call(req)
+    }
+}

actix-service/src/fn_service.rs

@@ -2,12 +2,12 @@ use std::future::Future;
 use std::marker::PhantomData;
 use std::task::{Context, Poll};
 
-use futures::future::{ok, Ready};
+use futures_util::future::{ok, Ready};
 
 use crate::{IntoService, IntoServiceFactory, Service, ServiceFactory};
 
 /// Create `ServiceFactory` for function that can act as a `Service`
-pub fn service_fn<F, Fut, Req, Res, Err, Cfg>(
+pub fn fn_service<F, Fut, Req, Res, Err, Cfg>(
     f: F,
 ) -> FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
@@ -17,16 +17,43 @@ where
     FnServiceFactory::new(f)
 }
 
-pub fn service_fn2<F, Fut, Req, Res, Err>(f: F) -> FnService<F, Fut, Req, Res, Err>
-where
-    F: FnMut(Req) -> Fut,
-    Fut: Future<Output = Result<Res, Err>>,
-{
-    FnService::new(f)
-}
-
 /// Create `ServiceFactory` for function that can produce services
-pub fn factory_fn<F, Cfg, Srv, Fut, Err>(f: F) -> FnServiceNoConfig<F, Cfg, Srv, Fut, Err>
+///
+/// # Example
+///
+/// ```rust
+/// use std::io;
+/// use actix_service::{fn_factory, fn_service, Service, ServiceFactory};
+/// use futures_util::future::ok;
+///
+/// /// Service that divides two usize values.
+/// async fn div((x, y): (usize, usize)) -> Result<usize, io::Error> {
+///     if y == 0 {
+///         Err(io::Error::new(io::ErrorKind::Other, "divide by zdro"))
+///     } else {
+///         Ok(x / y)
+///     }
+/// }
+///
+/// #[actix_rt::main]
+/// async fn main() -> io::Result<()> {
+///     // Create service factory that produces `div` services
+///     let factory = fn_factory(|| {
+///         ok::<_, io::Error>(fn_service(div))
+///     });
+///
+///     // construct new service
+///     let mut srv = factory.new_service(()).await?;
+///
+///     // now we can use `div` service
+///     let result = srv.call((10, 20)).await?;
+///
+///     println!("10 / 20 = {}", result);
+///
+///     Ok(())
+/// }
+/// ```
+pub fn fn_factory<F, Cfg, Srv, Fut, Err>(f: F) -> FnServiceNoConfig<F, Cfg, Srv, Fut, Err>
 where
     Srv: Service,
     F: Fn() -> Fut,
@@ -35,10 +62,41 @@ where
     FnServiceNoConfig::new(f)
 }
 
-/// Create `ServiceFactory` for function that can produce services with configuration
-pub fn factory_fn_cfg<F, Fut, Cfg, Srv, Err>(f: F) -> FnServiceConfig<F, Fut, Cfg, Srv, Err>
+/// Create `ServiceFactory` for function that accepts config argument and can produce services
+///
+/// Any function that has following form `Fn(Config) -> Future<Output = Service>` could
+/// act as a `ServiceFactory`.
+///
+/// # Example
+///
+/// ```rust
+/// use std::io;
+/// use actix_service::{fn_factory_with_config, fn_service, Service, ServiceFactory};
+/// use futures_util::future::ok;
+///
+/// #[actix_rt::main]
+/// async fn main() -> io::Result<()> {
+///     // Create service factory. factory uses config argument for
+///     // services it generates.
+///     let factory = fn_factory_with_config(|y: usize| {
+///         ok::<_, io::Error>(fn_service(move |x: usize| ok::<_, io::Error>(x * y)))
+///     });
+///
+///     // construct new service with config argument
+///     let mut srv = factory.new_service(10).await?;
+///
+///     let result = srv.call(10).await?;
+///     assert_eq!(result, 100);
+///
+///     println!("10 * 10 = {}", result);
+///     Ok(())
+/// }
+/// ```
+pub fn fn_factory_with_config<F, Fut, Cfg, Srv, Err>(
+    f: F,
+) -> FnServiceConfig<F, Fut, Cfg, Srv, Err>
 where
-    F: Fn(&Cfg) -> Fut,
+    F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
     Srv: Service,
 {
@@ -132,6 +190,25 @@ where
     }
 }
 
+impl<F, Fut, Req, Res, Err> Service 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>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        (self.f)(req)
+    }
+}
+
 impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
 where
     F: FnMut(Req) -> Fut + Clone,
@@ -146,7 +223,7 @@ where
     type InitError = ();
     type Future = Ready<Result<Self::Service, Self::InitError>>;
 
-    fn new_service(&self, _: &Cfg) -> Self::Future {
+    fn new_service(&self, _: Cfg) -> Self::Future {
         ok(FnService::new(self.f.clone()))
     }
 }
@@ -165,7 +242,7 @@ where
 /// Convert `Fn(&Config) -> Future<Service>` fn to NewService
 pub struct FnServiceConfig<F, Fut, Cfg, Srv, Err>
 where
-    F: Fn(&Cfg) -> Fut,
+    F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
     Srv: Service,
 {
@@ -175,7 +252,7 @@ where
 
 impl<F, Fut, Cfg, Srv, Err> FnServiceConfig<F, Fut, Cfg, Srv, Err>
 where
-    F: Fn(&Cfg) -> Fut,
+    F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
     Srv: Service,
 {
@@ -184,9 +261,23 @@ where
     }
 }
 
+impl<F, Fut, Cfg, Srv, Err> Clone for FnServiceConfig<F, Fut, Cfg, Srv, Err>
+where
+    F: Fn(Cfg) -> Fut + Clone,
+    Fut: Future<Output = Result<Srv, Err>>,
+    Srv: Service,
+{
+    fn clone(&self) -> Self {
+        FnServiceConfig {
+            f: self.f.clone(),
+            _t: PhantomData,
+        }
+    }
+}
+
 impl<F, Fut, Cfg, Srv, Err> ServiceFactory for FnServiceConfig<F, Fut, Cfg, Srv, Err>
 where
-    F: Fn(&Cfg) -> Fut,
+    F: Fn(Cfg) -> Fut,
     Fut: Future<Output = Result<Srv, Err>>,
     Srv: Service,
 {
@@ -199,7 +290,7 @@ where
     type InitError = Err;
     type Future = Fut;
 
-    fn new_service(&self, cfg: &Cfg) -> Self::Future {
+    fn new_service(&self, cfg: Cfg) -> Self::Future {
         (self.f)(cfg)
     }
 }
@@ -240,7 +331,7 @@ where
     type InitError = E;
     type Future = R;
 
-    fn new_service(&self, _: &C) -> Self::Future {
+    fn new_service(&self, _: C) -> Self::Future {
         (self.f)()
     }
 }
@@ -266,3 +357,47 @@ where
         FnServiceNoConfig::new(self)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::task::Poll;
+
+    use futures_util::future::{lazy, ok};
+
+    use super::*;
+    use crate::{Service, ServiceFactory};
+
+    #[actix_rt::test]
+    async fn test_fn_service() {
+        let new_srv = fn_service(|()| ok::<_, ()>("srv"));
+
+        let mut srv = new_srv.new_service(()).await.unwrap();
+        let res = srv.call(()).await;
+        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), "srv");
+    }
+
+    #[actix_rt::test]
+    async fn test_fn_service_service() {
+        let mut srv = fn_service(|()| ok::<_, ()>("srv"));
+
+        let res = srv.call(()).await;
+        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), "srv");
+    }
+
+    #[actix_rt::test]
+    async fn test_fn_service_with_config() {
+        let new_srv = fn_factory_with_config(|cfg: usize| {
+            ok::<_, ()>(fn_service(move |()| ok::<_, ()>(("srv", cfg))))
+        });
+
+        let mut srv = new_srv.new_service(1).await.unwrap();
+        let res = srv.call(()).await;
+        assert_eq!(lazy(|cx| srv.poll_ready(cx)).await, Poll::Ready(Ok(())));
+        assert!(res.is_ok());
+        assert_eq!(res.unwrap(), ("srv", 1));
+    }
+}

actix-service/src/lib.rs

@@ -1,3 +1,6 @@
+#![deny(rust_2018_idioms, warnings)]
+#![allow(clippy::type_complexity)]
+
 use std::cell::RefCell;
 use std::future::Future;
 use std::rc::Rc;
@@ -5,6 +8,7 @@ use std::sync::Arc;
 use std::task::{self, Context, Poll};
 
 mod and_then;
+mod and_then_apply_fn;
 mod apply;
 mod apply_cfg;
 pub mod boxed;
@@ -17,15 +21,52 @@ mod map_init_err;
 mod pipeline;
 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::fn_service::{factory_fn, factory_fn_cfg, service_fn, service_fn2};
-pub use self::map_config::{map_config, unit_config, MappedConfig};
+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};
 
 /// An asynchronous function from `Request` to a `Response`.
+///
+/// `Service` represents a service that represanting interation, taking requests and giving back
+/// replies. You can think about service as a function with one argument and result as a return
+/// type. In general form it looks like `async fn(Req) -> Result<Res, Err>`. `Service`
+/// trait just generalizing form of this function. Each parameter described as an assotiated type.
+///
+/// Services provides a symmetric and uniform API, same abstractions represents
+/// clients and servers. Services describe only `transforamtion` operation
+/// which encorouge to simplify api surface and phrases `value transformation`.
+/// That leads to simplier design of each service. That also allows better testability
+/// and better composition.
+///
+/// Services could be represented in several different forms. In general,
+/// Service is a type that implements `Service` trait.
+///
+/// ```rust,ignore
+/// struct MyService;
+///
+/// impl Service for MyService {
+///      type Request = u8;
+///      type Response = u64;
+///      type Error = MyError;
+///      type Future = Pin<Box<Future<Output=Result<Self::Response, Self::Error>>>;
+///
+///      fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { ... }
+///
+///      fn call(&mut self) -> Self::Future { ... }
+/// }
+/// ```
+///
+/// Service can have mutable state that influence computation.
+/// This service could be rewritten as a simple function:
+///
+/// ```rust,ignore
+/// async fn my_service(req: u8) -> Result<u64, MyError>;
+/// ```
 pub trait Service {
     /// Requests handled by the service.
     type Request;
@@ -48,6 +89,12 @@ pub trait Service {
     /// This is a **best effort** implementation. False positives are permitted.
     /// It is permitted for the service to return `Ready` from a `poll_ready`
     /// call and the next invocation of `call` results in an error.
+    ///
+    /// There are several notes to consider:
+    ///
+    /// 1. `.poll_ready()` might be called on different task from actual service call.
+    ///
+    /// 2. In case of chained services, `.poll_ready()` get called for all services at once.
     fn poll_ready(&mut self, ctx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>>;
 
     /// Process the request and return the response asynchronously.
@@ -131,7 +178,7 @@ pub trait ServiceFactory {
     type Future: Future<Output = Result<Self::Service, Self::InitError>>;
 
     /// Create and return a new service value asynchronously.
-    fn new_service(&self, cfg: &Self::Config) -> Self::Future;
+    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.
@@ -246,7 +293,7 @@ where
     type InitError = S::InitError;
     type Future = S::Future;
 
-    fn new_service(&self, cfg: &S::Config) -> S::Future {
+    fn new_service(&self, cfg: S::Config) -> S::Future {
         self.as_ref().new_service(cfg)
     }
 }
@@ -263,7 +310,7 @@ where
     type InitError = S::InitError;
     type Future = S::Future;
 
-    fn new_service(&self, cfg: &S::Config) -> S::Future {
+    fn new_service(&self, cfg: S::Config) -> S::Future {
         self.as_ref().new_service(cfg)
     }
 }
@@ -282,7 +329,7 @@ pub trait IntoServiceFactory<T>
 where
     T: ServiceFactory,
 {
-    /// Convert `Self` an `ServiceFactory`
+    /// Convert `Self` to a `ServiceFactory`
     fn into_factory(self) -> T;
 }
 
@@ -306,6 +353,7 @@ where
 
 pub mod dev {
     pub use crate::and_then::{AndThenService, AndThenServiceFactory};
+    pub use crate::and_then_apply_fn::{AndThenApplyFn, AndThenApplyFnFactory};
     pub use crate::apply::{Apply, ApplyServiceFactory};
     pub use crate::apply_cfg::{ApplyConfigService, ApplyConfigServiceFactory};
     pub use crate::fn_service::{
@@ -317,4 +365,5 @@ pub mod dev {
     pub use crate::map_init_err::MapInitErr;
     pub use crate::then::{ThenService, ThenServiceFactory};
     pub use crate::transform::ApplyTransform;
+    pub use crate::transform_err::TransformMapInitErr;
 }

actix-service/src/map.rs

@@ -151,7 +151,7 @@ where
     type InitError = A::InitError;
     type Future = MapServiceFuture<A, F, Res>;
 
-    fn new_service(&self, cfg: &A::Config) -> Self::Future {
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
         MapServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
@@ -197,7 +197,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use futures::future::{lazy, ok, Ready};
+    use futures_util::future::{lazy, ok, Ready};
 
     use super::*;
     use crate::{IntoServiceFactory, Service, ServiceFactory};
@@ -210,7 +210,7 @@ mod tests {
         type Error = ();
         type Future = Ready<Result<(), ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             Poll::Ready(Ok(()))
         }
 
@@ -219,14 +219,14 @@ mod tests {
         }
     }
 
-    #[tokio::test]
+    #[actix_rt::test]
     async fn test_poll_ready() {
         let mut srv = Srv.map(|_| "ok");
         let res = lazy(|cx| srv.poll_ready(cx)).await;
         assert_eq!(res, Poll::Ready(Ok(())));
     }
 
-    #[tokio::test]
+    #[actix_rt::test]
     async fn test_call() {
         let mut srv = Srv.map(|_| "ok");
         let res = srv.call(()).await;
@@ -234,7 +234,7 @@ mod tests {
         assert_eq!(res.unwrap(), "ok");
     }
 
-    #[tokio::test]
+    #[actix_rt::test]
     async fn test_new_service() {
         let new_srv = (|| ok::<_, ()>(Srv)).into_factory().map(|_| "ok");
         let mut srv = new_srv.new_service(&()).await.unwrap();

actix-service/src/map_config.rs

@@ -1,30 +1,30 @@
 use std::marker::PhantomData;
 
-use super::ServiceFactory;
+use super::{IntoServiceFactory, ServiceFactory};
 
-pub enum MappedConfig<'a, T> {
-    Ref(&'a T),
-    Owned(T),
-}
-
-/// Adapt external config to a config for provided new service
-pub fn map_config<T, F, C>(factory: T, f: F) -> MapConfig<T, F, C>
+/// Adapt external config argument to a config for provided service factory
+///
+/// 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>
 where
     T: ServiceFactory,
-    F: Fn(&C) -> MappedConfig<T::Config>,
+    U: IntoServiceFactory<T>,
+    F: Fn(C) -> T::Config,
 {
-    MapConfig::new(factory, f)
+    MapConfig::new(factory.into_factory(), f)
 }
 
 /// Replace config with unit
-pub fn unit_config<T, C>(new_service: T) -> UnitConfig<T, C>
+pub fn unit_config<T, U, C>(factory: U) -> UnitConfig<T, C>
 where
     T: ServiceFactory<Config = ()>,
+    U: IntoServiceFactory<T>,
 {
-    UnitConfig::new(new_service)
+    UnitConfig::new(factory.into_factory())
 }
 
-/// `.map_config()` service combinator
+/// `map_config()` adapter service factory
 pub struct MapConfig<A, F, C> {
     a: A,
     f: F,
@@ -36,7 +36,7 @@ impl<A, F, C> MapConfig<A, F, C> {
     pub(crate) fn new(a: A, f: F) -> Self
     where
         A: ServiceFactory,
-        F: Fn(&C) -> MappedConfig<A::Config>,
+        F: Fn(C) -> A::Config,
     {
         Self {
             a,
@@ -63,7 +63,7 @@ where
 impl<A, F, C> ServiceFactory for MapConfig<A, F, C>
 where
     A: ServiceFactory,
-    F: Fn(&C) -> MappedConfig<A::Config>,
+    F: Fn(C) -> A::Config,
 {
     type Request = A::Request;
     type Response = A::Response;
@@ -74,11 +74,8 @@ where
     type InitError = A::InitError;
     type Future = A::Future;
 
-    fn new_service(&self, cfg: &C) -> Self::Future {
-        match (self.f)(cfg) {
-            MappedConfig::Ref(cfg) => self.a.new_service(cfg),
-            MappedConfig::Owned(cfg) => self.a.new_service(&cfg),
-        }
+    fn new_service(&self, cfg: C) -> Self::Future {
+        self.a.new_service((self.f)(cfg))
     }
 }
 
@@ -123,7 +120,7 @@ where
     type InitError = A::InitError;
     type Future = A::Future;
 
-    fn new_service(&self, _: &C) -> Self::Future {
-        self.a.new_service(&())
+    fn new_service(&self, _: C) -> Self::Future {
+        self.a.new_service(())
     }
 }

actix-service/src/map_err.rs

@@ -154,7 +154,7 @@ where
     type InitError = A::InitError;
     type Future = MapErrServiceFuture<A, F, E>;
 
-    fn new_service(&self, cfg: &A::Config) -> Self::Future {
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
         MapErrServiceFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }
@@ -199,7 +199,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use futures::future::{err, lazy, ok, Ready};
+    use futures_util::future::{err, lazy, ok, Ready};
 
     use super::*;
     use crate::{IntoServiceFactory, Service, ServiceFactory};
@@ -212,7 +212,7 @@ mod tests {
         type Error = ();
         type Future = Ready<Result<(), ()>>;
 
-        fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+        fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
             Poll::Ready(Err(()))
         }
 
@@ -221,14 +221,14 @@ mod tests {
         }
     }
 
-    #[tokio::test]
+    #[actix_rt::test]
     async fn test_poll_ready() {
         let mut srv = Srv.map_err(|_| "error");
         let res = lazy(|cx| srv.poll_ready(cx)).await;
         assert_eq!(res, Poll::Ready(Err("error")));
     }
 
-    #[tokio::test]
+    #[actix_rt::test]
     async fn test_call() {
         let mut srv = Srv.map_err(|_| "error");
         let res = srv.call(()).await;
@@ -236,7 +236,7 @@ mod tests {
         assert_eq!(res.err().unwrap(), "error");
     }
 
-    #[tokio::test]
+    #[actix_rt::test]
     async fn test_new_service() {
         let new_srv = (|| ok::<_, ()>(Srv)).into_factory().map_err(|_| "error");
         let mut srv = new_srv.new_service(&()).await.unwrap();

actix-service/src/map_init_err.rs

@@ -55,7 +55,7 @@ where
     type InitError = E;
     type Future = MapInitErrFuture<A, F, E>;
 
-    fn new_service(&self, cfg: &A::Config) -> Self::Future {
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
         MapInitErrFuture::new(self.a.new_service(cfg), self.f.clone())
     }
 }

actix-service/src/pipeline.rs

@@ -1,9 +1,15 @@
+use std::future::Future;
 use std::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.
 pub fn pipeline<F, T>(service: F) -> Pipeline<T>
 where
     F: IntoService<T>,
@@ -14,6 +20,7 @@ where
     }
 }
 
+/// Contruct new pipeline factory with one service factory.
 pub fn pipeline_factory<T, F>(factory: F) -> PipelineFactory<T>
 where
     T: ServiceFactory,
@@ -24,7 +31,7 @@ where
     }
 }
 
-/// Pipeline service
+/// Pipeline service - pipeline allows to compose multiple service into one service.
 pub struct Pipeline<T> {
     service: T,
 }
@@ -50,6 +57,28 @@ impl<T: Service> Pipeline<T> {
         }
     }
 
+    /// 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<AndThenApplyFn<T, U, F, Fut, Res, Err>>
+    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),
+        }
+    }
+
     /// Chain on a computation for when a call to the service finished,
     /// passing the result of the call to the next service `U`.
     ///
@@ -65,6 +94,43 @@ impl<T: Service> Pipeline<T> {
             service: ThenService::new(self.service, service.into_service()),
         }
     }
+
+    /// 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.
+    pub fn map<F, R>(self, f: F) -> Pipeline<Map<T, F, R>>
+    where
+        Self: Sized,
+        F: FnMut(T::Response) -> R,
+    {
+        Pipeline {
+            service: Map::new(self.service, 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. This is useful for example to
+    /// ensure that services have the same error type.
+    ///
+    /// 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>>
+    where
+        Self: Sized,
+        F: Fn(T::Error) -> E,
+    {
+        Pipeline {
+            service: MapErr::new(self.service, f),
+        }
+    }
 }
 
 impl<T> Clone for Pipeline<T>
@@ -95,7 +161,7 @@ impl<T: Service> Service for Pipeline<T> {
     }
 }
 
-/// Pipeline constructor
+/// Pipeline factory
 pub struct PipelineFactory<T> {
     factory: T,
 }
@@ -105,6 +171,7 @@ impl<T: ServiceFactory> PipelineFactory<T> {
     pub fn and_then<F, U>(self, factory: F) -> PipelineFactory<AndThenServiceFactory<T, U>>
     where
         Self: Sized,
+        T::Config: Clone,
         F: IntoServiceFactory<U>,
         U: ServiceFactory<
             Config = T::Config,
@@ -118,6 +185,29 @@ impl<T: ServiceFactory> PipelineFactory<T> {
         }
     }
 
+    /// 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<AndThenApplyFnFactory<T, U, F, Fut, Res, Err>>
+    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),
+        }
+    }
+
     /// Create `NewService` to chain on a computation for when a call to the
     /// service finished, passing the result of the call to the next
     /// service `U`.
@@ -127,6 +217,7 @@ impl<T: ServiceFactory> PipelineFactory<T> {
     pub fn then<F, U>(self, factory: F) -> PipelineFactory<ThenServiceFactory<T, U>>
     where
         Self: Sized,
+        T::Config: Clone,
         F: IntoServiceFactory<U>,
         U: ServiceFactory<
             Config = T::Config,
@@ -139,6 +230,40 @@ impl<T: ServiceFactory> PipelineFactory<T> {
             factory: ThenServiceFactory::new(self.factory, factory.into_factory()),
         }
     }
+
+    /// 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>>
+    where
+        Self: Sized,
+        F: FnMut(T::Response) -> R + Clone,
+    {
+        PipelineFactory {
+            factory: MapServiceFactory::new(self.factory, f),
+        }
+    }
+
+    /// 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>>
+    where
+        Self: Sized,
+        F: Fn(T::Error) -> E + Clone,
+    {
+        PipelineFactory {
+            factory: MapErrServiceFactory::new(self.factory, f),
+        }
+    }
+
+    /// 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>>
+    where
+        Self: Sized,
+        F: Fn(T::InitError) -> E + Clone,
+    {
+        PipelineFactory {
+            factory: MapInitErr::new(self.factory, f),
+        }
+    }
 }
 
 impl<T> Clone for PipelineFactory<T>
@@ -162,7 +287,7 @@ impl<T: ServiceFactory> ServiceFactory for PipelineFactory<T> {
     type Future = T::Future;
 
     #[inline]
-    fn new_service(&self, cfg: &T::Config) -> Self::Future {
+    fn new_service(&self, cfg: T::Config) -> Self::Future {
         self.factory.new_service(cfg)
     }
 }

actix-service/src/then.rs

@@ -57,7 +57,9 @@ where
     }
 
     fn call(&mut self, req: A::Request) -> Self::Future {
-        ThenServiceResponse::new(self.a.call(req), self.b.clone())
+        ThenServiceResponse {
+            state: State::A(self.a.call(req), Some(self.b.clone())),
+        }
     }
 }
 
@@ -67,25 +69,19 @@ where
     A: Service,
     B: Service<Request = Result<A::Response, A::Error>>,
 {
-    b: Cell<B>,
     #[pin]
-    fut_b: Option<B::Future>,
-    #[pin]
-    fut_a: Option<A::Future>,
+    state: State<A, B>,
 }
 
-impl<A, B> ThenServiceResponse<A, B>
+#[pin_project::pin_project]
+enum State<A, B>
 where
     A: Service,
     B: Service<Request = Result<A::Response, A::Error>>,
 {
-    fn new(a: A::Future, b: Cell<B>) -> Self {
-        ThenServiceResponse {
-            b,
-            fut_a: Some(a),
-            fut_b: None,
-        }
-    }
+    A(#[pin] A::Future, Option<Cell<B>>),
+    B(#[pin] B::Future),
+    Empty,
 }
 
 impl<A, B> Future for ThenServiceResponse<A, B>
@@ -95,27 +91,27 @@ where
 {
     type Output = Result<B::Response, B::Error>;
 
+    #[pin_project::project]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.as_mut().project();
 
-        loop {
-            if let Some(fut) = this.fut_b.as_pin_mut() {
-                return fut.poll(cx);
-            }
-
-            match this
-                .fut_a
-                .as_pin_mut()
-                .expect("Bug in actix-service")
-                .poll(cx)
-            {
-                Poll::Ready(r) => {
-                    this = self.as_mut().project();
-                    this.fut_b.set(Some(this.b.get_mut().call(r)));
+        #[project]
+        match this.state.as_mut().project() {
+            State::A(fut, b) => match fut.poll(cx) {
+                Poll::Ready(res) => {
+                    let mut b = b.take().unwrap();
+                    this.state.set(State::Empty); // drop fut A
+                    let fut = b.get_mut().call(res);
+                    this.state.set(State::B(fut));
+                    self.poll(cx)
                 }
-
-                Poll::Pending => return Poll::Pending,
-            }
+                Poll::Pending => Poll::Pending,
+            },
+            State::B(fut) => fut.poll(cx).map(|r| {
+                this.state.set(State::Empty);
+                r
+            }),
+            State::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
         }
     }
 }
@@ -129,6 +125,7 @@ pub struct ThenServiceFactory<A, B> {
 impl<A, B> ThenServiceFactory<A, B>
 where
     A: ServiceFactory,
+    A::Config: Clone,
     B: ServiceFactory<
         Config = A::Config,
         Request = Result<A::Response, A::Error>,
@@ -145,6 +142,7 @@ where
 impl<A, B> ServiceFactory for ThenServiceFactory<A, B>
 where
     A: ServiceFactory,
+    A::Config: Clone,
     B: ServiceFactory<
         Config = A::Config,
         Request = Result<A::Response, A::Error>,
@@ -161,8 +159,11 @@ where
     type InitError = A::InitError;
     type Future = ThenServiceFactoryResponse<A, B>;
 
-    fn new_service(&self, cfg: &A::Config) -> Self::Future {
-        ThenServiceFactoryResponse::new(self.a.new_service(cfg), self.b.new_service(cfg))
+    fn new_service(&self, cfg: A::Config) -> Self::Future {
+        ThenServiceFactoryResponse::new(
+            self.a.new_service(cfg.clone()),
+            self.b.new_service(cfg),
+        )
     }
 }
 
@@ -260,7 +261,7 @@ mod tests {
     use std::rc::Rc;
     use std::task::{Context, Poll};
 
-    use futures::future::{err, lazy, ok, ready, Ready};
+    use futures_util::future::{err, lazy, ok, ready, Ready};
 
     use crate::{pipeline, pipeline_factory, Service, ServiceFactory};
 
@@ -307,7 +308,7 @@ mod tests {
         }
     }
 
-    #[tokio::test]
+    #[actix_rt::test]
     async fn test_poll_ready() {
         let cnt = Rc::new(Cell::new(0));
         let mut srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt.clone()));
@@ -316,7 +317,7 @@ mod tests {
         assert_eq!(cnt.get(), 2);
     }
 
-    #[tokio::test]
+    #[actix_rt::test]
     async fn test_call() {
         let cnt = Rc::new(Cell::new(0));
         let mut srv = pipeline(Srv1(cnt.clone())).then(Srv2(cnt));
@@ -330,7 +331,7 @@ mod tests {
         assert_eq!(res.unwrap(), (("srv2", "err")));
     }
 
-    #[tokio::test]
+    #[actix_rt::test]
     async fn test_factory() {
         let cnt = Rc::new(Cell::new(0));
         let cnt2 = cnt.clone();

actix-service/src/transform.rs

@@ -4,25 +4,91 @@ use std::rc::Rc;
 use std::sync::Arc;
 use std::task::{Context, Poll};
 
+use crate::transform_err::TransformMapInitErr;
 use crate::{IntoServiceFactory, Service, ServiceFactory};
 
-/// Apply transform to a service. Function returns
-/// services factory that in initialization creates
-/// service and applies transform to this service.
-pub fn apply<T, S, U>(t: T, service: U) -> ApplyTransform<T, S>
+/// Apply transform to a service.
+pub fn apply<T, S, U>(t: T, factory: U) -> ApplyTransform<T, S>
 where
     S: ServiceFactory,
     T: Transform<S::Service, InitError = S::InitError>,
     U: IntoServiceFactory<S>,
 {
-    ApplyTransform::new(t, service.into_factory())
+    ApplyTransform::new(t, factory.into_factory())
 }
 
+/// The `Transform` trait defines the interface of a service factory that wraps inner service
+/// during construction.
+///
+/// Transform(middleware) wraps inner service and runs during
+/// inbound and/or outbound processing in the request/response lifecycle.
+/// It may modify request and/or response.
+///
+/// For example, timeout transform:
+///
+/// ```rust,ignore
+/// pub struct Timeout<S> {
+///     service: S,
+///     timeout: Duration,
+/// }
+///
+/// impl<S> Service for Timeout<S>
+/// where
+///     S: Service,
+/// {
+///     type Request = S::Request;
+///     type Response = S::Response;
+///     type Error = TimeoutError<S::Error>;
+///     type Future = TimeoutServiceResponse<S>;
+///
+///     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+///         ready!(self.service.poll_ready(cx)).map_err(TimeoutError::Service)
+///     }
+///
+///     fn call(&mut self, req: S::Request) -> Self::Future {
+///         TimeoutServiceResponse {
+///             fut: self.service.call(req),
+///             sleep: Delay::new(clock::now() + self.timeout),
+///         }
+///     }
+/// }
+/// ```
+///
+/// Timeout service in above example is decoupled from underlying service implementation
+/// and could be applied to any service.
+///
 /// The `Transform` trait defines the interface of a Service factory. `Transform`
 /// is often implemented for middleware, defining how to construct a
 /// middleware Service. A Service that is constructed by the factory takes
 /// the Service that follows it during execution as a parameter, assuming
 /// ownership of the next Service.
+///
+/// Factory for `Timeout` middleware from the above example could look like this:
+///
+/// ```rust,,ignore
+/// pub struct TimeoutTransform {
+///     timeout: Duration,
+/// }
+///
+/// impl<S> Transform<S> for TimeoutTransform<E>
+/// where
+///     S: Service,
+/// {
+///     type Request = S::Request;
+///     type Response = S::Response;
+///     type Error = TimeoutError<S::Error>;
+///     type InitError = S::Error;
+///     type Transform = Timeout<S>;
+///     type Future = Ready<Result<Self::Transform, Self::InitError>>;
+///
+///     fn new_transform(&self, service: S) -> Self::Future {
+///         ok(TimeoutService {
+///             service,
+///             timeout: self.timeout,
+///         })
+///     }
+/// }
+/// ```
 pub trait Transform<S> {
     /// Requests handled by the service.
     type Request;
@@ -40,14 +106,24 @@ pub trait Transform<S> {
         Error = Self::Error,
     >;
 
-    /// Errors produced while building a service.
+    /// Errors produced while building a transform service.
     type InitError;
 
     /// The future response value.
     type Future: Future<Output = Result<Self::Transform, Self::InitError>>;
 
-    /// Creates and returns a new Service component, asynchronously
+    /// 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,
+    /// returning a new transform service factory.
+    fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, F, E>
+    where
+        Self: Sized,
+        F: Fn(Self::InitError) -> E + Clone,
+    {
+        TransformMapInitErr::new(self, f)
+    }
 }
 
 impl<T, S> Transform<S> for Rc<T>
@@ -83,10 +159,7 @@ where
 }
 
 /// `Apply` transform to new service
-pub struct ApplyTransform<T, S> {
-    s: Rc<S>,
-    t: Rc<T>,
-}
+pub struct ApplyTransform<T, S>(Rc<(T, S)>);
 
 impl<T, S> ApplyTransform<T, S>
 where
@@ -95,19 +168,13 @@ where
 {
     /// Create new `ApplyTransform` new service instance
     fn new(t: T, service: S) -> Self {
-        Self {
-            s: Rc::new(service),
-            t: Rc::new(t),
-        }
+        Self(Rc::new((t, service)))
     }
 }
 
 impl<T, S> Clone for ApplyTransform<T, S> {
     fn clone(&self) -> Self {
-        ApplyTransform {
-            s: self.s.clone(),
-            t: self.t.clone(),
-        }
+        ApplyTransform(self.0.clone())
     }
 }
 
@@ -125,11 +192,10 @@ where
     type InitError = T::InitError;
     type Future = ApplyTransformFuture<T, S>;
 
-    fn new_service(&self, cfg: &S::Config) -> Self::Future {
+    fn new_service(&self, cfg: S::Config) -> Self::Future {
         ApplyTransformFuture {
-            t_cell: self.t.clone(),
-            fut_a: self.s.new_service(cfg),
-            fut_t: None,
+            store: self.0.clone(),
+            state: ApplyTransformFutureState::A(self.0.as_ref().1.new_service(cfg)),
         }
     }
 }
@@ -140,11 +206,19 @@ where
     S: ServiceFactory,
     T: Transform<S::Service, InitError = S::InitError>,
 {
+    store: Rc<(T, S)>,
     #[pin]
-    fut_a: S::Future,
-    #[pin]
-    fut_t: Option<T::Future>,
-    t_cell: Rc<T>,
+    state: ApplyTransformFutureState<T, S>,
+}
+
+#[pin_project::pin_project]
+pub enum ApplyTransformFutureState<T, S>
+where
+    S: ServiceFactory,
+    T: Transform<S::Service, InitError = S::InitError>,
+{
+    A(#[pin] S::Future),
+    B(#[pin] T::Future),
 }
 
 impl<T, S> Future for ApplyTransformFuture<T, S>
@@ -154,20 +228,21 @@ where
 {
     type Output = Result<T::Transform, T::InitError>;
 
+    #[pin_project::project]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.as_mut().project();
 
-        if let Some(fut) = this.fut_t.as_pin_mut() {
-            return fut.poll(cx);
-        }
-
-        if let Poll::Ready(service) = this.fut_a.poll(cx)? {
-            let fut = this.t_cell.new_transform(service);
-            this = self.as_mut().project();
-            this.fut_t.set(Some(fut));
-            this.fut_t.as_pin_mut().unwrap().poll(cx)
-        } else {
-            return Poll::Pending;
+        #[project]
+        match this.state.as_mut().project() {
+            ApplyTransformFutureState::A(fut) => match fut.poll(cx)? {
+                Poll::Ready(srv) => {
+                    let fut = this.store.0.new_transform(srv);
+                    this.state.set(ApplyTransformFutureState::B(fut));
+                    self.poll(cx)
+                }
+                Poll::Pending => Poll::Pending,
+            },
+            ApplyTransformFutureState::B(fut) => fut.poll(cx),
         }
     }
 }

actix-service/src/transform_err.rs

@@ -0,0 +1,93 @@
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use super::Transform;
+
+/// Transform for the `map_init_err` combinator, changing the type of a new
+/// transform's init error.
+///
+/// This is created by the `Transform::map_init_err` method.
+pub struct TransformMapInitErr<T, S, F, E> {
+    t: T,
+    f: F,
+    e: PhantomData<(S, E)>,
+}
+
+impl<T, S, F, E> TransformMapInitErr<T, S, F, E> {
+    pub(crate) fn new(t: T, f: F) -> Self
+    where
+        T: Transform<S>,
+        F: Fn(T::InitError) -> E,
+    {
+        Self {
+            t,
+            f,
+            e: PhantomData,
+        }
+    }
+}
+
+impl<T, S, F, E> Clone for TransformMapInitErr<T, S, F, E>
+where
+    T: Clone,
+    F: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            t: self.t.clone(),
+            f: self.f.clone(),
+            e: PhantomData,
+        }
+    }
+}
+
+impl<T, S, F, E> Transform<S> for TransformMapInitErr<T, S, F, E>
+where
+    T: Transform<S>,
+    F: Fn(T::InitError) -> E + Clone,
+{
+    type Request = T::Request;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Transform = T::Transform;
+
+    type InitError = E;
+    type Future = TransformMapInitErrFuture<T, S, F, E>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        TransformMapInitErrFuture {
+            fut: self.t.new_transform(service),
+            f: self.f.clone(),
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub struct TransformMapInitErrFuture<T, S, F, E>
+where
+    T: Transform<S>,
+    F: Fn(T::InitError) -> E,
+{
+    #[pin]
+    fut: T::Future,
+    f: F,
+}
+
+impl<T, S, F, E> Future for TransformMapInitErrFuture<T, S, F, E>
+where
+    T: Transform<S>,
+    F: Fn(T::InitError) -> E + Clone,
+{
+    type Output = Result<T::Transform, E>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+        if let Poll::Ready(res) = this.fut.poll(cx) {
+            Poll::Ready(res.map_err(this.f))
+        } else {
+            Poll::Pending
+        }
+    }
+}

actix-test-server/Cargo.toml

@@ -1,60 +0,0 @@
-[package]
-name = "actix-test-server"
-version = "0.2.2"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix test server"
-keywords = ["network", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-test-server/"
-categories = ["network-programming", "asynchronous"]
-license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
-edition = "2018"
-workspace = ".."
-
-[package.metadata.docs.rs]
-features = ["ssl", "tls", "rust-tls"]
-
-[lib]
-name = "actix_test_server"
-path = "src/lib.rs"
-
-[features]
-default = []
-
-# tls
-tls = ["native-tls", "actix-server/tls"]
-
-# openssl
-ssl = ["openssl", "actix-server/ssl"]
-
-# rustls
-rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
-
-[dependencies]
-actix-rt = "0.2.1"
-actix-server = "0.5.0"
-actix-server-config = "0.2.0"
-actix-testing = "0.1.0"
-
-log = "0.4"
-net2 = "0.2"
-futures = { package = "futures-preview", version = "0.3.0-alpha.18"}
-tokio-io = "0.2.0-alpha.4"
-tokio-net = "0.2.0-alpha.4"
-
-# native-tls
-native-tls = { version="0.2", optional = true }
-
-# openssl
-openssl = { version="0.10", optional = true }
-
-#rustls
-rustls = { version = "^0.16", optional = true }
-tokio-rustls = { version = "^0.12.0-alpha.2", optional = true }
-webpki = { version = "0.21", optional = true }
-webpki-roots = { version = "0.17", optional = true }
-
-[dev-dependencies]
-actix-service = "0.4.0"

actix-test-server/README.md

@@ -1,3 +0,0 @@
-# Actix test server (Deprecated)
-
-Use [actix-testing](https://docs.rs/actix-testing/) instead

actix-test-server/src/lib.rs

@@ -1,149 +0,0 @@
-//! Various helpers for Actix applications to use during testing.
-use std::sync::mpsc;
-use std::{net, thread};
-
-use actix_rt::{Runtime, System};
-use actix_server::{Server, StreamServiceFactory};
-pub use actix_server_config::{Io, ServerConfig};
-
-use futures::future::{lazy, Future, IntoFuture};
-use net2::TcpBuilder;
-use tokio_reactor::Handle;
-use tokio_tcp::TcpStream;
-
-/// The `TestServer` type.
-///
-/// `TestServer` is very simple test server that simplify process of writing
-/// integration tests for actix-net applications.
-///
-/// # Examples
-///
-/// ```rust
-/// use actix_service::{service_fn, IntoNewService};
-/// use actix_test_server::TestServer;
-///
-/// fn main() {
-///     let srv = TestServer::with(|| service_fn(
-///         |sock| {
-///             println!("New connection: {:?}", sock);
-///             Ok::<_, ()>(())
-///         }
-///     ));
-///
-///     println!("SOCKET: {:?}", srv.connect());
-/// }
-/// ```
-pub struct TestServer;
-
-/// Test server runstime
-pub struct TestServerRuntime {
-    addr: net::SocketAddr,
-    host: String,
-    port: u16,
-    rt: Runtime,
-}
-
-impl TestServer {
-    /// Start new test server with application factory
-    pub fn with<F: StreamServiceFactory>(factory: F) -> TestServerRuntime {
-        let (tx, rx) = mpsc::channel();
-
-        // run server in separate thread
-        thread::spawn(move || {
-            let sys = System::new("actix-test-server");
-            let tcp = net::TcpListener::bind("127.0.0.1:0").unwrap();
-            let local_addr = tcp.local_addr().unwrap();
-
-            Server::build()
-                .listen("test", tcp, factory)?
-                .workers(1)
-                .disable_signals()
-                .start();
-
-            tx.send((System::current(), local_addr)).unwrap();
-            sys.run()
-        });
-
-        let (system, addr) = rx.recv().unwrap();
-        System::set_current(system);
-
-        let rt = Runtime::new().unwrap();
-        let host = format!("{}", addr.ip());
-        let port = addr.port();
-
-        TestServerRuntime {
-            addr,
-            rt,
-            host,
-            port,
-        }
-    }
-
-    /// Get firat available unused local address
-    pub fn unused_addr() -> net::SocketAddr {
-        let addr: net::SocketAddr = "127.0.0.1:0".parse().unwrap();
-        let socket = TcpBuilder::new_v4().unwrap();
-        socket.bind(&addr).unwrap();
-        socket.reuse_address(true).unwrap();
-        let tcp = socket.to_tcp_listener().unwrap();
-        tcp.local_addr().unwrap()
-    }
-}
-
-impl TestServerRuntime {
-    /// Execute future on current runtime
-    pub fn block_on<F, I, E>(&mut self, fut: F) -> Result<I, E>
-    where
-        F: Future<Item = I, Error = E>,
-    {
-        self.rt.block_on(fut)
-    }
-
-    /// Runs the provided function, with runtime enabled.
-    pub fn run_on<F, R>(&mut self, f: F) -> Result<R::Item, R::Error>
-    where
-        F: FnOnce() -> R,
-        R: IntoFuture,
-    {
-        self.rt.block_on(lazy(|| f().into_future()))
-    }
-
-    /// Spawn future to the current runtime
-    pub fn spawn<F>(&mut self, fut: F)
-    where
-        F: Future<Item = (), Error = ()> + 'static,
-    {
-        self.rt.spawn(fut);
-    }
-
-    /// Test server host
-    pub fn host(&self) -> &str {
-        &self.host
-    }
-
-    /// Test server port
-    pub fn port(&self) -> u16 {
-        self.port
-    }
-
-    /// Get test server address
-    pub fn addr(&self) -> net::SocketAddr {
-        self.addr
-    }
-
-    /// Stop http server
-    fn stop(&mut self) {
-        System::current().stop();
-    }
-
-    /// Connect to server, return tokio TcpStream
-    pub fn connect(&self) -> std::io::Result<TcpStream> {
-        TcpStream::from_std(net::TcpStream::connect(self.addr)?, &Handle::default())
-    }
-}
-
-impl Drop for TestServerRuntime {
-    fn drop(&mut self) {
-        self.stop()
-    }
-}

actix-testing/CHANGES.md

@@ -1,5 +1,22 @@
 # Changes
 
+## [1.0.0] - 2019-12-11
+
+* Update actix-server to 1.0.0
+
+## [1.0.0-alpha.3] - 2019-12-07
+
+* Migrate to tokio 0.2
+
+## [1.0.0-alpha.2] - 2019-12-02
+
+* Re-export `test` attribute macros
+
+
+## [0.3.0-alpha.1] - 2019-11-22
+
+* Migrate to std::future
+
 ## [0.2.0] - 2019-10-14
 
 * Upgrade actix-server and actix-server-config deps

actix-testing/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-testing"
-version = "0.3.0-alpha.1"
+version = "1.0.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix testing utils"
 keywords = ["network", "framework", "async", "futures"]
@@ -17,13 +17,11 @@ name = "actix_testing"
 path = "src/lib.rs"
 
 [dependencies]
-actix-rt = "1.0.0-alpha.1"
-actix-server = "0.8.0-alpha.1"
-actix-server-config = "0.3.0-alpha.1"
-actix-service = "1.0.0-alpha.1"
+actix-rt = "1.0.0"
+actix-macros = "0.1.0"
+actix-server = "1.0.0"
+actix-service = "1.0.0"
 
 log = "0.4"
 net2 = "0.2"
 futures = "0.3.1"
-tokio = "0.2.0-alpha.6"
-tokio-net = { version = "0.2.0-alpha.6" }

actix-testing/src/lib.rs

@@ -1,17 +1,16 @@
 //! Various helpers for Actix applications to use during testing.
+#![deny(rust_2018_idioms, warnings)]
+#![allow(clippy::type_complexity)]
+
 use std::sync::mpsc;
 use std::{net, thread};
 
-use actix_rt::System;
+use actix_rt::{net::TcpStream, System};
 use actix_server::{Server, ServerBuilder, ServiceFactory};
-pub use actix_server_config::{Io, ServerConfig};
-
 use net2::TcpBuilder;
-use tokio_net::driver::Handle;
-use tokio_net::tcp::TcpStream;
 
-mod rt;
-pub use self::rt::*;
+#[cfg(not(test))] // Work around for rust-lang/rust#62127
+pub use actix_macros::test;
 
 /// The `TestServer` type.
 ///
@@ -21,11 +20,12 @@ pub use self::rt::*;
 /// # Examples
 ///
 /// ```rust
-/// use actix_service::{service_fn};
+/// use actix_service::fn_service;
 /// use actix_testing::TestServer;
 ///
-/// fn main() {
-///     let srv = TestServer::with(|| service_fn(
+/// #[actix_rt::main]
+/// async fn main() {
+///     let srv = TestServer::with(|| fn_service(
 ///         |sock| async move {
 ///             println!("New connection: {:?}", sock);
 ///             Ok::<_, ()>(())
@@ -47,7 +47,7 @@ pub struct TestServerRuntime {
 
 impl TestServer {
     /// Start new server with server builder
-    pub fn new<F>(mut factory: F) -> TestServerRuntime
+    pub fn start<F>(mut factory: F) -> TestServerRuntime
     where
         F: FnMut(ServerBuilder) -> ServerBuilder + Send + 'static,
     {
@@ -141,7 +141,7 @@ impl TestServerRuntime {
 
     /// Connect to server, return tokio TcpStream
     pub fn connect(&self) -> std::io::Result<TcpStream> {
-        TcpStream::from_std(net::TcpStream::connect(self.addr)?, &Handle::default())
+        TcpStream::from_std(net::TcpStream::connect(self.addr)?)
     }
 }
 

actix-testing/src/rt.rs

@@ -1,117 +0,0 @@
-//! Various helpers for Actix applications to use during testing.
-use std::cell::RefCell;
-use std::future::Future;
-
-use actix_rt::{System, SystemRunner};
-use actix_service::Service;
-use futures::future::{lazy, FutureExt};
-// use futures_util::future::FutureExt;
-
-thread_local! {
-    static RT: RefCell<Inner> = {
-        RefCell::new(Inner(Some(System::builder().build())))
-    };
-}
-
-struct Inner(Option<SystemRunner>);
-
-impl Inner {
-    fn get_mut(&mut self) -> &mut SystemRunner {
-        self.0.as_mut().unwrap()
-    }
-}
-
-impl Drop for Inner {
-    fn drop(&mut self) {
-        std::mem::forget(self.0.take().unwrap())
-    }
-}
-
-/// Runs the provided future, blocking the current thread until the future
-/// completes.
-///
-/// This function can be used to synchronously block the current thread
-/// until the provided `future` has resolved either successfully or with an
-/// error. The result of the future is then returned from this function
-/// call.
-///
-/// Note that this function is intended to be used only for testing purpose.
-/// This function panics on nested call.
-pub fn block_on<F>(f: F) -> F::Output
-where
-    F: Future,
-{
-    RT.with(move |rt| rt.borrow_mut().get_mut().block_on(f))
-}
-
-/// Runs the provided function, blocking the current thread until the result
-/// future completes.
-///
-/// This function can be used to synchronously block the current thread
-/// until the provided `future` has resolved either successfully or with an
-/// error. The result of the future is then returned from this function
-/// call.
-///
-/// Note that this function is intended to be used only for testing purpose.
-/// This function panics on nested call.
-pub fn block_fn<F, R>(f: F) -> R::Output
-where
-    F: FnOnce() -> R,
-    R: Future,
-{
-    RT.with(move |rt| {
-        let mut rt = rt.borrow_mut();
-        let fut = rt.get_mut().block_on(lazy(|_| f()));
-        rt.get_mut().block_on(fut)
-    })
-}
-
-/// Spawn future to the current test runtime.
-pub fn spawn<F>(fut: F)
-where
-    F: Future + 'static,
-{
-    run_on(move || {
-        actix_rt::spawn(fut.map(|_| ()));
-    });
-}
-
-/// Runs the provided function, with runtime enabled.
-///
-/// Note that this function is intended to be used only for testing purpose.
-/// This function panics on nested call.
-pub fn run_on<F, R>(f: F) -> R
-where
-    F: FnOnce() -> R,
-{
-    RT.with(move |rt| rt.borrow_mut().get_mut().block_on(lazy(|_| f())))
-}
-
-/// Calls service and waits for response future completion.
-///
-/// ```rust,ignore
-/// use actix_web::{test, App, HttpResponse, http::StatusCode};
-/// use actix_service::Service;
-///
-/// #[test]
-/// fn test_response() {
-///     let mut app = test::init_service(
-///         App::new()
-///             .service(web::resource("/test").to(|| HttpResponse::Ok()))
-///     );
-///
-///     // Create request object
-///     let req = test::TestRequest::with_uri("/test").to_request();
-///
-///     // Call application
-///     let resp = test::call_service(&mut app, req);
-///     assert_eq!(resp.status(), StatusCode::OK);
-/// }
-/// ```
-pub fn call_service<S, R>(app: &mut S, req: R) -> S::Response
-where
-    S: Service<Request = R>,
-    S::Error: std::fmt::Debug,
-{
-    block_on(run_on(move || app.call(req))).unwrap()
-}

actix-threadpool/CHANGES.md

@@ -1,5 +1,17 @@
 # Changes
 
+## [0.3.1] - 2019-12-12
+
+### Changed
+
+* Use parking_lot 0.10
+
+## [0.3.0] - 2019-12-02
+
+### Changed
+
+* Expect `Result` type as a function return type
+
 ## [0.2.0] - 2019-11-21
 
 ### Changed

actix-threadpool/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-threadpool"
-version = "0.2.0"
+version = "0.3.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix thread pool for sync code"
 keywords = ["actix", "network", "framework", "async", "futures"]
@@ -18,10 +18,10 @@ name = "actix_threadpool"
 path = "src/lib.rs"
 
 [dependencies]
-derive_more = "0.15"
-futures = "0.3.1"
-parking_lot = "0.9"
-lazy_static = "1.2"
+derive_more = "0.99.2"
+futures-channel = "0.3.1"
+parking_lot = "0.10"
+lazy_static = "1.3"
 log = "0.4"
 num_cpus = "1.10"
 threadpool = "1.7"

actix-threadpool/src/lib.rs

@@ -1,15 +1,15 @@
 //! Thread pool for blocking operations
 
+use std::fmt;
 use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-use futures::channel::oneshot;
+use derive_more::Display;
+use futures_channel::oneshot;
 use parking_lot::Mutex;
 use threadpool::ThreadPool;
 
-pub use futures::channel::oneshot::Canceled;
-
 /// Env variable for default cpu pool size.
 const ENV_CPU_POOL_VAR: &str = "ACTIX_THREADPOOL";
 
@@ -39,12 +39,22 @@ thread_local! {
     };
 }
 
+/// Blocking operation execution error
+#[derive(Debug, Display)]
+pub enum BlockingError<E: fmt::Debug> {
+    #[display(fmt = "{:?}", _0)]
+    Error(E),
+    #[display(fmt = "Thread pool is gone")]
+    Canceled,
+}
+
 /// Execute blocking function on a thread pool, returns future that resolves
 /// to result of the function execution.
-pub fn run<F, I>(f: F) -> CpuFuture<I>
+pub fn run<F, I, E>(f: F) -> CpuFuture<I, E>
 where
-    F: FnOnce() -> I + Send + 'static,
+    F: FnOnce() -> Result<I, E> + Send + 'static,
     I: Send + 'static,
+    E: Send + fmt::Debug + 'static,
 {
     let (tx, rx) = oneshot::channel();
     POOL.with(|pool| {
@@ -60,16 +70,21 @@ where
 
 /// Blocking operation completion future. It resolves with results
 /// of blocking function execution.
-pub struct CpuFuture<I> {
-    rx: oneshot::Receiver<I>,
+pub struct CpuFuture<I, E> {
+    rx: oneshot::Receiver<Result<I, E>>,
 }
 
-impl<I> Future for CpuFuture<I> {
-    type Output = Result<I, Canceled>;
+impl<I, E: fmt::Debug> Future for CpuFuture<I, E> {
+    type Output = Result<I, BlockingError<E>>;
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let rx = Pin::new(&mut Pin::get_mut(self).rx);
-        let res = futures::ready!(rx.poll(cx));
-        Poll::Ready(res.map_err(|_| Canceled))
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let rx = Pin::new(&mut self.rx);
+        let res = match rx.poll(cx) {
+            Poll::Pending => return Poll::Pending,
+            Poll::Ready(res) => res
+                .map_err(|_| BlockingError::Canceled)
+                .and_then(|res| res.map_err(BlockingError::Error)),
+        };
+        Poll::Ready(res)
     }
 }

actix-tls/CHANGES.md

@@ -0,0 +1,19 @@
+# Changes
+
+## [1.0.0] - 2019-12-11
+
+* 1.0.0 release
+
+## [1.0.0-alpha.3] - 2019-12-07
+
+### Changed
+
+* Migrate to tokio 0.2
+
+* Enable rustls acceptor service
+
+* Enable native-tls acceptor service
+
+## [1.0.0-alpha.1] - 2019-12-02
+
+* Split openssl accetor from actix-server package

actix-tls/Cargo.toml

@@ -0,0 +1,60 @@
+[package]
+name = "actix-tls"
+version = "1.0.0"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix tls services"
+keywords = ["network", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-net.git"
+documentation = "https://docs.rs/actix-tls/"
+categories = ["network-programming", "asynchronous"]
+license = "MIT/Apache-2.0"
+edition = "2018"
+workspace = ".."
+
+[package.metadata.docs.rs]
+features = ["openssl", "rustls", "nativetls"]
+
+[lib]
+name = "actix_tls"
+path = "src/lib.rs"
+
+[features]
+default = []
+
+# openssl
+openssl = ["open-ssl", "tokio-openssl"]
+
+# rustls
+rustls = ["rust-tls", "webpki", "webpki-roots", "tokio-rustls"]
+
+# nativetls
+nativetls = ["native-tls", "tokio-tls"]
+
+[dependencies]
+actix-service = "1.0.0"
+actix-codec = "0.2.0"
+actix-utils = "1.0.0"
+actix-rt = "1.0.0"
+derive_more = "0.99.2"
+either = "1.5.2"
+futures = "0.3.1"
+log = "0.4"
+
+# openssl
+open-ssl = { version="0.10", package = "openssl", optional = true }
+tokio-openssl = { version = "0.4.0", optional = true }
+
+# rustls
+rust-tls = { version = "0.16.0", package = "rustls", optional = true }
+webpki = { version = "0.21", optional = true }
+webpki-roots = { version = "0.17", optional = true }
+tokio-rustls = { version = "0.12.0", optional = true }
+
+# native-tls
+native-tls = { version="0.2", optional = true }
+tokio-tls = { version="0.3", optional = true }
+
+[dev-dependencies]
+bytes = "0.5"
+actix-testing = { version="1.0.0" }

actix-tls/src/lib.rs

@@ -1,22 +1,19 @@
 //! SSL Services
+#![deny(rust_2018_idioms, warnings)]
+#![allow(clippy::type_complexity)]
+
 use std::sync::atomic::{AtomicUsize, Ordering};
 
-use crate::counter::Counter;
+use actix_utils::counter::Counter;
 
 #[cfg(feature = "openssl")]
-mod openssl;
-#[cfg(feature = "openssl")]
-pub use self::openssl::OpensslAcceptor;
-
-#[cfg(feature = "nativetls")]
-mod nativetls;
-#[cfg(feature = "nativetls")]
-pub use self::nativetls::NativeTlsAcceptor;
+pub mod openssl;
 
 #[cfg(feature = "rustls")]
-mod rustls;
-#[cfg(feature = "rustls")]
-pub use self::rustls::RustlsAcceptor;
+pub mod rustls;
+
+#[cfg(feature = "nativetls")]
+pub mod nativetls;
 
 /// Sets the maximum per-worker concurrent ssl connection establish process.
 ///

actix-tls/src/nativetls.rs

@@ -1,26 +1,24 @@
-use std::convert::Infallible;
 use std::marker::PhantomData;
 use std::task::{Context, Poll};
 
+use actix_codec::{AsyncRead, AsyncWrite};
 use actix_service::{Service, ServiceFactory};
-use futures::future::{self, FutureExt as _, LocalBoxFuture, TryFutureExt as _};
-use native_tls::Error;
-use tokio::io::{AsyncRead, AsyncWrite};
-use tokio_tls::{TlsAcceptor, TlsStream};
+use actix_utils::counter::Counter;
+use futures::future::{self, FutureExt, LocalBoxFuture, TryFutureExt};
+pub use native_tls::Error;
+pub use tokio_tls::{TlsAcceptor, TlsStream};
 
-use crate::counter::Counter;
-use crate::ssl::MAX_CONN_COUNTER;
-use crate::{Io, ServerConfig};
+use crate::MAX_CONN_COUNTER;
 
 /// Support `SSL` connections via native-tls package
 ///
 /// `tls` feature enables `NativeTlsAcceptor` type
-pub struct NativeTlsAcceptor<T, P = ()> {
+pub struct NativeTlsAcceptor<T> {
     acceptor: TlsAcceptor,
-    io: PhantomData<(T, P)>,
+    io: PhantomData<T>,
 }
 
-impl<T, P> NativeTlsAcceptor<T, P>
+impl<T> NativeTlsAcceptor<T>
 where
     T: AsyncRead + AsyncWrite + Unpin,
 {
@@ -34,7 +32,7 @@ where
     }
 }
 
-impl<T, P> Clone for NativeTlsAcceptor<T, P> {
+impl<T> Clone for NativeTlsAcceptor<T> {
     #[inline]
     fn clone(&self) -> Self {
         Self {
@@ -44,23 +42,20 @@ impl<T, P> Clone for NativeTlsAcceptor<T, P> {
     }
 }
 
-impl<T, P> ServiceFactory for NativeTlsAcceptor<T, P>
+impl<T> ServiceFactory for NativeTlsAcceptor<T>
 where
     T: AsyncRead + AsyncWrite + Unpin + 'static,
-    P: 'static,
 {
-    type Request = Io<T, P>;
-    type Response = Io<TlsStream<T>, P>;
+    type Request = T;
+    type Response = TlsStream<T>;
     type Error = Error;
+    type Service = NativeTlsAcceptorService<T>;
 
-    type Config = ServerConfig;
-    type Service = NativeTlsAcceptorService<T, P>;
-    type InitError = Infallible;
+    type Config = ();
+    type InitError = ();
     type Future = future::Ready<Result<Self::Service, Self::InitError>>;
 
-    fn new_service(&self, cfg: &ServerConfig) -> Self::Future {
-        cfg.set_secure();
-
+    fn new_service(&self, _: ()) -> Self::Future {
         MAX_CONN_COUNTER.with(|conns| {
             future::ok(NativeTlsAcceptorService {
                 acceptor: self.acceptor.clone(),
@@ -71,13 +66,13 @@ where
     }
 }
 
-pub struct NativeTlsAcceptorService<T, P> {
+pub struct NativeTlsAcceptorService<T> {
     acceptor: TlsAcceptor,
-    io: PhantomData<(T, P)>,
+    io: PhantomData<T>,
     conns: Counter,
 }
 
-impl<T, P> Clone for NativeTlsAcceptorService<T, P> {
+impl<T> Clone for NativeTlsAcceptorService<T> {
     fn clone(&self) -> Self {
         Self {
             acceptor: self.acceptor.clone(),
@@ -87,15 +82,14 @@ impl<T, P> Clone for NativeTlsAcceptorService<T, P> {
     }
 }
 
-impl<T, P> Service for NativeTlsAcceptorService<T, P>
+impl<T> Service for NativeTlsAcceptorService<T>
 where
     T: AsyncRead + AsyncWrite + Unpin + 'static,
-    P: 'static,
 {
-    type Request = Io<T, P>;
-    type Response = Io<TlsStream<T>, P>;
+    type Request = T;
+    type Response = TlsStream<T>;
     type Error = Error;
-    type Future = LocalBoxFuture<'static, Result<Io<TlsStream<T>, P>, Error>>;
+    type Future = LocalBoxFuture<'static, Result<TlsStream<T>, Error>>;
 
     fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
         if self.conns.available(cx) {
@@ -108,9 +102,7 @@ where
     fn call(&mut self, req: Self::Request) -> Self::Future {
         let guard = self.conns.get();
         let this = self.clone();
-        let (io, params, proto) = req.into_parts();
-        async move { this.acceptor.accept(io).await }
-            .map_ok(move |stream| Io::from_parts(stream, params, proto))
+        async move { this.acceptor.accept(req).await }
             .map_ok(move |io| {
                 // Required to preserve `CounterGuard` until `Self::Future`
                 // is completely resolved.

actix-tls/src/openssl.rs

@@ -0,0 +1,111 @@
+use std::future::Future;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+pub use open_ssl::ssl::{AlpnError, SslAcceptor, SslAcceptorBuilder};
+pub use tokio_openssl::{HandshakeError, SslStream};
+
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_service::{Service, ServiceFactory};
+use actix_utils::counter::{Counter, CounterGuard};
+use futures::future::{ok, FutureExt, LocalBoxFuture, Ready};
+
+use crate::MAX_CONN_COUNTER;
+
+/// Support `TLS` server connections via openssl package
+///
+/// `openssl` feature enables `Acceptor` type
+pub struct Acceptor<T: AsyncRead + AsyncWrite> {
+    acceptor: SslAcceptor,
+    io: PhantomData<T>,
+}
+
+impl<T: AsyncRead + AsyncWrite> Acceptor<T> {
+    /// Create default `OpensslAcceptor`
+    pub fn new(acceptor: SslAcceptor) -> Self {
+        Acceptor {
+            acceptor,
+            io: PhantomData,
+        }
+    }
+}
+
+impl<T: AsyncRead + AsyncWrite> Clone for Acceptor<T> {
+    fn clone(&self) -> Self {
+        Self {
+            acceptor: self.acceptor.clone(),
+            io: PhantomData,
+        }
+    }
+}
+
+impl<T: AsyncRead + AsyncWrite + Unpin + 'static> ServiceFactory for Acceptor<T> {
+    type Request = T;
+    type Response = SslStream<T>;
+    type Error = HandshakeError<T>;
+    type Config = ();
+    type Service = AcceptorService<T>;
+    type InitError = ();
+    type Future = Ready<Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        MAX_CONN_COUNTER.with(|conns| {
+            ok(AcceptorService {
+                acceptor: self.acceptor.clone(),
+                conns: conns.clone(),
+                io: PhantomData,
+            })
+        })
+    }
+}
+
+pub struct AcceptorService<T> {
+    acceptor: SslAcceptor,
+    conns: Counter,
+    io: PhantomData<T>,
+}
+
+impl<T: AsyncRead + AsyncWrite + Unpin + 'static> Service for AcceptorService<T> {
+    type Request = T;
+    type Response = SslStream<T>;
+    type Error = HandshakeError<T>;
+    type Future = AcceptorServiceResponse<T>;
+
+    fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        if self.conns.available(ctx) {
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        let acc = self.acceptor.clone();
+        AcceptorServiceResponse {
+            _guard: self.conns.get(),
+            fut: async move {
+                let acc = acc;
+                tokio_openssl::accept(&acc, req).await
+            }
+            .boxed_local(),
+        }
+    }
+}
+
+pub struct AcceptorServiceResponse<T>
+where
+    T: AsyncRead + AsyncWrite,
+{
+    fut: LocalBoxFuture<'static, Result<SslStream<T>, HandshakeError<T>>>,
+    _guard: CounterGuard,
+}
+
+impl<T: AsyncRead + AsyncWrite + Unpin> Future for AcceptorServiceResponse<T> {
+    type Output = Result<SslStream<T>, HandshakeError<T>>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let io = futures::ready!(Pin::new(&mut self.fut).poll(cx))?;
+        Poll::Ready(Ok(io))
+    }
+}

actix-tls/src/rustls.rs

@@ -0,0 +1,117 @@
+use std::future::Future;
+use std::io;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+
+use actix_codec::{AsyncRead, AsyncWrite};
+use actix_service::{Service, ServiceFactory};
+use actix_utils::counter::{Counter, CounterGuard};
+use futures::future::{ok, Ready};
+use tokio_rustls::{Accept, TlsAcceptor};
+
+pub use rust_tls::{ServerConfig, Session};
+pub use tokio_rustls::server::TlsStream;
+pub use webpki_roots::TLS_SERVER_ROOTS;
+
+use crate::MAX_CONN_COUNTER;
+
+/// Support `SSL` connections via rustls package
+///
+/// `rust-tls` feature enables `RustlsAcceptor` type
+pub struct Acceptor<T> {
+    config: Arc<ServerConfig>,
+    io: PhantomData<T>,
+}
+
+impl<T: AsyncRead + AsyncWrite> Acceptor<T> {
+    /// Create rustls based `Acceptor` service factory
+    pub fn new(config: ServerConfig) -> Self {
+        Acceptor {
+            config: Arc::new(config),
+            io: PhantomData,
+        }
+    }
+}
+
+impl<T> Clone for Acceptor<T> {
+    fn clone(&self) -> Self {
+        Self {
+            config: self.config.clone(),
+            io: PhantomData,
+        }
+    }
+}
+
+impl<T: AsyncRead + AsyncWrite + Unpin> ServiceFactory for Acceptor<T> {
+    type Request = T;
+    type Response = TlsStream<T>;
+    type Error = io::Error;
+    type Service = AcceptorService<T>;
+
+    type Config = ();
+    type InitError = ();
+    type Future = Ready<Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        MAX_CONN_COUNTER.with(|conns| {
+            ok(AcceptorService {
+                acceptor: self.config.clone().into(),
+                conns: conns.clone(),
+                io: PhantomData,
+            })
+        })
+    }
+}
+
+/// RusTLS based `Acceptor` service
+pub struct AcceptorService<T> {
+    acceptor: TlsAcceptor,
+    io: PhantomData<T>,
+    conns: Counter,
+}
+
+impl<T: AsyncRead + AsyncWrite + Unpin> Service for AcceptorService<T> {
+    type Request = T;
+    type Response = TlsStream<T>;
+    type Error = io::Error;
+    type Future = AcceptorServiceFut<T>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        if self.conns.available(cx) {
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        AcceptorServiceFut {
+            _guard: self.conns.get(),
+            fut: self.acceptor.accept(req),
+        }
+    }
+}
+
+pub struct AcceptorServiceFut<T>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+{
+    fut: Accept<T>,
+    _guard: CounterGuard,
+}
+
+impl<T: AsyncRead + AsyncWrite + Unpin> Future for AcceptorServiceFut<T> {
+    type Output = Result<TlsStream<T>, io::Error>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.get_mut();
+
+        let res = futures::ready!(Pin::new(&mut this.fut).poll(cx));
+        match res {
+            Ok(io) => Poll::Ready(Ok(io)),
+            Err(e) => Poll::Ready(Err(e)),
+        }
+    }
+}

actix-utils/CHANGES.md

@@ -1,5 +1,37 @@
 # Changes
 
+## [1.0.4] - 2019-12-20
+
+* Add methods to check `LocalWaker` registration state.
+
+## [1.0.3] - 2019-12-11
+
+* Revert InOrder service changes
+
+## [1.0.2] - 2019-12-11
+
+* Allow to create `framed::Dispatcher` with custom `mpsc::Receiver`
+
+* Add `oneshot::Sender::is_canceled()` method
+
+## [1.0.1] - 2019-12-11
+
+* Optimize InOrder service
+
+## [1.0.0] - 2019-12-11
+
+* Simplify oneshot and mpsc implementations
+
+## [1.0.0-alpha.3] - 2019-12-07
+
+* Migrate to tokio 0.2
+
+* Fix oneshot
+
+## [1.0.0-alpha.2] - 2019-12-02
+
+* Migrate to `std::future`
+
 ## [0.4.7] - 2019-10-14
 
 * Re-register task on every framed transport poll.

actix-utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-utils"
-version = "0.5.0-alpha1"
+version = "1.0.4"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix utils - various actix net related services"
 keywords = ["network", "framework", "async", "futures"]
@@ -9,24 +9,18 @@ repository = "https://github.com/actix/actix-net.git"
 documentation = "https://docs.rs/actix-utils/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"
-workspace = ".."
 
 [lib]
 name = "actix_utils"
 path = "src/lib.rs"
 
 [dependencies]
-actix-service = "1.0.0-alpha.1"
-actix-codec = "0.2.0-alpha.1"
-bytes = "0.4"
-either = "1.5.2"
+actix-service = "1.0.0"
+actix-rt = "1.0.0"
+actix-codec = "0.2.0"
+bytes = "0.5.3"
+either = "1.5.3"
 futures = "0.3.1"
-pin-project = "0.4.5"
-tokio-timer = "0.3.0-alpha.6"
-tokio-executor = { version="=0.2.0-alpha.6", features=["current-thread"] }
+pin-project = "0.4.6"
 log = "0.4"
-
-[dev-dependencies]
-actix-rt = "1.0.0-alpha.1"

actix-utils/src/cell.rs

@@ -5,7 +5,7 @@ use std::fmt;
 use std::rc::Rc;
 
 pub(crate) struct Cell<T> {
-    inner: Rc<UnsafeCell<T>>,
+    pub(crate) inner: Rc<UnsafeCell<T>>,
 }
 
 impl<T> Clone for Cell<T> {
@@ -17,23 +17,32 @@ impl<T> Clone for Cell<T> {
 }
 
 impl<T: fmt::Debug> fmt::Debug for Cell<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.inner.fmt(f)
     }
 }
 
 impl<T> Cell<T> {
-    pub fn new(inner: T) -> Self {
+    pub(crate) fn new(inner: T) -> Self {
         Self {
             inner: Rc::new(UnsafeCell::new(inner)),
         }
     }
 
-    pub fn get_ref(&self) -> &T {
+    pub(crate) fn strong_count(&self) -> usize {
+        Rc::strong_count(&self.inner)
+    }
+
+    pub(crate) fn get_ref(&self) -> &T {
         unsafe { &*self.inner.as_ref().get() }
     }
 
-    pub fn get_mut(&mut self) -> &mut T {
+    pub(crate) fn get_mut(&mut self) -> &mut T {
         unsafe { &mut *self.inner.as_ref().get() }
     }
+
+    #[allow(clippy::mut_from_ref)]
+    pub(crate) unsafe fn get_mut_unsafe(&self) -> &mut T {
+        &mut *self.inner.as_ref().get()
+    }
 }