Fix back-pressure handling for concurrent connections

.travis.yml

@@ -10,13 +10,13 @@ matrix:
   include:
     - rust: stable
     - rust: beta
-    - rust: nightly-2019-06-15
+    - rust: nightly
   allow_failures:
-    - rust: nightly-2019-06-15
+    - rust: nightly
 
 env:
   global:
-    - RUSTFLAGS="-C link-dead-code"
+    # - RUSTFLAGS="-C link-dead-code"
     - OPENSSL_VERSION=openssl-1.0.2
 
 before_install:
@@ -24,26 +24,31 @@ before_install:
   - sudo apt-get update -qq
   - sudo apt-get install -y openssl libssl-dev libelf-dev libdw-dev cmake gcc binutils-dev libiberty-dev
 
-before_cache: |
-  if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-06-15" ]]; then
-    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install --version 0.6.11 cargo-tarpaulin
-  fi
-
 # Add clippy
 before_script:
   - export PATH=$PATH:~/.cargo/bin
 
 script:
   - |
-    if [[ "$TRAVIS_RUST_VERSION" != "nightly-2019-06-15" ]]; then
+    if [[ "$TRAVIS_RUST_VERSION" != "nightly" ]]; then
     cargo clean
-    cargo test --all --all-features -- --nocapture
+    cargo test --features="ssl,tls,rust-tls" -- --nocapture
+    fi
+  - |
+    if [[ "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
+    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install -f cargo-tarpaulin
+    cargo tarpaulin --features="ssl,tls,rust-tls" --out Xml
+    bash <(curl -s https://codecov.io/bash)
+    echo "Uploaded code coverage"
     fi
 
+# Upload docs
 after_success:
   - |
-    if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-06-15" ]]; then
-    taskset -c 0 cargo tarpaulin --all --all-features --out Xml
-    echo "Uploaded code coverage"
-    bash <(curl -s https://codecov.io/bash)
+    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "beta" ]]; then
+      cargo doc --features "ssl,tls,rust-tls" --no-deps &&
+      echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html &&
+      git clone https://github.com/davisp/ghp-import.git &&
+      ./ghp-import/ghp_import.py -n -p -f -m "Documentation upload" -r https://"$GH_TOKEN"@github.com/"$TRAVIS_REPO_SLUG.git" target/doc &&
+      echo "Uploaded documentation"
     fi

CHANGES.md

@@ -1,10 +1,19 @@
 # Changes
 
-## [0.3.0] - xxx
+## [0.2.6] - 2018-12-21
 
-* Split `Service` trait to separate crate
+### Fixed
 
-* Use new `Service<Request>` trait
+* Fix back-pressure handling for concurrent connections
+
+
+## [0.2.5] - 2018-12-12
+
+### Fixed
+
+* Fix back-pressure for concurrent ssl handshakes
+
+* Drop completed future for .then and .and_then combinators
 
 
 ## [0.2.4] - 2018-11-21

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "actix-net"
-version = "0.3.0"
+version = "0.2.6"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix net - framework for the compisible network services for Rust"
+description = "Actix net - framework for the compisible network services for Rust (experimental)"
 readme = "README.md"
 keywords = ["network", "framework", "async", "futures"]
 homepage = "https://actix.rs"
@@ -11,31 +11,72 @@ documentation = "https://docs.rs/actix-net/"
 categories = ["network-programming", "asynchronous"]
 license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
-edition = "2018"
 
-[workspace]
-members = [
-  "actix-codec",
-  "actix-connect",
-  "actix-rt",
-  "actix-service",
-  "actix-server",
-  "actix-server-config",
-  "actix-test-server",
-  "actix-threadpool",
-  "actix-tower",
-  "actix-ioframe",
-  "actix-utils",
-  "router",
-]
+[package.metadata.docs.rs]
+features = ["ssl", "tls", "rust-tls"]
+
+[badges]
+travis-ci = { repository = "actix/actix-net", branch = "master" }
+# appveyor = { repository = "fafhrd91/actix-web-hdy9d" }
+codecov = { repository = "actix/actix-net", branch = "master", service = "github" }
+
+[lib]
+name = "actix_net"
+path = "src/lib.rs"
+
+[features]
+default = []
+
+# tls
+tls = ["native-tls"]
+
+# openssl
+ssl = ["openssl", "tokio-openssl"]
+
+# rustls
+rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
+
+cell = []
+
+[dependencies]
+actix = "0.7.6"
+
+log = "0.4"
+num_cpus = "1.0"
+
+# io
+mio = "^0.6.13"
+net2 = "0.2"
+bytes = "0.4"
+futures = "0.1"
+slab = "0.4"
+tokio = "0.1"
+tokio-codec = "0.1"
+tokio-io = "0.1"
+tokio-tcp = "0.1"
+tokio-timer = "0.2"
+tokio-reactor = "0.1"
+tokio-current-thread = "0.1"
+tower-service = "0.1"
+trust-dns-resolver = "^0.10.2"
+
+# native-tls
+native-tls = { version="0.2", optional = true }
+
+# openssl
+openssl = { version="0.10", optional = true }
+tokio-openssl = { version="0.2", optional = true }
+
+#rustls
+rustls = { version = "^0.14", optional = true }
+tokio-rustls = { version = "^0.8", optional = true }
+webpki = { version = "0.18", optional = true }
+webpki-roots = { version = "0.15", optional = true }
 
 [dev-dependencies]
-actix-service = "0.4.0"
-actix-codec = "0.1.1"
-actix-rt = "0.2.0"
-actix-server = { version="0.5.0", features=["ssl"] }
-env_logger = "0.6"
-futures = "0.1.25"
-openssl = "0.10"
-tokio-tcp = "0.1"
-tokio-openssl = "0.3"
+env_logger = "0.5"
+
+[profile.release]
+lto = true
+opt-level = 3
+codegen-units = 1

README.md

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

actix-codec/CHANGES.md

@@ -1,15 +0,0 @@
-# Changes
-
-## [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,25 +0,0 @@
-[package]
-name = "actix-codec"
-version = "0.1.2"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Utilities for encoding and decoding frames"
-keywords = ["network", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-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 = ".."
-
-[lib]
-name = "actix_codec"
-path = "src/lib.rs"
-
-[dependencies]
-bytes = "0.4.12"
-futures = "0.1.24"
-tokio-io = "0.1.12"
-tokio-codec = "0.1.1"
-log = "0.4"

actix-codec/LICENSE-APACHE

@@ -1 +0,0 @@
-../LICENSE-APACHE

actix-codec/LICENSE-MIT

@@ -1 +0,0 @@
-../LICENSE-MIT

actix-connect/CHANGES.md

@@ -1,67 +0,0 @@
-# Changes
-
-## [0.2.1] - 2019-07-17
-
-### Added
-
-* Expose Connect addrs #30
-
-### Changed
-
-* Update `derive_more` to 0.15
-
-
-## [0.2.0] - 2019-05-12
-
-### Changed
-
-* Upgrade to actix-service 0.4
-
-
-## [0.1.5] - 2019-04-19
-
-### Added
-
-* `Connect::set_addr()`
-
-### Changed
-
-* Use trust-dns-resolver 0.11.0
-
-
-## [0.1.4] - 2019-04-12
-
-### Changed
-
-* Do not start default resolver immediately for default connector.
-
-
-## [0.1.3] - 2019-04-11
-
-### Changed
-
-* Start trust-dns default resolver on first use
-
-## [0.1.2] - 2019-04-04
-
-### Added
-
-* Log error if dns system config could not be loaded.
-
-### Changed
-
-* Rename connect Connector to TcpConnector #10
-
-
-## [0.1.1] - 2019-03-15
-
-### Fixed
-
-* Fix error handling for single address
-
-
-## [0.1.0] - 2019-03-14
-
-* Refactor resolver and connector services
-
-* Rename crate

actix-connect/Cargo.toml

@@ -1,52 +0,0 @@
-[package]
-name = "actix-connect"
-version = "0.2.1"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix Connector - tcp connector service"
-keywords = ["network", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-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 = ".."
-
-[package.metadata.docs.rs]
-features = ["ssl", "uri"]
-
-[lib]
-name = "actix_connect"
-path = "src/lib.rs"
-
-[features]
-default = ["uri"]
-
-# openssl
-ssl = ["openssl", "tokio-openssl"]
-
-# support http::Uri as connect address
-uri = ["http"]
-
-[dependencies]
-actix-service = "0.4.0"
-actix-codec = "0.1.2"
-actix-utils = "0.4.0"
-derive_more = "0.15"
-either = "1.5.2"
-futures = "0.1.25"
-http = { version = "0.1.17", optional = true }
-log = "0.4"
-tokio-tcp = "0.1.3"
-tokio-current-thread = "0.1.5"
-trust-dns-resolver = { version="0.11.0", default-features = false }
-
-# openssl
-openssl = { version="0.10", optional = true }
-tokio-openssl = { version="0.3", optional = true }
-
-[dev-dependencies]
-bytes = "0.4"
-actix-test-server = { version="0.2.2", features=["ssl"] }
-actix-server-config = "0.1.0"

actix-connect/LICENSE-APACHE

@@ -1 +0,0 @@
-../LICENSE-APACHE

actix-connect/LICENSE-MIT

@@ -1 +0,0 @@
-../LICENSE-MIT

actix-connect/src/connect.rs

@@ -1,281 +0,0 @@
-use std::collections::{vec_deque, VecDeque};
-use std::fmt;
-use std::iter::{FromIterator, FusedIterator};
-use std::net::SocketAddr;
-
-use either::Either;
-
-/// Connect request
-pub trait Address {
-    /// Host name of the request
-    fn host(&self) -> &str;
-
-    /// Port of the request
-    fn port(&self) -> Option<u16>;
-}
-
-impl Address for String {
-    fn host(&self) -> &str {
-        &self
-    }
-
-    fn port(&self) -> Option<u16> {
-        None
-    }
-}
-
-impl Address for &'static str {
-    fn host(&self) -> &str {
-        self
-    }
-
-    fn port(&self) -> Option<u16> {
-        None
-    }
-}
-
-/// Connect request
-#[derive(Eq, PartialEq, Debug, Hash)]
-pub struct Connect<T> {
-    pub(crate) req: T,
-    pub(crate) port: u16,
-    pub(crate) addr: Option<Either<SocketAddr, VecDeque<SocketAddr>>>,
-}
-
-impl<T: Address> Connect<T> {
-    /// Create `Connect` instance by spliting the string by ':' and convert the second part to u16
-    pub fn new(req: T) -> Connect<T> {
-        let (_, port) = parse(req.host());
-        Connect {
-            req,
-            port: port.unwrap_or(0),
-            addr: None,
-        }
-    }
-
-    /// Create new `Connect` instance from host and address. Connector skips name resolution stage for such connect messages.
-    pub fn with(req: T, addr: SocketAddr) -> Connect<T> {
-        Connect {
-            req,
-            port: 0,
-            addr: Some(Either::Left(addr)),
-        }
-    }
-
-    /// Use port if address does not provide one.
-    ///
-    /// By default it set to 0
-    pub fn set_port(mut self, port: u16) -> Self {
-        self.port = port;
-        self
-    }
-
-    /// Use address.
-    pub fn set_addr(mut self, addr: Option<SocketAddr>) -> Self {
-        if let Some(addr) = addr {
-            self.addr = Some(Either::Left(addr));
-        }
-        self
-    }
-
-    /// Use addresses.
-    pub fn set_addrs<I>(mut self, addrs: I) -> Self
-    where
-        I: IntoIterator<Item = SocketAddr>,
-    {
-        let mut addrs = VecDeque::from_iter(addrs);
-        self.addr = if addrs.len() < 2 {
-            addrs.pop_front().map(Either::Left)
-        } else {
-            Some(Either::Right(addrs))
-        };
-        self
-    }
-
-    /// Host name
-    pub fn host(&self) -> &str {
-        self.req.host()
-    }
-
-    /// Port of the request
-    pub fn port(&self) -> u16 {
-        self.req.port().unwrap_or(self.port)
-    }
-
-    /// Preresolved addresses of the request.
-    pub fn addrs(&self) -> ConnectAddrsIter<'_> {
-        let inner = match self.addr {
-            None => Either::Left(None),
-            Some(Either::Left(addr)) => Either::Left(Some(addr)),
-            Some(Either::Right(ref addrs)) => Either::Right(addrs.iter()),
-        };
-
-        ConnectAddrsIter { inner }
-    }
-
-    /// Takes preresolved addresses of the request.
-    pub fn take_addrs(&mut self) -> ConnectTakeAddrsIter {
-        let inner = match self.addr.take() {
-            None => Either::Left(None),
-            Some(Either::Left(addr)) => Either::Left(Some(addr)),
-            Some(Either::Right(addrs)) => Either::Right(addrs.into_iter()),
-        };
-
-        ConnectTakeAddrsIter { inner }
-    }
-}
-
-impl<T: Address> From<T> for Connect<T> {
-    fn from(addr: T) -> Self {
-        Connect::new(addr)
-    }
-}
-
-impl<T: Address> fmt::Display for Connect<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}:{}", self.host(), self.port())
-    }
-}
-
-/// Iterator over addresses in a [`Connect`](struct.Connect.html) request.
-#[derive(Clone)]
-pub struct ConnectAddrsIter<'a> {
-    inner: Either<Option<SocketAddr>, vec_deque::Iter<'a, SocketAddr>>,
-}
-
-impl Iterator for ConnectAddrsIter<'_> {
-    type Item = SocketAddr;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self.inner {
-            Either::Left(ref mut opt) => opt.take(),
-            Either::Right(ref mut iter) => iter.next().copied(),
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        match self.inner {
-            Either::Left(Some(_)) => (1, Some(1)),
-            Either::Left(None) => (0, Some(0)),
-            Either::Right(ref iter) => iter.size_hint(),
-        }
-    }
-}
-
-impl fmt::Debug for ConnectAddrsIter<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_list().entries(self.clone()).finish()
-    }
-}
-
-impl ExactSizeIterator for ConnectAddrsIter<'_> {}
-
-impl FusedIterator for ConnectAddrsIter<'_> {}
-
-/// Owned iterator over addresses in a [`Connect`](struct.Connect.html) request.
-#[derive(Debug)]
-pub struct ConnectTakeAddrsIter {
-    inner: Either<Option<SocketAddr>, vec_deque::IntoIter<SocketAddr>>,
-}
-
-impl Iterator for ConnectTakeAddrsIter {
-    type Item = SocketAddr;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self.inner {
-            Either::Left(ref mut opt) => opt.take(),
-            Either::Right(ref mut iter) => iter.next(),
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        match self.inner {
-            Either::Left(Some(_)) => (1, Some(1)),
-            Either::Left(None) => (0, Some(0)),
-            Either::Right(ref iter) => iter.size_hint(),
-        }
-    }
-}
-
-impl ExactSizeIterator for ConnectTakeAddrsIter {}
-
-impl FusedIterator for ConnectTakeAddrsIter {}
-
-fn parse(host: &str) -> (&str, Option<u16>) {
-    let mut parts_iter = host.splitn(2, ':');
-    if let Some(host) = parts_iter.next() {
-        let port_str = parts_iter.next().unwrap_or("");
-        if let Ok(port) = port_str.parse::<u16>() {
-            (host, Some(port))
-        } else {
-            (host, None)
-        }
-    } else {
-        (host, None)
-    }
-}
-
-pub struct Connection<T, U> {
-    io: U,
-    req: T,
-}
-
-impl<T, U> Connection<T, U> {
-    pub fn new(io: U, req: T) -> Self {
-        Self { io, req }
-    }
-}
-
-impl<T, U> Connection<T, U> {
-    /// Reconstruct from a parts.
-    pub fn from_parts(io: U, req: T) -> Self {
-        Self { io, req }
-    }
-
-    /// Deconstruct into a parts.
-    pub fn into_parts(self) -> (U, T) {
-        (self.io, self.req)
-    }
-
-    /// Replace inclosed object, return new Stream and old object
-    pub fn replace<Y>(self, io: Y) -> (U, Connection<T, Y>) {
-        (self.io, Connection { io, req: self.req })
-    }
-
-    /// Returns a shared reference to the underlying stream.
-    pub fn get_ref(&self) -> &U {
-        &self.io
-    }
-
-    /// Returns a mutable reference to the underlying stream.
-    pub fn get_mut(&mut self) -> &mut U {
-        &mut self.io
-    }
-}
-
-impl<T: Address, U> Connection<T, U> {
-    /// Get request
-    pub fn host(&self) -> &str {
-        &self.req.host()
-    }
-}
-
-impl<T, U> std::ops::Deref for Connection<T, U> {
-    type Target = U;
-
-    fn deref(&self) -> &U {
-        &self.io
-    }
-}
-
-impl<T, U> std::ops::DerefMut for Connection<T, U> {
-    fn deref_mut(&mut self) -> &mut U {
-        &mut self.io
-    }
-}
-
-impl<T, U: fmt::Debug> fmt::Debug for Connection<T, U> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Stream {{{:?}}}", self.io)
-    }
-}

actix-connect/src/connector.rs

@@ -1,157 +0,0 @@
-use std::collections::VecDeque;
-use std::marker::PhantomData;
-use std::net::SocketAddr;
-
-use actix_service::{NewService, Service};
-use futures::future::{err, ok, Either, FutureResult};
-use futures::{Async, Future, Poll};
-use tokio_tcp::{ConnectFuture, TcpStream};
-
-use super::connect::{Address, Connect, Connection};
-use super::error::ConnectError;
-
-/// Tcp connector service factory
-#[derive(Debug)]
-pub struct TcpConnectorFactory<T>(PhantomData<T>);
-
-impl<T> TcpConnectorFactory<T> {
-    pub fn new() -> Self {
-        TcpConnectorFactory(PhantomData)
-    }
-}
-
-impl<T> Clone for TcpConnectorFactory<T> {
-    fn clone(&self) -> Self {
-        TcpConnectorFactory(PhantomData)
-    }
-}
-
-impl<T: Address> NewService for TcpConnectorFactory<T> {
-    type Request = Connect<T>;
-    type Response = Connection<T, TcpStream>;
-    type Error = ConnectError;
-    type Config = ();
-    type Service = TcpConnector<T>;
-    type InitError = ();
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self, _: &()) -> Self::Future {
-        ok(TcpConnector(PhantomData))
-    }
-}
-
-/// Tcp connector service
-#[derive(Debug)]
-pub struct TcpConnector<T>(PhantomData<T>);
-
-impl<T> TcpConnector<T> {
-    pub fn new() -> Self {
-        TcpConnector(PhantomData)
-    }
-}
-
-impl<T> Clone for TcpConnector<T> {
-    fn clone(&self) -> Self {
-        TcpConnector(PhantomData)
-    }
-}
-
-impl<T: Address> Service for TcpConnector<T> {
-    type Request = Connect<T>;
-    type Response = Connection<T, TcpStream>;
-    type Error = ConnectError;
-    type Future = Either<TcpConnectorResponse<T>, FutureResult<Self::Response, Self::Error>>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, req: Connect<T>) -> Self::Future {
-        let port = req.port();
-        let Connect { req, addr, .. } = req;
-
-        if let Some(addr) = addr {
-            Either::A(TcpConnectorResponse::new(req, port, addr))
-        } else {
-            error!("TCP connector: got unresolved address");
-            Either::B(err(ConnectError::Unresolverd))
-        }
-    }
-}
-
-#[doc(hidden)]
-/// Tcp stream connector response future
-pub struct TcpConnectorResponse<T> {
-    req: Option<T>,
-    port: u16,
-    addrs: Option<VecDeque<SocketAddr>>,
-    stream: Option<ConnectFuture>,
-}
-
-impl<T: Address> TcpConnectorResponse<T> {
-    pub fn new(
-        req: T,
-        port: u16,
-        addr: either::Either<SocketAddr, VecDeque<SocketAddr>>,
-    ) -> TcpConnectorResponse<T> {
-        trace!(
-            "TCP connector - connecting to {:?} port:{}",
-            req.host(),
-            port
-        );
-
-        match addr {
-            either::Either::Left(addr) => TcpConnectorResponse {
-                req: Some(req),
-                port,
-                addrs: None,
-                stream: Some(TcpStream::connect(&addr)),
-            },
-            either::Either::Right(addrs) => TcpConnectorResponse {
-                req: Some(req),
-                port,
-                addrs: Some(addrs),
-                stream: None,
-            },
-        }
-    }
-}
-
-impl<T: Address> Future for TcpConnectorResponse<T> {
-    type Item = Connection<T, TcpStream>;
-    type Error = ConnectError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        // connect
-        loop {
-            if let Some(new) = self.stream.as_mut() {
-                match new.poll() {
-                    Ok(Async::Ready(sock)) => {
-                        let req = self.req.take().unwrap();
-                        trace!(
-                            "TCP connector - successfully connected to connecting to {:?} - {:?}",
-                            req.host(), sock.peer_addr()
-                        );
-                        return Ok(Async::Ready(Connection::new(sock, req)));
-                    }
-                    Ok(Async::NotReady) => return Ok(Async::NotReady),
-                    Err(err) => {
-                        trace!(
-                            "TCP connector - failed to connect to connecting to {:?} port: {}",
-                            self.req.as_ref().unwrap().host(),
-                            self.port,
-                        );
-                        if self.addrs.is_none() || self.addrs.as_ref().unwrap().is_empty() {
-                            return Err(err.into());
-                        }
-                    }
-                }
-            }
-
-            // try to connect
-            self.stream = Some(TcpStream::connect(
-                &self.addrs.as_mut().unwrap().pop_front().unwrap(),
-            ));
-        }
-    }
-}

actix-connect/src/error.rs

@@ -1,26 +0,0 @@
-use std::io;
-
-use derive_more::{Display, From};
-use trust_dns_resolver::error::ResolveError;
-
-#[derive(Debug, From, Display)]
-pub enum ConnectError {
-    /// Failed to resolve the hostname
-    #[display(fmt = "Failed resolving hostname: {}", _0)]
-    Resolver(ResolveError),
-
-    /// No dns records
-    #[display(fmt = "No dns records found for the input")]
-    NoRecords,
-
-    /// Invalid input
-    InvalidInput,
-
-    /// Unresolved host name
-    #[display(fmt = "Connector received `Connect` method with unresolved host")]
-    Unresolverd,
-
-    /// Connection io error
-    #[display(fmt = "{}", _0)]
-    Io(io::Error),
-}

actix-connect/src/lib.rs

@@ -1,109 +0,0 @@
-//! Actix connect - tcp connector service
-//!
-//! ## Package feature
-//!
-//! * `ssl` - enables ssl support via `openssl` crate
-//! * `rust-tls` - enables ssl support via `rustls` crate
-
-#![recursion_limit = "128"]
-
-#[macro_use]
-extern crate log;
-
-use std::cell::RefCell;
-
-mod connect;
-mod connector;
-mod error;
-mod resolver;
-pub mod ssl;
-
-#[cfg(feature = "uri")]
-mod uri;
-
-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};
-
-use actix_service::{NewService, Service, ServiceExt};
-use tokio_tcp::TcpStream;
-
-pub fn start_resolver(cfg: ResolverConfig, opts: ResolverOpts) -> AsyncResolver {
-    let (resolver, bg) = AsyncResolver::new(cfg, opts);
-    tokio_current_thread::spawn(bg);
-    resolver
-}
-
-thread_local! {
-    static DEFAULT_RESOLVER: RefCell<Option<AsyncResolver>> = RefCell::new(None);
-}
-
-pub(crate) fn get_default_resolver() -> AsyncResolver {
-    DEFAULT_RESOLVER.with(|cell| {
-        if let Some(ref resolver) = *cell.borrow() {
-            return resolver.clone();
-        }
-
-        let (cfg, opts) = match read_system_conf() {
-            Ok((cfg, opts)) => (cfg, opts),
-            Err(e) => {
-                log::error!("TRust-DNS can not load system config: {}", e);
-                (ResolverConfig::default(), ResolverOpts::default())
-            }
-        };
-
-        let (resolver, bg) = AsyncResolver::new(cfg, opts);
-        tokio_current_thread::spawn(bg);
-
-        *cell.borrow_mut() = Some(resolver.clone());
-        resolver
-    })
-}
-
-pub fn start_default_resolver() -> AsyncResolver {
-    get_default_resolver()
-}
-
-/// Create tcp connector service
-pub fn new_connector<T: Address>(
-    resolver: AsyncResolver,
-) -> impl Service<Request = Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError>
-         + Clone {
-    Resolver::new(resolver).and_then(TcpConnector::new())
-}
-
-/// Create tcp connector service
-pub fn new_connector_factory<T: Address>(
-    resolver: AsyncResolver,
-) -> impl NewService<
-    Config = (),
-    Request = Connect<T>,
-    Response = Connection<T, TcpStream>,
-    Error = ConnectError,
-    InitError = (),
-> + Clone {
-    ResolverFactory::new(resolver).and_then(TcpConnectorFactory::new())
-}
-
-/// Create connector service with default parameters
-pub fn default_connector<T: Address>(
-) -> impl Service<Request = Connect<T>, Response = Connection<T, TcpStream>, Error = ConnectError>
-         + Clone {
-    Resolver::default().and_then(TcpConnector::new())
-}
-
-/// Create connector service factory with default parameters
-pub fn default_connector_factory<T: Address>() -> impl NewService<
-    Config = (),
-    Request = Connect<T>,
-    Response = Connection<T, TcpStream>,
-    Error = ConnectError,
-    InitError = (),
-> + Clone {
-    ResolverFactory::default().and_then(TcpConnectorFactory::new())
-}

actix-connect/src/resolver.rs

@@ -1,183 +0,0 @@
-use std::marker::PhantomData;
-use std::net::SocketAddr;
-
-use actix_service::{NewService, Service};
-use futures::future::{ok, Either, FutureResult};
-use futures::{Async, Future, Poll};
-use trust_dns_resolver::lookup_ip::LookupIpFuture;
-use trust_dns_resolver::{AsyncResolver, Background};
-
-use crate::connect::{Address, Connect};
-use crate::error::ConnectError;
-use crate::get_default_resolver;
-
-/// DNS Resolver Service factory
-pub struct ResolverFactory<T> {
-    resolver: Option<AsyncResolver>,
-    _t: PhantomData<T>,
-}
-
-impl<T> ResolverFactory<T> {
-    /// Create new resolver instance with custom configuration and options.
-    pub fn new(resolver: AsyncResolver) -> Self {
-        ResolverFactory {
-            resolver: Some(resolver),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T> Default for ResolverFactory<T> {
-    fn default() -> Self {
-        ResolverFactory {
-            resolver: None,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T> Clone for ResolverFactory<T> {
-    fn clone(&self) -> Self {
-        ResolverFactory {
-            resolver: self.resolver.clone(),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T: Address> NewService for ResolverFactory<T> {
-    type Request = Connect<T>;
-    type Response = Connect<T>;
-    type Error = ConnectError;
-    type Config = ();
-    type Service = Resolver<T>;
-    type InitError = ();
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self, _: &()) -> Self::Future {
-        ok(Resolver {
-            resolver: self.resolver.clone(),
-            _t: PhantomData,
-        })
-    }
-}
-
-/// DNS Resolver Service
-pub struct Resolver<T> {
-    resolver: Option<AsyncResolver>,
-    _t: PhantomData<T>,
-}
-
-impl<T> Resolver<T> {
-    /// Create new resolver instance with custom configuration and options.
-    pub fn new(resolver: AsyncResolver) -> Self {
-        Resolver {
-            resolver: Some(resolver),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T> Default for Resolver<T> {
-    fn default() -> Self {
-        Resolver {
-            resolver: None,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T> Clone for Resolver<T> {
-    fn clone(&self) -> Self {
-        Resolver {
-            resolver: self.resolver.clone(),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T: Address> Service for Resolver<T> {
-    type Request = Connect<T>;
-    type Response = Connect<T>;
-    type Error = ConnectError;
-    type Future = Either<ResolverFuture<T>, FutureResult<Connect<T>, Self::Error>>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, mut req: Connect<T>) -> Self::Future {
-        if req.addr.is_some() {
-            Either::B(ok(req))
-        } else {
-            if let Ok(ip) = req.host().parse() {
-                req.addr = Some(either::Either::Left(SocketAddr::new(ip, req.port())));
-                Either::B(ok(req))
-            } else {
-                trace!("DNS resolver: resolving host {:?}", req.host());
-                if self.resolver.is_none() {
-                    self.resolver = Some(get_default_resolver());
-                }
-                Either::A(ResolverFuture::new(req, self.resolver.as_ref().unwrap()))
-            }
-        }
-    }
-}
-
-#[doc(hidden)]
-/// Resolver future
-pub struct ResolverFuture<T: Address> {
-    req: Option<Connect<T>>,
-    lookup: Background<LookupIpFuture>,
-}
-
-impl<T: Address> ResolverFuture<T> {
-    pub fn new(req: Connect<T>, resolver: &AsyncResolver) -> Self {
-        let lookup = if let Some(host) = req.host().splitn(2, ':').next() {
-            resolver.lookup_ip(host)
-        } else {
-            resolver.lookup_ip(req.host())
-        };
-
-        ResolverFuture {
-            lookup,
-            req: Some(req),
-        }
-    }
-}
-
-impl<T: Address> Future for ResolverFuture<T> {
-    type Item = Connect<T>;
-    type Error = ConnectError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.lookup.poll().map_err(|e| {
-            trace!(
-                "DNS resolver: failed to resolve host {:?} err: {}",
-                self.req.as_ref().unwrap().host(),
-                e
-            );
-            e
-        })? {
-            Async::NotReady => Ok(Async::NotReady),
-            Async::Ready(ips) => {
-                let req = self.req.take().unwrap();
-
-                let port = req.port();
-                let req = req.set_addrs(ips.iter().map(|ip| SocketAddr::new(ip, port)));
-
-                trace!(
-                    "DNS resolver: host {:?} resolved to {:?}",
-                    req.host(),
-                    req.addrs()
-                );
-
-                if req.addr.is_none() {
-                    Err(ConnectError::NoRecords)
-                } else {
-                    Ok(Async::Ready(req))
-                }
-            }
-        }
-    }
-}

actix-connect/src/ssl/mod.rs

@@ -1,6 +0,0 @@
-//! SSL Services
-
-#[cfg(feature = "ssl")]
-mod openssl;
-#[cfg(feature = "ssl")]
-pub use self::openssl::OpensslConnector;

actix-connect/src/ssl/openssl.rs

@@ -1,128 +0,0 @@
-use std::fmt;
-use std::marker::PhantomData;
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_service::{NewService, Service};
-use futures::{future::ok, future::FutureResult, Async, Future, Poll};
-use openssl::ssl::{HandshakeError, SslConnector};
-use tokio_openssl::{ConnectAsync, SslConnectorExt, SslStream};
-
-use crate::{Address, Connection};
-
-/// Openssl connector factory
-pub struct OpensslConnector<T, U> {
-    connector: SslConnector,
-    _t: PhantomData<(T, U)>,
-}
-
-impl<T, U> OpensslConnector<T, U> {
-    pub fn new(connector: SslConnector) -> Self {
-        OpensslConnector {
-            connector,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, U> OpensslConnector<T, U>
-where
-    T: Address,
-    U: AsyncRead + AsyncWrite + fmt::Debug,
-{
-    pub fn service(
-        connector: SslConnector,
-    ) -> impl Service<
-        Request = Connection<T, U>,
-        Response = Connection<T, SslStream<U>>,
-        Error = HandshakeError<U>,
-    > {
-        OpensslConnectorService {
-            connector: connector,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, U> Clone for OpensslConnector<T, U> {
-    fn clone(&self) -> Self {
-        Self {
-            connector: self.connector.clone(),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T: Address, U> NewService for OpensslConnector<T, U>
-where
-    U: AsyncRead + AsyncWrite + fmt::Debug,
-{
-    type Request = Connection<T, U>;
-    type Response = Connection<T, SslStream<U>>;
-    type Error = HandshakeError<U>;
-    type Config = ();
-    type Service = OpensslConnectorService<T, U>;
-    type InitError = ();
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self, _: &()) -> Self::Future {
-        ok(OpensslConnectorService {
-            connector: self.connector.clone(),
-            _t: PhantomData,
-        })
-    }
-}
-
-pub struct OpensslConnectorService<T, U> {
-    connector: SslConnector,
-    _t: PhantomData<(T, U)>,
-}
-
-impl<T: Address, U> Service for OpensslConnectorService<T, U>
-where
-    U: AsyncRead + AsyncWrite + fmt::Debug,
-{
-    type Request = Connection<T, U>;
-    type Response = Connection<T, SslStream<U>>;
-    type Error = HandshakeError<U>;
-    type Future = ConnectAsyncExt<T, U>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, stream: Connection<T, U>) -> Self::Future {
-        trace!("SSL Handshake start for: {:?}", stream.host());
-        let (io, stream) = stream.replace(());
-        ConnectAsyncExt {
-            fut: SslConnectorExt::connect_async(&self.connector, stream.host(), io),
-            stream: Some(stream),
-        }
-    }
-}
-
-pub struct ConnectAsyncExt<T, U> {
-    fut: ConnectAsync<U>,
-    stream: Option<Connection<T, ()>>,
-}
-
-impl<T: Address, U> Future for ConnectAsyncExt<T, U>
-where
-    U: AsyncRead + AsyncWrite + fmt::Debug,
-{
-    type Item = Connection<T, SslStream<U>>;
-    type Error = HandshakeError<U>;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.fut.poll().map_err(|e| {
-            trace!("SSL Handshake error: {:?}", e);
-            e
-        })? {
-            Async::Ready(stream) => {
-                let s = self.stream.take().unwrap();
-                trace!("SSL Handshake success: {:?}", s.host());
-                Ok(Async::Ready(s.replace(stream).1))
-            }
-            Async::NotReady => Ok(Async::NotReady),
-        }
-    }
-}

actix-connect/src/uri.rs

@@ -1,37 +0,0 @@
-use http::Uri;
-
-use crate::Address;
-
-impl Address for Uri {
-    fn host(&self) -> &str {
-        self.host().unwrap_or("")
-    }
-
-    fn port(&self) -> Option<u16> {
-        if let Some(port) = self.port_u16() {
-            Some(port)
-        } else {
-            port(self.scheme_str())
-        }
-    }
-}
-
-// TODO: load data from file
-fn port(scheme: Option<&str>) -> Option<u16> {
-    if let Some(scheme) = scheme {
-        match scheme {
-            "http" => Some(80),
-            "https" => Some(443),
-            "ws" => Some(80),
-            "wss" => Some(443),
-            "amqp" => Some(5672),
-            "amqps" => Some(5671),
-            "sb" => Some(5671),
-            "mqtt" => Some(1883),
-            "mqtts" => Some(8883),
-            _ => None,
-        }
-    } else {
-        None
-    }
-}

actix-connect/tests/test_connect.rs

@@ -1,109 +0,0 @@
-use actix_codec::{BytesCodec, Framed};
-use actix_server_config::Io;
-use actix_service::{service_fn, NewService, Service};
-use actix_test_server::TestServer;
-use bytes::Bytes;
-use futures::{future::lazy, Future, Sink};
-use http::{HttpTryFrom, Uri};
-use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
-
-use actix_connect::{default_connector, Connect};
-
-#[cfg(feature = "ssl")]
-#[test]
-fn test_string() {
-    let mut srv = TestServer::with(|| {
-        service_fn(|io: Io<tokio_tcp::TcpStream>| {
-            Framed::new(io.into_parts().0, BytesCodec)
-                .send(Bytes::from_static(b"test"))
-                .then(|_| Ok::<_, ()>(()))
-        })
-    });
-
-    let mut conn = default_connector();
-    let addr = format!("localhost:{}", srv.port());
-    let con = srv.run_on(move || conn.call(addr.into())).unwrap();
-    assert_eq!(con.peer_addr().unwrap(), srv.addr());
-}
-
-#[test]
-fn test_static_str() {
-    let mut srv = TestServer::with(|| {
-        service_fn(|io: Io<tokio_tcp::TcpStream>| {
-            Framed::new(io.into_parts().0, BytesCodec)
-                .send(Bytes::from_static(b"test"))
-                .then(|_| Ok::<_, ()>(()))
-        })
-    });
-
-    let resolver = srv
-        .block_on(lazy(
-            || Ok::<_, ()>(actix_connect::start_default_resolver()),
-        ))
-        .unwrap();
-    let mut conn = srv
-        .block_on(lazy(|| {
-            Ok::<_, ()>(actix_connect::new_connector(resolver.clone()))
-        }))
-        .unwrap();
-
-    let con = srv
-        .block_on(conn.call(Connect::with("10", srv.addr())))
-        .unwrap();
-    assert_eq!(con.peer_addr().unwrap(), srv.addr());
-
-    let connect = Connect::new(srv.host().to_owned());
-    let mut conn = srv
-        .block_on(lazy(|| Ok::<_, ()>(actix_connect::new_connector(resolver))))
-        .unwrap();
-    let con = srv.block_on(conn.call(connect));
-    assert!(con.is_err());
-}
-
-#[test]
-fn test_new_service() {
-    let mut srv = TestServer::with(|| {
-        service_fn(|io: Io<tokio_tcp::TcpStream>| {
-            Framed::new(io.into_parts().0, BytesCodec)
-                .send(Bytes::from_static(b"test"))
-                .then(|_| Ok::<_, ()>(()))
-        })
-    });
-
-    let resolver = srv
-        .block_on(lazy(|| {
-            Ok::<_, ()>(actix_connect::start_resolver(
-                ResolverConfig::default(),
-                ResolverOpts::default(),
-            ))
-        }))
-        .unwrap();
-    let factory = srv
-        .block_on(lazy(|| {
-            Ok::<_, ()>(actix_connect::new_connector_factory(resolver))
-        }))
-        .unwrap();
-
-    let mut conn = srv.block_on(factory.new_service(&())).unwrap();
-    let con = srv
-        .block_on(conn.call(Connect::with("10", srv.addr())))
-        .unwrap();
-    assert_eq!(con.peer_addr().unwrap(), srv.addr());
-}
-
-#[cfg(feature = "ssl")]
-#[test]
-fn test_uri() {
-    let mut srv = TestServer::with(|| {
-        service_fn(|io: Io<tokio_tcp::TcpStream>| {
-            Framed::new(io.into_parts().0, BytesCodec)
-                .send(Bytes::from_static(b"test"))
-                .then(|_| Ok::<_, ()>(()))
-        })
-    });
-
-    let mut conn = default_connector();
-    let addr = Uri::try_from(format!("https://localhost:{}", srv.port())).unwrap();
-    let con = srv.run_on(move || conn.call(addr.into())).unwrap();
-    assert_eq!(con.peer_addr().unwrap(), srv.addr());
-}

actix-ioframe/CHANGES.md

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

actix-ioframe/Cargo.toml

@@ -1,35 +0,0 @@
-[package]
-name = "actix-ioframe"
-version = "0.1.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix framed service"
-keywords = ["network", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-ioframed/"
-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 = "0.4.1"
-actix-codec = "0.1.2"
-bytes = "0.4"
-either = "1.5.2"
-futures = "0.1.25"
-tokio-current-thread = "0.1.4"
-log = "0.4"
-
-[dev-dependencies]
-actix-rt = "0.2.2"
-actix-connect = "0.2.0"
-actix-test-server = "0.2.2"
-actix-server-config = "0.1.1"
-tokio-tcp = "0.1"
-tokio-timer = "0.2"

actix-ioframe/LICENSE-APACHE

@@ -1 +0,0 @@
-../LICENSE-APACHE

actix-ioframe/LICENSE-MIT

@@ -1 +0,0 @@
-../LICENSE-MIT

actix-ioframe/src/cell.rs

@@ -1,35 +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_mut(&mut self) -> &mut T {
-        &mut *self.inner.as_ref().get()
-    }
-}

actix-ioframe/src/connect.rs

@@ -1,110 +0,0 @@
-use std::marker::PhantomData;
-
-use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
-use futures::unsync::mpsc;
-
-use crate::dispatcher::FramedMessage;
-use crate::sink::Sink;
-
-pub struct Connect<Io, St = (), Codec = ()> {
-    io: Io,
-    _t: PhantomData<(St, Codec)>,
-}
-
-impl<Io> Connect<Io>
-where
-    Io: AsyncRead + AsyncWrite,
-{
-    pub(crate) fn new(io: Io) -> Self {
-        Self {
-            io,
-            _t: PhantomData,
-        }
-    }
-
-    pub fn codec<Codec>(self, codec: Codec) -> ConnectResult<Io, (), Codec>
-    where
-        Codec: Encoder + Decoder,
-    {
-        let (tx, rx) = mpsc::unbounded();
-        let sink = Sink::new(tx);
-
-        ConnectResult {
-            state: (),
-            framed: Framed::new(self.io, codec),
-            rx,
-            sink,
-        }
-    }
-}
-
-pub struct ConnectResult<Io, St, Codec: Encoder + Decoder> {
-    pub(crate) state: St,
-    pub(crate) framed: Framed<Io, Codec>,
-    pub(crate) rx: mpsc::UnboundedReceiver<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
-    }
-
-    #[inline]
-    pub fn get_ref(&self) -> &Io {
-        self.framed.get_ref()
-    }
-
-    #[inline]
-    pub fn get_mut(&mut self) -> &mut Io {
-        self.framed.get_mut()
-    }
-
-    #[inline]
-    pub fn state<S>(self, state: S) -> ConnectResult<Io, S, Codec> {
-        ConnectResult {
-            state,
-            framed: self.framed,
-            rx: self.rx,
-            sink: self.sink,
-        }
-    }
-}
-
-impl<Io, St, Codec> futures::Stream for ConnectResult<Io, St, Codec>
-where
-    Io: AsyncRead + AsyncWrite,
-    Codec: Encoder + Decoder,
-{
-    type Item = <Codec as Decoder>::Item;
-    type Error = <Codec as Decoder>::Error;
-
-    fn poll(&mut self) -> futures::Poll<Option<Self::Item>, Self::Error> {
-        self.framed.poll()
-    }
-}
-
-impl<Io, St, Codec> futures::Sink for ConnectResult<Io, St, Codec>
-where
-    Io: AsyncRead + AsyncWrite,
-    Codec: Encoder + Decoder,
-{
-    type SinkItem = <Codec as Encoder>::Item;
-    type SinkError = <Codec as Encoder>::Error;
-
-    fn start_send(
-        &mut self,
-        item: Self::SinkItem,
-    ) -> futures::StartSend<Self::SinkItem, Self::SinkError> {
-        self.framed.start_send(item)
-    }
-
-    fn poll_complete(&mut self) -> futures::Poll<(), Self::SinkError> {
-        self.framed.poll_complete()
-    }
-
-    fn close(&mut self) -> futures::Poll<(), Self::SinkError> {
-        self.framed.close()
-    }
-}

actix-ioframe/src/dispatcher.rs

@@ -1,325 +0,0 @@
-//! Framed dispatcher service and related utilities
-use std::collections::VecDeque;
-use std::mem;
-use std::rc::Rc;
-
-use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
-use actix_service::{IntoService, Service};
-use futures::task::AtomicTask;
-use futures::unsync::{mpsc, oneshot};
-use futures::{Async, Future, Poll, Sink as FutureSink, 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 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.
-pub(crate) struct FramedDispatcher<St, S, T, U>
-where
-    S: Service<Request = Request<St, 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,
-{
-    service: S,
-    sink: Sink<<U as Encoder>::Item>,
-    state: State<St>,
-    dispatch_state: FramedState<S, U>,
-    framed: Framed<T, U>,
-    rx: Option<mpsc::UnboundedReceiver<FramedMessage<<U as Encoder>::Item>>>,
-    inner: Cell<FramedDispatcherInner<<U as Encoder>::Item, S::Error>>,
-    disconnect: Option<Rc<Fn(&mut St, bool)>>,
-}
-
-impl<St, S, T, U> FramedDispatcher<St, S, T, 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,
-{
-    pub(crate) fn new<F: IntoService<S>>(
-        framed: Framed<T, U>,
-        state: State<St>,
-        service: F,
-        rx: mpsc::UnboundedReceiver<FramedMessage<<U as Encoder>::Item>>,
-        sink: Sink<<U as Encoder>::Item>,
-        disconnect: Option<Rc<Fn(&mut St, bool)>>,
-    ) -> Self {
-        FramedDispatcher {
-            framed,
-            state,
-            sink,
-            disconnect,
-            rx: Some(rx),
-            service: service.into_service(),
-            dispatch_state: FramedState::Processing,
-            inner: Cell::new(FramedDispatcherInner {
-                buf: VecDeque::new(),
-                task: AtomicTask::new(),
-            }),
-        }
-    }
-}
-
-enum FramedState<S: Service, U: Encoder + Decoder> {
-    Processing,
-    Error(ServiceError<S::Error, U>),
-    FramedError(ServiceError<S::Error, U>),
-    FlushAndStop(Vec<oneshot::Sender<()>>),
-    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(());
-                }
-            }
-        }
-    }
-}
-
-struct FramedDispatcherInner<I, E> {
-    buf: VecDeque<Result<I, E>>,
-    task: AtomicTask,
-}
-
-impl<St, S, T, U> FramedDispatcher<St, S, T, 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,
-{
-    fn disconnect(&mut self, error: bool) {
-        if let Some(ref disconnect) = self.disconnect {
-            (&*disconnect)(&mut *self.state.get_mut(), error);
-        }
-    }
-
-    fn poll_read(&mut self) -> bool {
-        loop {
-            match self.service.poll_ready() {
-                Ok(Async::Ready(_)) => {
-                    let item = match self.framed.poll() {
-                        Ok(Async::Ready(Some(el))) => el,
-                        Err(err) => {
-                            self.dispatch_state =
-                                FramedState::FramedError(ServiceError::Decoder(err));
-                            return true;
-                        }
-                        Ok(Async::NotReady) => return false,
-                        Ok(Async::Ready(None)) => {
-                            self.dispatch_state = FramedState::Stopping;
-                            return true;
-                        }
-                    };
-
-                    let mut cell = self.inner.clone();
-                    unsafe { cell.get_mut().task.register() };
-                    tokio_current_thread::spawn(
-                        self.service
-                            .call(Item::new(self.state.clone(), self.sink.clone(), item))
-                            .then(move |item| {
-                                let item = match item {
-                                    Ok(Some(item)) => Ok(item),
-                                    Ok(None) => return Ok(()),
-                                    Err(err) => Err(err),
-                                };
-                                unsafe {
-                                    let inner = cell.get_mut();
-                                    inner.buf.push_back(item);
-                                    inner.task.notify();
-                                }
-                                Ok(())
-                            }),
-                    );
-                }
-                Ok(Async::NotReady) => return false,
-                Err(err) => {
-                    self.dispatch_state = FramedState::Error(ServiceError::Service(err));
-                    return true;
-                }
-            }
-        }
-    }
-
-    /// write to framed object
-    fn poll_write(&mut self) -> bool {
-        let inner = unsafe { self.inner.get_mut() };
-        let mut rx_done = self.rx.is_none();
-        let mut buf_empty = inner.buf.is_empty();
-        loop {
-            while !self.framed.is_write_buf_full() {
-                if !buf_empty {
-                    match inner.buf.pop_front().unwrap() {
-                        Ok(msg) => {
-                            if let Err(err) = self.framed.force_send(msg) {
-                                self.dispatch_state =
-                                    FramedState::FramedError(ServiceError::Encoder(err));
-                                return true;
-                            }
-                            buf_empty = inner.buf.is_empty();
-                        }
-                        Err(err) => {
-                            self.dispatch_state =
-                                FramedState::Error(ServiceError::Service(err));
-                            return true;
-                        }
-                    }
-                }
-
-                if !rx_done && self.rx.is_some() {
-                    match self.rx.as_mut().unwrap().poll() {
-                        Ok(Async::Ready(Some(FramedMessage::Message(msg)))) => {
-                            if let Err(err) = self.framed.force_send(msg) {
-                                self.dispatch_state =
-                                    FramedState::FramedError(ServiceError::Encoder(err));
-                                return true;
-                            }
-                        }
-                        Ok(Async::Ready(Some(FramedMessage::Close))) => {
-                            self.dispatch_state.stop(None);
-                            return true;
-                        }
-                        Ok(Async::Ready(Some(FramedMessage::WaitClose(tx)))) => {
-                            self.dispatch_state.stop(Some(tx));
-                            return true;
-                        }
-                        Ok(Async::Ready(None)) => {
-                            rx_done = true;
-                            let _ = self.rx.take();
-                        }
-                        Ok(Async::NotReady) => rx_done = true,
-                        Err(_e) => {
-                            rx_done = true;
-                            let _ = self.rx.take();
-                        }
-                    }
-                }
-
-                if rx_done && buf_empty {
-                    break;
-                }
-            }
-
-            if !self.framed.is_write_buf_empty() {
-                match self.framed.poll_complete() {
-                    Ok(Async::NotReady) => break,
-                    Err(err) => {
-                        debug!("Error sending data: {:?}", err);
-                        self.dispatch_state =
-                            FramedState::FramedError(ServiceError::Encoder(err));
-                        return true;
-                    }
-                    Ok(Async::Ready(_)) => (),
-                }
-            } else {
-                break;
-            }
-        }
-
-        false
-    }
-}
-
-impl<St, S, T, U> Future for FramedDispatcher<St, S, T, 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,
-{
-    type Item = ();
-    type Error = ServiceError<S::Error, U>;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match mem::replace(&mut self.dispatch_state, FramedState::Processing) {
-            FramedState::Processing => {
-                if self.poll_read() || self.poll_write() {
-                    self.poll()
-                } else {
-                    Ok(Async::NotReady)
-                }
-            }
-            FramedState::Error(err) => {
-                if self.framed.is_write_buf_empty()
-                    || (self.poll_write() || self.framed.is_write_buf_empty())
-                {
-                    self.disconnect(true);
-                    Err(err)
-                } else {
-                    self.dispatch_state = FramedState::Error(err);
-                    Ok(Async::NotReady)
-                }
-            }
-            FramedState::FlushAndStop(mut vec) => {
-                if !self.framed.is_write_buf_empty() {
-                    match self.framed.poll_complete() {
-                        Err(err) => {
-                            debug!("Error sending data: {:?}", err);
-                        }
-                        Ok(Async::NotReady) => {
-                            self.dispatch_state = FramedState::FlushAndStop(vec);
-                            return Ok(Async::NotReady);
-                        }
-                        Ok(Async::Ready(_)) => (),
-                    }
-                };
-                for tx in vec.drain(..) {
-                    let _ = tx.send(());
-                }
-                self.disconnect(false);
-                Ok(Async::Ready(()))
-            }
-            FramedState::FramedError(err) => {
-                self.disconnect(true);
-                Err(err)
-            }
-            FramedState::Stopping => {
-                self.disconnect(false);
-                Ok(Async::Ready(()))
-            }
-        }
-    }
-}

actix-ioframe/src/error.rs

@@ -1,49 +0,0 @@
-use std::fmt;
-
-use actix_codec::{Decoder, Encoder};
-
-/// Framed service errors
-pub enum ServiceError<E, U: Encoder + Decoder> {
-    /// Inner service error
-    Service(E),
-    /// Encoder parse error
-    Encoder(<U as Encoder>::Error),
-    /// Decoder parse error
-    Decoder(<U as Decoder>::Error),
-}
-
-impl<E, U: Encoder + Decoder> From<E> for ServiceError<E, U> {
-    fn from(err: E) -> Self {
-        ServiceError::Service(err)
-    }
-}
-
-impl<E, U: Encoder + Decoder> fmt::Debug for ServiceError<E, U>
-where
-    E: fmt::Debug,
-    <U as Encoder>::Error: fmt::Debug,
-    <U as Decoder>::Error: fmt::Debug,
-{
-    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),
-            ServiceError::Decoder(ref e) => write!(fmt, "ServiceError::Encoder({:?})", e),
-        }
-    }
-}
-
-impl<E, U: Encoder + Decoder> fmt::Display for ServiceError<E, U>
-where
-    E: fmt::Display,
-    <U as Encoder>::Error: fmt::Debug,
-    <U as Decoder>::Error: fmt::Debug,
-{
-    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),
-            ServiceError::Decoder(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 +0,0 @@
-mod cell;
-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;

actix-ioframe/src/service.rs

@@ -1,363 +0,0 @@
-use std::marker::PhantomData;
-use std::rc::Rc;
-
-use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder};
-use actix_service::{IntoNewService, IntoService, NewService, Service};
-use futures::{Async, Future, Poll};
-
-use crate::connect::{Connect, ConnectResult};
-use crate::dispatcher::FramedDispatcher;
-use crate::error::ServiceError;
-use crate::item::Item;
-use crate::state::State;
-
-type RequestItem<S, U> = Item<S, U>;
-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)
-    }
-
-    /// Construct framed handler service with specified connect service
-    pub fn service<Io, C, F>(self, connect: F) -> ServiceBuilder<St, C, Io, Codec>
-    where
-        F: IntoService<C>,
-        Io: AsyncRead + AsyncWrite,
-        C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
-        Codec: Decoder + Encoder,
-    {
-        ServiceBuilder {
-            connect: connect.into_service(),
-            disconnect: None,
-            _t: PhantomData,
-        }
-    }
-
-    /// Construct framed handler new service with specified connect service
-    pub fn factory<Io, C, F>(self, connect: F) -> NewServiceBuilder<St, C, Io, Codec>
-    where
-        F: IntoNewService<C>,
-        Io: AsyncRead + AsyncWrite,
-        C: NewService<
-            Config = (),
-            Request = Connect<Io>,
-            Response = ConnectResult<Io, St, Codec>,
-        >,
-        C::Error: 'static,
-        C::Future: 'static,
-        Codec: Decoder + Encoder,
-    {
-        NewServiceBuilder {
-            connect: connect.into_new_service(),
-            disconnect: None,
-            _t: PhantomData,
-        }
-    }
-}
-
-pub struct ServiceBuilder<St, C, Io, Codec> {
-    connect: C,
-    disconnect: Option<Rc<Fn(&mut St, bool)>>,
-    _t: PhantomData<(St, Io, Codec)>,
-}
-
-impl<St, C, Io, Codec> ServiceBuilder<St, C, Io, Codec>
-where
-    St: 'static,
-    Io: AsyncRead + AsyncWrite,
-    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
-    C::Error: '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, 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,
-    ) -> impl Service<Request = Io, Response = (), Error = ServiceError<C::Error, Codec>>
-    where
-        F: IntoNewService<T>,
-        T: NewService<
-                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_new_service()),
-            disconnect: self.disconnect.clone(),
-            _t: PhantomData,
-        }
-    }
-}
-
-pub struct NewServiceBuilder<St, C, Io, Codec> {
-    connect: C,
-    disconnect: Option<Rc<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: NewService<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,
-    ) -> impl NewService<
-        Config = Cfg,
-        Request = Io,
-        Response = (),
-        Error = ServiceError<C::Error, Codec>,
-    >
-    where
-        F: IntoNewService<T>,
-        T: NewService<
-                Config = St,
-                Request = RequestItem<St, Codec>,
-                Response = ResponseItem<Codec>,
-                Error = C::Error,
-                InitError = C::Error,
-            > + 'static,
-    {
-        FramedService {
-            connect: self.connect,
-            handler: Rc::new(service.into_new_service()),
-            disconnect: self.disconnect,
-            _t: PhantomData,
-        }
-    }
-}
-
-pub(crate) struct FramedService<St, C, T, Io, Codec, Cfg> {
-    connect: C,
-    handler: Rc<T>,
-    disconnect: Option<Rc<Fn(&mut St, bool)>>,
-    _t: PhantomData<(St, Io, Codec, Cfg)>,
-}
-
-impl<St, C, T, Io, Codec, Cfg> NewService for FramedService<St, C, T, Io, Codec, Cfg>
-where
-    St: 'static,
-    Io: AsyncRead + AsyncWrite,
-    C: NewService<Config = (), Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
-    C::Error: 'static,
-    C::Future: 'static,
-    T: NewService<
-            Config = St,
-            Request = RequestItem<St, Codec>,
-            Response = ResponseItem<Codec>,
-            Error = C::Error,
-            InitError = C::Error,
-        > + 'static,
-    Codec: Decoder + Encoder,
-    <Codec as Encoder>::Item: 'static,
-    <Codec as Encoder>::Error: std::fmt::Debug,
-{
-    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 = Box<Future<Item = Self::Service, Error = Self::InitError>>;
-
-    fn new_service(&self, _: &Cfg) -> Self::Future {
-        let handler = self.handler.clone();
-        let disconnect = self.disconnect.clone();
-
-        // create connect service and then create service impl
-        Box::new(
-            self.connect
-                .new_service(&())
-                .map(move |connect| FramedServiceImpl {
-                    connect,
-                    handler,
-                    disconnect,
-                    _t: PhantomData,
-                }),
-        )
-    }
-}
-
-pub struct FramedServiceImpl<St, C, T, Io, Codec> {
-    connect: C,
-    handler: Rc<T>,
-    disconnect: Option<Rc<Fn(&mut St, bool)>>,
-    _t: PhantomData<(St, Io, Codec)>,
-}
-
-impl<St, C, T, Io, Codec> Service for FramedServiceImpl<St, C, T, Io, Codec>
-where
-    Io: AsyncRead + AsyncWrite,
-    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
-    C::Error: 'static,
-    T: NewService<
-        Config = St,
-        Request = RequestItem<St, Codec>,
-        Response = ResponseItem<Codec>,
-        Error = C::Error,
-        InitError = C::Error,
-    >,
-    <<T as NewService>::Service as Service>::Future: 'static,
-    Codec: Decoder + Encoder,
-    <Codec as Encoder>::Item: 'static,
-    <Codec as Encoder>::Error: std::fmt::Debug,
-{
-    type Request = Io;
-    type Response = ();
-    type Error = ServiceError<C::Error, Codec>;
-    type Future = FramedServiceImplResponse<St, Io, Codec, C, T>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.connect.poll_ready().map_err(|e| e.into())
-    }
-
-    fn call(&mut self, req: Io) -> Self::Future {
-        FramedServiceImplResponse {
-            inner: FramedServiceImplResponseInner::Connect(
-                self.connect.call(Connect::new(req)),
-                self.handler.clone(),
-            ),
-            disconnect: self.disconnect.clone(),
-        }
-    }
-}
-
-pub struct FramedServiceImplResponse<St, Io, Codec, C, T>
-where
-    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
-    C::Error: 'static,
-    T: NewService<
-        Config = St,
-        Request = RequestItem<St, Codec>,
-        Response = ResponseItem<Codec>,
-        Error = C::Error,
-        InitError = C::Error,
-    >,
-    <<T as NewService>::Service as Service>::Future: 'static,
-    Io: AsyncRead + AsyncWrite,
-    Codec: Encoder + Decoder,
-    <Codec as Encoder>::Item: 'static,
-    <Codec as Encoder>::Error: std::fmt::Debug,
-{
-    inner: FramedServiceImplResponseInner<St, Io, Codec, C, T>,
-    disconnect: Option<Rc<Fn(&mut St, bool)>>,
-}
-
-enum FramedServiceImplResponseInner<St, Io, Codec, C, T>
-where
-    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
-    C::Error: 'static,
-    T: NewService<
-        Config = St,
-        Request = RequestItem<St, Codec>,
-        Response = ResponseItem<Codec>,
-        Error = C::Error,
-        InitError = C::Error,
-    >,
-    <<T as NewService>::Service as Service>::Future: 'static,
-    Io: AsyncRead + AsyncWrite,
-    Codec: Encoder + Decoder,
-    <Codec as Encoder>::Item: 'static,
-    <Codec as Encoder>::Error: std::fmt::Debug,
-{
-    Connect(C::Future, Rc<T>),
-    Handler(T::Future, Option<ConnectResult<Io, St, Codec>>),
-    Dispatcher(FramedDispatcher<St, T::Service, Io, Codec>),
-}
-
-impl<St, Io, Codec, C, T> Future for FramedServiceImplResponse<St, Io, Codec, C, T>
-where
-    C: Service<Request = Connect<Io>, Response = ConnectResult<Io, St, Codec>>,
-    C::Error: 'static,
-    T: NewService<
-        Config = St,
-        Request = RequestItem<St, Codec>,
-        Response = ResponseItem<Codec>,
-        Error = C::Error,
-        InitError = C::Error,
-    >,
-    <<T as NewService>::Service as Service>::Future: 'static,
-    Io: AsyncRead + AsyncWrite,
-    Codec: Encoder + Decoder,
-    <Codec as Encoder>::Item: 'static,
-    <Codec as Encoder>::Error: std::fmt::Debug,
-{
-    type Item = ();
-    type Error = ServiceError<C::Error, Codec>;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.inner {
-            FramedServiceImplResponseInner::Connect(ref mut fut, ref handler) => {
-                match fut.poll()? {
-                    Async::Ready(res) => {
-                        self.inner = FramedServiceImplResponseInner::Handler(
-                            handler.new_service(&res.state),
-                            Some(res),
-                        );
-                        self.poll()
-                    }
-                    Async::NotReady => Ok(Async::NotReady),
-                }
-            }
-            FramedServiceImplResponseInner::Handler(ref mut fut, ref mut res) => {
-                match fut.poll()? {
-                    Async::Ready(handler) => {
-                        let res = res.take().unwrap();
-                        self.inner =
-                            FramedServiceImplResponseInner::Dispatcher(FramedDispatcher::new(
-                                res.framed,
-                                State::new(res.state),
-                                handler,
-                                res.rx,
-                                res.sink,
-                                self.disconnect.clone(),
-                            ));
-                        self.poll()
-                    }
-                    Async::NotReady => Ok(Async::NotReady),
-                }
-            }
-            FramedServiceImplResponseInner::Dispatcher(ref mut fut) => fut.poll(),
-        }
-    }
-}

actix-ioframe/src/sink.rs

@@ -1,44 +0,0 @@
-use std::fmt;
-
-use futures::unsync::{mpsc, oneshot};
-use futures::Future;
-
-use crate::dispatcher::FramedMessage;
-
-pub struct Sink<T>(mpsc::UnboundedSender<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::UnboundedSender<FramedMessage<T>>) -> Self {
-        Sink(tx)
-    }
-
-    /// Close connection
-    pub fn close(&self) {
-        let _ = self.0.unbounded_send(FramedMessage::Close);
-    }
-
-    /// Close connection
-    pub fn wait_close(&self) -> impl Future<Item = (), Error = ()> {
-        let (tx, rx) = oneshot::channel();
-        let _ = self.0.unbounded_send(FramedMessage::WaitClose(tx));
-
-        rx.map_err(|_| ())
-    }
-
-    /// Send item
-    pub fn send(&self, item: T) {
-        let _ = self.0.unbounded_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,60 +0,0 @@
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
-use std::time::Duration;
-
-use actix_codec::BytesCodec;
-use actix_server_config::Io;
-use actix_service::{new_apply_fn, Service};
-use actix_test_server::TestServer;
-use futures::Future;
-use tokio_tcp::TcpStream;
-use tokio_timer::sleep;
-
-use actix_ioframe::{Builder, Connect};
-
-struct State;
-
-#[test]
-fn test_disconnect() -> std::io::Result<()> {
-    let disconnect = Arc::new(AtomicBool::new(false));
-    let disconnect1 = disconnect.clone();
-
-    let mut srv = TestServer::with(move || {
-        let disconnect1 = disconnect1.clone();
-
-        new_apply_fn(
-            Builder::new()
-                .factory(|conn: Connect<_>| Ok(conn.codec(BytesCodec).state(State)))
-                .disconnect(move |_, _| {
-                    disconnect1.store(true, Ordering::Relaxed);
-                })
-                .finish(|_t| Ok(None)),
-            |io: Io<TcpStream>, srv| srv.call(io.into_parts().0),
-        )
-    });
-
-    let mut client = Builder::new()
-        .service(|conn: Connect<_>| {
-            let conn = conn.codec(BytesCodec).state(State);
-            conn.sink().close();
-            Ok(conn)
-        })
-        .finish(|_t| Ok(None));
-
-    let conn = srv
-        .block_on(
-            actix_connect::default_connector()
-                .call(actix_connect::Connect::with(String::new(), srv.addr())),
-        )
-        .unwrap();
-
-    srv.block_on(client.call(conn.into_parts().0)).unwrap();
-    let _ = srv.block_on(
-        sleep(Duration::from_millis(100))
-            .map(|_| ())
-            .map_err(|_| ()),
-    );
-    assert!(disconnect.load(Ordering::Relaxed));
-
-    Ok(())
-}

actix-rt/CHANGES.md

@@ -1,44 +0,0 @@
-# Changes
-
-## [0.2.4] - 2019-07-17
-
-### Changed
-
-* Avoid a copy of the Future when initializing the Box. #29
-
-
-## [0.2.3] - 2019-06-22
-
-### Added
-
-* Allow to start System using exsiting CurrentThread Handle #22
-
-
-## [0.2.2] - 2019-03-28
-
-### Changed
-
-* Moved `blocking` module to `actix-threadpool` crate
-
-
-## [0.2.1] - 2019-03-11
-
-### Added
-
-* Added `blocking` module
-
-* Arbiter::exec_fn - execute fn on the arbiter's thread
-
-* Arbiter::exec - execute fn on the arbiter's thread and wait result
-
-
-## [0.2.0] - 2019-03-06
-
-* `run` method returns `io::Result<()>`
-
-* Removed `Handle`
-
-
-## [0.1.0] - 2018-12-09
-
-* Initial release

actix-rt/Cargo.toml

@@ -1,27 +0,0 @@
-[package]
-name = "actix-rt"
-version = "0.2.4"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix runtime"
-keywords = ["network", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-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.1.1"
-futures = "0.1.25"
-tokio-current-thread = "0.1"
-tokio-executor = "0.1.5"
-tokio-reactor = "0.1.7"
-tokio-timer = "0.2.8"
-copyless = "0.1.4"

actix-rt/LICENSE-APACHE

@@ -1 +0,0 @@
-../LICENSE-APACHE

actix-rt/LICENSE-MIT

@@ -1 +0,0 @@
-../LICENSE-MIT

actix-rt/src/arbiter.rs

@@ -1,319 +0,0 @@
-use std::cell::{Cell, RefCell};
-use std::collections::HashMap;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::{fmt, thread};
-
-use futures::sync::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
-use futures::sync::oneshot::{channel, Canceled, Sender};
-use futures::{future, Async, Future, IntoFuture, Poll, Stream};
-use tokio_current_thread::spawn;
-
-use crate::builder::Builder;
-use crate::system::System;
-
-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<Future<Item = (), Error = ()>>>> = RefCell::new(Vec::new());
-);
-
-pub(crate) static COUNT: AtomicUsize = AtomicUsize::new(0);
-
-pub(crate) enum ArbiterCommand {
-    Stop,
-    Execute(Box<Future<Item = (), Error = ()> + Send>),
-    ExecuteFn(Box<FnExec>),
-}
-
-impl fmt::Debug for ArbiterCommand {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            ArbiterCommand::Stop => write!(f, "ArbiterCommand::Stop"),
-            ArbiterCommand::Execute(_) => write!(f, "ArbiterCommand::Execute"),
-            ArbiterCommand::ExecuteFn(_) => write!(f, "ArbiterCommand::ExecuteFn"),
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-/// Arbiters provide an asynchronous execution environment for actors, functions
-/// and futures. When an Arbiter is created, they spawn a new OS thread, and
-/// host an event loop. Some Arbiter functions execute on the current thread.
-pub struct Arbiter(UnboundedSender<ArbiterCommand>);
-
-impl Default for Arbiter {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Arbiter {
-    pub(crate) fn new_system() -> Self {
-        let (tx, rx) = unbounded();
-
-        let arb = Arbiter(tx);
-        ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
-        RUNNING.with(|cell| cell.set(false));
-        Arbiter::spawn(ArbiterController { stop: None, rx });
-
-        arb
-    }
-
-    /// Returns the current thread's arbiter's address. If no Arbiter is present, then this
-    /// function will panic!
-    pub fn current() -> Arbiter {
-        ADDR.with(|cell| match *cell.borrow() {
-            Some(ref addr) => addr.clone(),
-            None => panic!("Arbiter is not running"),
-        })
-    }
-
-    /// Stop arbiter from continuing it's event loop.
-    pub fn stop(&self) {
-        let _ = self.0.unbounded_send(ArbiterCommand::Stop);
-    }
-
-    /// Spawn new thread and run event loop in spawned thread.
-    /// Returns address of newly created arbiter.
-    pub fn new() -> Arbiter {
-        let id = COUNT.fetch_add(1, Ordering::Relaxed);
-        let name = format!("actix-rt:worker:{}", id);
-        let sys = System::current();
-        let (arb_tx, arb_rx) = unbounded();
-        let arb_tx2 = arb_tx.clone();
-
-        let _ = thread::Builder::new().name(name.clone()).spawn(move || {
-            let mut rt = Builder::new().build_rt().expect("Can not create Runtime");
-            let arb = Arbiter(arb_tx);
-
-            let (stop, stop_rx) = channel();
-            RUNNING.with(|cell| cell.set(true));
-
-            System::set_current(sys);
-
-            // start arbiter controller
-            rt.spawn(ArbiterController {
-                stop: Some(stop),
-                rx: arb_rx,
-            });
-            ADDR.with(|cell| *cell.borrow_mut() = Some(arb.clone()));
-
-            // register arbiter
-            let _ = System::current()
-                .sys()
-                .unbounded_send(SystemCommand::RegisterArbiter(id, arb.clone()));
-
-            // run loop
-            let _ = match rt.block_on(stop_rx) {
-                Ok(code) => code,
-                Err(_) => 1,
-            };
-
-            // unregister arbiter
-            let _ = System::current()
-                .sys()
-                .unbounded_send(SystemCommand::UnregisterArbiter(id));
-        });
-
-        Arbiter(arb_tx2)
-    }
-
-    pub(crate) fn run_system() {
-        RUNNING.with(|cell| cell.set(true));
-        Q.with(|cell| {
-            let mut v = cell.borrow_mut();
-            for fut in v.drain(..) {
-                spawn(fut);
-            }
-        });
-    }
-
-    pub(crate) fn stop_system() {
-        RUNNING.with(|cell| cell.set(false));
-    }
-
-    /// Spawn a future on the current thread. This does not create a new Arbiter
-    /// or Arbiter address, it is simply a helper for spawning futures on the current
-    /// thread.
-    pub fn spawn<F>(future: F)
-    where
-        F: Future<Item = (), Error = ()> + 'static,
-    {
-        RUNNING.with(move |cell| {
-            if cell.get() {
-                spawn(Box::alloc().init(future));
-            } else {
-                Q.with(move |cell| cell.borrow_mut().push(Box::alloc().init(future)));
-            }
-        });
-    }
-
-    /// Executes a future on the current thread. This does not create a new Arbiter
-    /// or Arbiter address, it is simply a helper for executing futures on the current
-    /// thread.
-    pub fn spawn_fn<F, R>(f: F)
-    where
-        F: FnOnce() -> R + 'static,
-        R: IntoFuture<Item = (), Error = ()> + 'static,
-    {
-        Arbiter::spawn(future::lazy(f))
-    }
-
-    /// Send a future to the Arbiter's thread, and spawn it.
-    pub fn send<F>(&self, future: F)
-    where
-        F: Future<Item = (), Error = ()> + Send + 'static,
-    {
-        let _ = self
-            .0
-            .unbounded_send(ArbiterCommand::Execute(Box::new(future)));
-    }
-
-    /// Send a function to the Arbiter's thread, and execute it. Any result from the function
-    /// is discarded.
-    pub fn exec_fn<F>(&self, f: F)
-    where
-        F: FnOnce() + Send + 'static,
-    {
-        let _ = self
-            .0
-            .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || {
-                let _ = f();
-            })));
-    }
-
-    /// Send a function to the Arbiter's thread. This function will be executed asynchronously.
-    /// A future is created, and when resolved will contain the result of the function sent
-    /// to the Arbiters thread.
-    pub fn exec<F, R>(&self, f: F) -> impl Future<Item = R, Error = Canceled>
-    where
-        F: FnOnce() -> R + Send + 'static,
-        R: Send + 'static,
-    {
-        let (tx, rx) = channel();
-        let _ = self
-            .0
-            .unbounded_send(ArbiterCommand::ExecuteFn(Box::new(move || {
-                if !tx.is_canceled() {
-                    let _ = tx.send(f());
-                }
-            })));
-        rx
-    }
-}
-
-struct ArbiterController {
-    stop: Option<Sender<i32>>,
-    rx: UnboundedReceiver<ArbiterCommand>,
-}
-
-impl Drop for ArbiterController {
-    fn drop(&mut self) {
-        if thread::panicking() {
-            eprintln!("Panic in Arbiter thread, shutting down system.");
-            if System::current().stop_on_panic() {
-                System::current().stop_with_code(1)
-            }
-        }
-    }
-}
-
-impl Future for ArbiterController {
-    type Item = ();
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        loop {
-            match self.rx.poll() {
-                Ok(Async::Ready(None)) | Err(_) => return Ok(Async::Ready(())),
-                Ok(Async::Ready(Some(item))) => match item {
-                    ArbiterCommand::Stop => {
-                        if let Some(stop) = self.stop.take() {
-                            let _ = stop.send(0);
-                        };
-                        return Ok(Async::Ready(()));
-                    }
-                    ArbiterCommand::Execute(fut) => {
-                        spawn(fut);
-                    }
-                    ArbiterCommand::ExecuteFn(f) => {
-                        f.call_box();
-                    }
-                },
-                Ok(Async::NotReady) => return Ok(Async::NotReady),
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-pub(crate) enum SystemCommand {
-    Exit(i32),
-    RegisterArbiter(usize, Arbiter),
-    UnregisterArbiter(usize),
-}
-
-#[derive(Debug)]
-pub(crate) struct SystemArbiter {
-    stop: Option<Sender<i32>>,
-    commands: UnboundedReceiver<SystemCommand>,
-    arbiters: HashMap<usize, Arbiter>,
-}
-
-impl SystemArbiter {
-    pub(crate) fn new(stop: Sender<i32>, commands: UnboundedReceiver<SystemCommand>) -> Self {
-        SystemArbiter {
-            commands,
-            stop: Some(stop),
-            arbiters: HashMap::new(),
-        }
-    }
-}
-
-impl Future for SystemArbiter {
-    type Item = ();
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        loop {
-            match self.commands.poll() {
-                Ok(Async::Ready(None)) | Err(_) => return Ok(Async::Ready(())),
-                Ok(Async::Ready(Some(cmd))) => match cmd {
-                    SystemCommand::Exit(code) => {
-                        // stop arbiters
-                        for arb in self.arbiters.values() {
-                            arb.stop();
-                        }
-                        // stop event loop
-                        if let Some(stop) = self.stop.take() {
-                            let _ = stop.send(code);
-                        }
-                    }
-                    SystemCommand::RegisterArbiter(name, hnd) => {
-                        self.arbiters.insert(name, hnd);
-                    }
-                    SystemCommand::UnregisterArbiter(name) => {
-                        self.arbiters.remove(&name);
-                    }
-                },
-                Ok(Async::NotReady) => return Ok(Async::NotReady),
-            }
-        }
-    }
-}
-
-pub trait FnExec: Send + 'static {
-    fn call_box(self: Box<Self>);
-}
-
-impl<F> FnExec for F
-where
-    F: FnOnce() + Send + 'static,
-{
-    #[cfg_attr(feature = "cargo-clippy", allow(boxed_local))]
-    fn call_box(self: Box<Self>) {
-        (*self)()
-    }
-}

actix-rt/src/builder.rs

@@ -1,242 +0,0 @@
-use std::borrow::Cow;
-use std::io;
-
-use futures::future;
-use futures::future::{lazy, Future};
-use futures::sync::mpsc::unbounded;
-use futures::sync::oneshot::{channel, Receiver};
-
-use tokio_current_thread::{CurrentThread, Handle};
-use tokio_reactor::Reactor;
-use tokio_timer::clock::Clock;
-use tokio_timer::timer::Timer;
-
-use crate::arbiter::{Arbiter, SystemArbiter};
-use crate::runtime::Runtime;
-use crate::system::System;
-
-/// Builder struct for a actix runtime.
-///
-/// Either use `Builder::build` to create a system and start actors.
-/// Alternatively, use `Builder::run` to start the tokio runtime and
-/// run a function in its context.
-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,
-}
-
-impl Builder {
-    pub(crate) fn new() -> Self {
-        Builder {
-            name: Cow::Borrowed("actix"),
-            clock: Clock::new(),
-            stop_on_panic: false,
-        }
-    }
-
-    /// Sets the name of the System.
-    pub fn name<T: Into<String>>(mut self, name: T) -> Self {
-        self.name = Cow::Owned(name.into());
-        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.
-    ///
-    /// Defaults to false.
-    pub fn stop_on_panic(mut self, stop_on_panic: bool) -> Self {
-        self.stop_on_panic = stop_on_panic;
-        self
-    }
-
-    /// Create new System.
-    ///
-    /// This method panics if it can not create tokio runtime
-    pub fn build(self) -> SystemRunner {
-        self.create_runtime(|| {})
-    }
-
-    /// 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)
-    }
-
-    /// This function will start tokio runtime and will finish once the
-    /// `System::stop()` message get called.
-    /// Function `f` get called within tokio runtime context.
-    pub fn run<F>(self, f: F) -> io::Result<()>
-    where
-        F: FnOnce() + 'static,
-    {
-        self.create_runtime(f).run()
-    }
-
-    fn create_async_runtime(self, executor: Handle) -> AsyncSystemRunner {
-        let (stop_tx, stop) = channel();
-        let (sys_sender, sys_receiver) = unbounded();
-
-        let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic);
-
-        // system arbiter
-        let arb = SystemArbiter::new(stop_tx, sys_receiver);
-
-        // start the system arbiter
-        executor.spawn(arb).expect("could not start system arbiter");
-
-        AsyncSystemRunner { stop, system }
-    }
-
-    fn create_runtime<F>(self, f: F) -> SystemRunner
-    where
-        F: FnOnce() + 'static,
-    {
-        let (stop_tx, stop) = channel();
-        let (sys_sender, sys_receiver) = unbounded();
-
-        let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic);
-
-        // system arbiter
-        let arb = SystemArbiter::new(stop_tx, sys_receiver);
-
-        let mut rt = self.build_rt().unwrap();
-        rt.spawn(arb);
-
-        // init system arbiter and run configuration method
-        let _ = rt.block_on(lazy(move || {
-            f();
-            Ok::<_, ()>(())
-        }));
-
-        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)]
-pub(crate) struct AsyncSystemRunner {
-    stop: Receiver<i32>,
-    system: System,
-}
-
-impl AsyncSystemRunner {
-    /// This function will start event loop and returns a future that
-    /// resolves once the `System::stop()` function is called.
-    pub(crate) fn run_nonblocking(self) -> impl Future<Item = (), Error = io::Error> + Send {
-        let AsyncSystemRunner { stop, .. } = self;
-
-        // run loop
-        future::lazy(|| {
-            Arbiter::run_system();
-            stop.then(|res| match res {
-                Ok(code) => {
-                    if code != 0 {
-                        Err(io::Error::new(
-                            io::ErrorKind::Other,
-                            format!("Non-zero exit code: {}", code),
-                        ))
-                    } else {
-                        Ok(())
-                    }
-                }
-                Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
-            })
-            .then(|result| {
-                Arbiter::stop_system();
-                result
-            })
-        })
-    }
-}
-
-/// Helper object that runs System's event loop
-#[must_use = "SystemRunner must be run"]
-#[derive(Debug)]
-pub struct SystemRunner {
-    rt: Runtime,
-    stop: Receiver<i32>,
-    system: System,
-}
-
-impl SystemRunner {
-    /// This function will start event loop and will finish once the
-    /// `System::stop()` function is called.
-    pub fn run(self) -> io::Result<()> {
-        let SystemRunner { mut rt, stop, .. } = self;
-
-        // run loop
-        let _ = rt.block_on(lazy(move || {
-            Arbiter::run_system();
-            Ok::<_, ()>(())
-        }));
-        let result = match rt.block_on(stop) {
-            Ok(code) => {
-                if code != 0 {
-                    Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        format!("Non-zero exit code: {}", code),
-                    ))
-                } else {
-                    Ok(())
-                }
-            }
-            Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
-        };
-        Arbiter::stop_system();
-        result
-    }
-
-    /// Execute a future and wait for result.
-    pub fn block_on<F, I, E>(&mut self, fut: F) -> Result<I, E>
-    where
-        F: Future<Item = I, Error = E>,
-    {
-        let _ = self.rt.block_on(lazy(move || {
-            Arbiter::run_system();
-            Ok::<_, ()>(())
-        }));
-        let res = self.rt.block_on(fut);
-        let _ = self.rt.block_on(lazy(move || {
-            Arbiter::stop_system();
-            Ok::<_, ()>(())
-        }));
-        res
-    }
-}

actix-rt/src/lib.rs

@@ -1,30 +0,0 @@
-//! A runtime implementation that runs everything on the current thread.
-
-mod arbiter;
-mod builder;
-mod runtime;
-mod system;
-
-pub use self::arbiter::Arbiter;
-pub use self::builder::{Builder, SystemRunner};
-pub use self::runtime::Runtime;
-pub use self::system::System;
-
-#[doc(hidden)]
-pub use actix_threadpool as blocking;
-
-/// Spawns a future on the current arbiter.
-///
-/// # Panics
-///
-/// This function panics if actix system is not running.
-pub fn spawn<F>(f: F)
-where
-    F: futures::Future<Item = (), Error = ()> + 'static,
-{
-    if !System::is_set() {
-        panic!("System is not running");
-    }
-
-    Arbiter::spawn(f);
-}

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,174 +0,0 @@
-use std::error::Error;
-use std::{fmt, io};
-
-use futures::Future;
-use tokio_current_thread::{self as current_thread, CurrentThread};
-use tokio_executor;
-use tokio_reactor::{self, Reactor};
-use tokio_timer::clock::{self, Clock};
-use tokio_timer::timer::{self, Timer};
-
-use crate::builder::Builder;
-
-/// Single-threaded runtime provides a way to start reactor
-/// and executor on the current thread.
-///
-/// See [module level][mod] documentation for more details.
-///
-/// [mod]: index.html
-#[derive(Debug)]
-pub struct Runtime {
-    reactor_handle: tokio_reactor::Handle,
-    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<&Error> {
-        self.inner.source()
-    }
-}
-
-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()
-    }
-
-    pub(super) fn new2(
-        reactor_handle: tokio_reactor::Handle,
-        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.
-    ///
-    /// See [module level][mod] documentation for more details.
-    ///
-    /// [mod]: index.html
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use futures::{future, Future, Stream};
-    /// use actix_rt::Runtime;
-    ///
-    /// # fn dox() {
-    /// // Create the runtime
-    /// let mut rt = Runtime::new().unwrap();
-    ///
-    /// // Spawn a future onto the runtime
-    /// rt.spawn(future::lazy(|| {
-    ///     println!("running on the runtime");
-    ///     Ok(())
-    /// }));
-    /// # }
-    /// # pub fn main() {}
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// 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
-    where
-        F: Future<Item = (), Error = ()> + 'static,
-    {
-        self.executor.spawn(future);
-        self
-    }
-
-    /// 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 will **also** execute any spawned futures on the
-    /// current thread, but will **not** block until these other spawned futures
-    /// have completed. Once the function returns, any uncompleted futures
-    /// remain pending in the `Runtime` instance. These futures will not run
-    /// until `block_on` or `run` is called again.
-    ///
-    /// The caller is responsible for ensuring that other spawned futures
-    /// complete execution by calling `block_on` or `run`.
-    pub fn block_on<F>(&mut self, f: F) -> Result<F::Item, F::Error>
-    where
-        F: Future,
-    {
-        self.enter(|executor| {
-            // Run the provided future
-            let ret = executor.block_on(f);
-            ret.map_err(|e| e.into_inner().expect("unexpected execution error"))
-        })
-    }
-
-    /// 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 current_thread::Entered<Timer<Reactor>>) -> R,
-    {
-        let Runtime {
-            ref reactor_handle,
-            ref timer_handle,
-            ref clock,
-            ref mut executor,
-            ..
-        } = *self;
-
-        // Binds an executor to this thread
-        let mut enter = tokio_executor::enter().expect("Multiple executors at once");
-
-        // This will set the default handle and timer to use inside the closure
-        // and run the future.
-        tokio_reactor::with_default(&reactor_handle, &mut enter, |enter| {
-            clock::with_default(clock, enter, |enter| {
-                timer::with_default(&timer_handle, enter, |enter| {
-                    // The TaskExecutor is a fake executor that looks into the
-                    // current single-threaded executor when used. This is a trick,
-                    // because we need two mutable references to the executor (one
-                    // to run the provided future, another to install as the default
-                    // one). We use the fake one here as the default one.
-                    let mut default_executor = current_thread::TaskExecutor::current();
-                    tokio_executor::with_default(&mut default_executor, enter, |enter| {
-                        let mut executor = executor.enter(enter);
-                        f(&mut executor)
-                    })
-                })
-            })
-        })
-    }
-}

actix-rt/src/system.rs

@@ -1,145 +0,0 @@
-use std::cell::RefCell;
-use std::io;
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-use futures::sync::mpsc::UnboundedSender;
-use futures::Future;
-use tokio_current_thread::Handle;
-
-use crate::arbiter::{Arbiter, SystemCommand};
-use crate::builder::{Builder, SystemRunner};
-
-static SYSTEM_COUNT: AtomicUsize = AtomicUsize::new(0);
-
-/// System is a runtime manager.
-#[derive(Clone, Debug)]
-pub struct System {
-    id: usize,
-    sys: UnboundedSender<SystemCommand>,
-    arbiter: Arbiter,
-    stop_on_panic: bool,
-}
-
-thread_local!(
-    static CURRENT: RefCell<Option<System>> = RefCell::new(None);
-);
-
-impl System {
-    /// Constructs new system and sets it as current
-    pub(crate) fn construct(
-        sys: UnboundedSender<SystemCommand>,
-        arbiter: Arbiter,
-        stop_on_panic: bool,
-    ) -> Self {
-        let sys = System {
-            sys,
-            arbiter,
-            stop_on_panic,
-            id: SYSTEM_COUNT.fetch_add(1, Ordering::SeqCst),
-        };
-        System::set_current(sys.clone());
-        sys
-    }
-
-    /// Build a new system with a customized tokio runtime.
-    ///
-    /// This allows to customize the runtime. See struct level docs on
-    /// `Builder` for more information.
-    pub fn builder() -> Builder {
-        Builder::new()
-    }
-
-    #[allow(clippy::new_ret_no_self)]
-    /// Create new system.
-    ///
-    /// This method panics if it can not create tokio runtime
-    pub fn new<T: Into<String>>(name: T) -> SystemRunner {
-        Self::builder().name(name).build()
-    }
-
-    #[allow(clippy::new_ret_no_self)]
-    /// Create new system using provided CurrentThread Handle.
-    ///
-    /// This method panics if it can not spawn system arbiter
-    pub fn run_in_executor<T: Into<String>>(
-        name: T,
-        executor: Handle,
-    ) -> impl Future<Item = (), Error = io::Error> + Send {
-        Self::builder()
-            .name(name)
-            .build_async(executor)
-            .run_nonblocking()
-    }
-
-    /// Get current running system.
-    pub fn current() -> System {
-        CURRENT.with(|cell| match *cell.borrow() {
-            Some(ref sys) => sys.clone(),
-            None => panic!("System is not running"),
-        })
-    }
-
-    /// Set current running system.
-    pub(crate) fn is_set() -> bool {
-        CURRENT.with(|cell| cell.borrow().is_some())
-    }
-
-    /// Set current running system.
-    #[doc(hidden)]
-    pub fn set_current(sys: System) {
-        CURRENT.with(|s| {
-            *s.borrow_mut() = Some(sys);
-        })
-    }
-
-    /// Execute function with system reference.
-    pub fn with_current<F, R>(f: F) -> R
-    where
-        F: FnOnce(&System) -> R,
-    {
-        CURRENT.with(|cell| match *cell.borrow() {
-            Some(ref sys) => f(sys),
-            None => panic!("System is not running"),
-        })
-    }
-
-    /// System id
-    pub fn id(&self) -> usize {
-        self.id
-    }
-
-    /// Stop the system
-    pub fn stop(&self) {
-        self.stop_with_code(0)
-    }
-
-    /// Stop the system with a particular exit code.
-    pub fn stop_with_code(&self, code: i32) {
-        let _ = self.sys.unbounded_send(SystemCommand::Exit(code));
-    }
-
-    pub(crate) fn sys(&self) -> &UnboundedSender<SystemCommand> {
-        &self.sys
-    }
-
-    /// Return status of 'stop_on_panic' option which controls whether the System is stopped when an
-    /// uncaught panic is thrown from a worker thread.
-    pub fn stop_on_panic(&self) -> bool {
-        self.stop_on_panic
-    }
-
-    /// System arbiter
-    pub fn arbiter(&self) -> &Arbiter {
-        &self.arbiter
-    }
-
-    /// This function will start tokio runtime and will finish once the
-    /// `System::stop()` message get called.
-    /// Function `f` get called within tokio runtime context.
-    pub fn run<F>(f: F) -> io::Result<()>
-    where
-        F: FnOnce() + 'static,
-    {
-        Self::builder().run(f)
-    }
-}

actix-server-config/Cargo.toml

@@ -1,38 +0,0 @@
-[package]
-name = "actix-server-config"
-version = "0.1.2"
-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 = ["ssl", "rust-tls", "uds"]
-
-[features]
-default = []
-
-# openssl
-ssl = ["tokio-openssl"]
-
-# rustls
-rust-tls = ["rustls", "tokio-rustls"]
-
-# unix domain sockets
-uds = ["tokio-uds"]
-
-[dependencies]
-futures = "0.1.25"
-tokio-io = "0.1.12"
-tokio-tcp = "0.1"
-tokio-openssl = { version="0.3.0", optional = true }
-rustls = { version = "0.15.2", optional = true }
-tokio-rustls = { version = "0.9.1", optional = true }
-tokio-uds = { version="0.2.5", optional = true }

actix-server-config/LICENSE-APACHE

@@ -1 +0,0 @@
-../LICENSE-APACHE

actix-server-config/LICENSE-MIT

@@ -1 +0,0 @@
-../LICENSE-MIT

actix-server-config/changes.md

@@ -1,14 +0,0 @@
-# Changes
-
-## [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,241 +0,0 @@
-use std::cell::Cell;
-use std::net::SocketAddr;
-use std::rc::Rc;
-use std::{fmt, io, net, time};
-
-use tokio_io::{AsyncRead, AsyncWrite};
-use tokio_tcp::TcpStream;
-
-#[derive(Debug, Clone)]
-pub struct ServerConfig {
-    addr: SocketAddr,
-    secure: Rc<Cell<bool>>,
-}
-
-impl ServerConfig {
-    pub fn new(addr: SocketAddr) -> Self {
-        ServerConfig {
-            addr,
-            secure: Rc::new(Cell::new(false)),
-        }
-    }
-
-    /// Returns the address of the local half of this TCP server socket
-    pub fn local_addr(&self) -> SocketAddr {
-        self.addr
-    }
-
-    /// Returns true if connection is secure (tls enabled)
-    pub fn secure(&self) -> bool {
-        self.secure.as_ref().get()
-    }
-
-    /// Set secure flag
-    pub fn set_secure(&self) {
-        self.secure.as_ref().set(true)
-    }
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum Protocol {
-    Unknown,
-    Http10,
-    Http11,
-    Http2,
-    Proto1,
-    Proto2,
-    Proto3,
-    Proto4,
-    Proto5,
-    Proto6,
-}
-
-pub struct Io<T, P = ()> {
-    io: T,
-    proto: Protocol,
-    params: P,
-}
-
-impl<T> Io<T, ()> {
-    pub fn new(io: T) -> Self {
-        Self {
-            io,
-            proto: Protocol::Unknown,
-            params: (),
-        }
-    }
-}
-
-impl<T, P> Io<T, P> {
-    /// Reconstruct from a parts.
-    pub fn from_parts(io: T, params: P, proto: Protocol) -> Self {
-        Self { io, params, proto }
-    }
-
-    /// Deconstruct into a parts.
-    pub fn into_parts(self) -> (T, P, Protocol) {
-        (self.io, self.params, self.proto)
-    }
-
-    /// Returns a shared reference to the underlying stream.
-    pub fn get_ref(&self) -> &T {
-        &self.io
-    }
-
-    /// Returns a mutable reference to the underlying stream.
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.io
-    }
-
-    /// Get selected protocol
-    pub fn protocol(&self) -> Protocol {
-        self.proto
-    }
-
-    /// 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> std::ops::Deref for Io<T, P> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        &self.io
-    }
-}
-
-impl<T, P> std::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 {
-    /// 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(any(feature = "ssl"))]
-impl<T: IoStream> IoStream for tokio_openssl::SslStream<T> {
-    #[inline]
-    fn peer_addr(&self) -> Option<net::SocketAddr> {
-        self.get_ref().get_ref().peer_addr()
-    }
-
-    #[inline]
-    fn set_nodelay(&mut self, nodelay: bool) -> io::Result<()> {
-        self.get_mut().get_mut().set_nodelay(nodelay)
-    }
-
-    #[inline]
-    fn set_linger(&mut self, dur: Option<time::Duration>) -> io::Result<()> {
-        self.get_mut().get_mut().set_linger(dur)
-    }
-
-    #[inline]
-    fn set_keepalive(&mut self, dur: Option<time::Duration>) -> io::Result<()> {
-        self.get_mut().get_mut().set_keepalive(dur)
-    }
-}
-
-#[cfg(any(feature = "rust-tls"))]
-impl<T: IoStream> IoStream for tokio_rustls::TlsStream<T, rustls::ServerSession> {
-    #[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(all(unix, feature = "uds"))]
-impl IoStream for tokio_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,131 +0,0 @@
-# Changes
-
-## [0.6.0] - 2019-07-18
-
-### Added
-
-* Support Unix domain sockets #3
-
-
-## [0.5.1] - 2019-05-18
-
-### Changed
-
-* ServerBuilder::shutdown_timeout() accepts u64
-
-
-## [0.5.0] - 2019-05-12
-
-### Added
-
-* Add `Debug` impl for `SslError`
-
-* Derive debug for `Server` and `ServerCommand`
-
-### Changed
-
-* Upgrade to actix-service 0.4
-
-
-## [0.4.3] - 2019-04-16
-
-### Added
-
-* Re-export `IoStream` trait
-
-### Changed
-
-* Deppend on `ssl` and `rust-tls` features from actix-server-config
-
-
-## [0.4.2] - 2019-03-30
-
-### Fixed
-
-* Fix SIGINT force shutdown
-
-
-## [0.4.1] - 2019-03-14
-
-### Added
-
-* `SystemRuntime::on_start()` - allow to run future before server service initialization
-
-
-## [0.4.0] - 2019-03-12
-
-### Changed
-
-* Use `ServerConfig` for service factory
-
-* Wrap tcp socket to `Io` type
-
-* Upgrade actix-service
-
-
-## [0.3.1] - 2019-03-04
-
-### Added
-
-* Add `ServerBuilder::maxconnrate` sets the maximum per-worker number of concurrent connections
-
-* Add helper ssl error `SslError`
-
-
-### Changed
-
-* Rename `StreamServiceFactory` to `ServiceFactory`
-
-* Deprecate `StreamServiceFactory`
-
-
-## [0.3.0] - 2019-03-02
-
-### Changed
-
-* Use new `NewService` trait
-
-
-## [0.2.1] - 2019-02-09
-
-### Changed
-
-* Drop service response
-
-
-## [0.2.0] - 2019-02-01
-
-### Changed
-
-* Migrate to actix-service 0.2
-
-* Updated rustls dependency
-
-
-## [0.1.3] - 2018-12-21
-
-### Fixed
-
-* Fix max concurrent connections handling
-
-
-## [0.1.2] - 2018-12-12
-
-### Changed
-
-* rename ServiceConfig::rt() to ServiceConfig::apply()
-
-
-### Fixed
-
-* Fix back-pressure for concurrent ssl handshakes
-
-
-## [0.1.1] - 2018-12-11
-
-* Fix signal handling on windows
-
-
-## [0.1.0] - 2018-12-09
-
-* Move server to separate crate

actix-server/Cargo.toml

@@ -1,76 +0,0 @@
-[package]
-name = "actix-server"
-version = "0.6.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix server - General purpose tcp server"
-keywords = ["network", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-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", "uds"]
-
-[lib]
-name = "actix_server"
-path = "src/lib.rs"
-
-[features]
-default = []
-
-# tls
-tls = ["native-tls"]
-
-# openssl
-ssl = ["openssl", "tokio-openssl", "actix-server-config/ssl"]
-
-# rustls
-rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots", "actix-server-config/rust-tls"]
-
-# uds
-uds = ["mio-uds", "tokio-uds", "actix-server-config/uds"]
-
-[dependencies]
-actix-rt = "0.2.2"
-actix-service = "0.4.1"
-actix-server-config = "0.1.2"
-
-log = "0.4"
-num_cpus = "1.0"
-
-mio = "0.6.19"
-net2 = "0.2"
-futures = "0.1"
-slab = "0.4"
-tokio-io = "0.1"
-tokio-tcp = "0.1"
-tokio-timer = "0.2.8"
-tokio-reactor = "0.1"
-tokio-signal = "0.2"
-
-# unix domain sockets
-mio-uds = { version="0.6.7", optional = true }
-tokio-uds = { version="0.2.5", optional = true }
-
-# native-tls
-native-tls = { version="0.2", optional = true }
-
-# openssl
-openssl = { version="0.10", optional = true }
-tokio-openssl = { version="0.3", optional = true }
-
-# rustls
-rustls = { version = "0.15.2", optional = true }
-tokio-rustls = { version = "0.9.1", optional = true }
-webpki = { version = "0.19", optional = true }
-webpki-roots = { version = "0.16", optional = true }
-
-[dev-dependencies]
-bytes = "0.4"
-actix-codec = "0.1.2"
-env_logger = "0.6"

actix-server/LICENSE-APACHE

@@ -1 +0,0 @@
-../LICENSE-APACHE

actix-server/LICENSE-MIT

@@ -1 +0,0 @@
-../LICENSE-MIT

actix-server/src/builder.rs

@@ -1,482 +0,0 @@
-use std::time::Duration;
-use std::{io, mem, net};
-
-use actix_rt::{spawn, Arbiter, System};
-use futures::future::{lazy, ok};
-use futures::stream::futures_unordered;
-use futures::sync::mpsc::{unbounded, UnboundedReceiver};
-use futures::{Async, Future, Poll, Stream};
-use log::{error, info};
-use net2::TcpBuilder;
-use num_cpus;
-use tokio_tcp::TcpStream;
-use tokio_timer::sleep;
-
-use crate::accept::{AcceptLoop, AcceptNotify, Command};
-use crate::config::{ConfiguredService, ServiceConfig};
-use crate::server::{Server, ServerCommand};
-use crate::services::{InternalServiceFactory, ServiceFactory, StreamNewService};
-use crate::signals::{Signal, Signals};
-use crate::socket::StdListener;
-use crate::worker::{self, Worker, WorkerAvailability, WorkerClient};
-use crate::{ssl, Token};
-
-/// Server builder
-pub struct ServerBuilder {
-    threads: usize,
-    token: Token,
-    backlog: i32,
-    workers: Vec<(usize, WorkerClient)>,
-    services: Vec<Box<dyn InternalServiceFactory>>,
-    sockets: Vec<(Token, StdListener)>,
-    accept: AcceptLoop,
-    exit: bool,
-    shutdown_timeout: Duration,
-    no_signals: bool,
-    cmd: UnboundedReceiver<ServerCommand>,
-    server: Server,
-}
-
-impl Default for ServerBuilder {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl ServerBuilder {
-    /// Create new Server builder instance
-    pub fn new() -> ServerBuilder {
-        let (tx, rx) = unbounded();
-        let server = Server::new(tx);
-
-        ServerBuilder {
-            threads: num_cpus::get(),
-            token: Token(0),
-            workers: Vec::new(),
-            services: Vec::new(),
-            sockets: Vec::new(),
-            accept: AcceptLoop::new(server.clone()),
-            backlog: 2048,
-            exit: false,
-            shutdown_timeout: Duration::from_secs(30),
-            no_signals: false,
-            cmd: rx,
-            server,
-        }
-    }
-
-    /// Set number of workers to start.
-    ///
-    /// By default server uses number of available logical cpu as workers
-    /// count.
-    pub fn workers(mut self, num: usize) -> Self {
-        self.threads = num;
-        self
-    }
-
-    /// Set the maximum number of pending connections.
-    ///
-    /// This refers to the number of clients that can be waiting to be served.
-    /// Exceeding this number results in the client getting an error when
-    /// attempting to connect. It should only affect servers under significant
-    /// load.
-    ///
-    /// Generally set in the 64-2048 range. Default value is 2048.
-    ///
-    /// This method should be called before `bind()` method call.
-    pub fn backlog(mut self, num: i32) -> Self {
-        self.backlog = num;
-        self
-    }
-
-    /// Sets the maximum per-worker number of concurrent connections.
-    ///
-    /// All socket listeners will stop accepting connections when this limit is
-    /// reached for each worker.
-    ///
-    /// By default max connections is set to a 25k per worker.
-    pub fn maxconn(self, num: usize) -> Self {
-        worker::max_concurrent_connections(num);
-        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;
-        self
-    }
-
-    /// Disable signal handling
-    pub fn disable_signals(mut self) -> Self {
-        self.no_signals = true;
-        self
-    }
-
-    /// Timeout for graceful workers shutdown in seconds.
-    ///
-    /// After receiving a stop signal, workers have this much time to finish
-    /// serving requests. Workers still alive after the timeout are force
-    /// dropped.
-    ///
-    /// By default shutdown timeout sets to 30 seconds.
-    pub fn shutdown_timeout(mut self, sec: u64) -> Self {
-        self.shutdown_timeout = Duration::from_secs(sec);
-        self
-    }
-
-    /// Execute external configuration as part of the server building
-    /// process.
-    ///
-    /// This function is useful for moving parts of configuration to a
-    /// different module or even library.
-    pub fn configure<F>(mut self, f: F) -> io::Result<ServerBuilder>
-    where
-        F: Fn(&mut ServiceConfig) -> io::Result<()>,
-    {
-        let mut cfg = ServiceConfig::new(self.threads, self.backlog);
-
-        f(&mut cfg)?;
-
-        if let Some(apply) = cfg.apply {
-            let mut srv = ConfiguredService::new(apply);
-            for (name, lst) in cfg.services {
-                let token = self.token.next();
-                srv.stream(token, name, lst.local_addr()?);
-                self.sockets.push((token, StdListener::Tcp(lst)));
-            }
-            self.services.push(Box::new(srv));
-        }
-        self.threads = cfg.threads;
-
-        Ok(self)
-    }
-
-    /// Add new service to the server.
-    pub fn bind<F, U, N: AsRef<str>>(mut self, name: N, addr: U, factory: F) -> io::Result<Self>
-    where
-        F: ServiceFactory<TcpStream>,
-        U: net::ToSocketAddrs,
-    {
-        let sockets = bind_addr(addr, self.backlog)?;
-
-        for lst in sockets {
-            let token = self.token.next();
-            self.services.push(StreamNewService::create(
-                name.as_ref().to_string(),
-                token,
-                factory.clone(),
-                lst.local_addr()?,
-            ));
-            self.sockets.push((token, StdListener::Tcp(lst)));
-        }
-        Ok(self)
-    }
-
-    #[cfg(all(unix, feature = "uds"))]
-    /// Add new unix domain service to the server.
-    pub fn bind_uds<F, U, N>(mut self, name: N, addr: U, factory: F) -> io::Result<Self>
-    where
-        F: ServiceFactory<tokio_uds::UnixStream>,
-        N: AsRef<str>,
-        U: AsRef<std::path::Path>,
-    {
-        use std::net::{IpAddr, Ipv4Addr, SocketAddr};
-        use std::os::unix::net::UnixListener;
-
-        // TODO: need to do something with existing paths
-        let _ = std::fs::remove_file(addr.as_ref());
-
-        let lst = UnixListener::bind(addr)?;
-
-        let token = self.token.next();
-        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
-        self.services.push(StreamNewService::create(
-            name.as_ref().to_string(),
-            token,
-            factory.clone(),
-            addr,
-        ));
-        self.sockets.push((token, StdListener::Uds(lst)));
-        Ok(self)
-    }
-
-    /// Add new service to the server.
-    pub fn listen<F, N: AsRef<str>>(
-        mut self,
-        name: N,
-        lst: net::TcpListener,
-        factory: F,
-    ) -> io::Result<Self>
-    where
-        F: ServiceFactory<TcpStream>,
-    {
-        let token = self.token.next();
-        self.services.push(StreamNewService::create(
-            name.as_ref().to_string(),
-            token,
-            factory,
-            lst.local_addr()?,
-        ));
-        self.sockets.push((token, 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()
-    }
-
-    /// Starts processing incoming connections and return server controller.
-    pub fn start(mut self) -> Server {
-        if self.sockets.is_empty() {
-            panic!("Server should have at least one bound socket");
-        } else {
-            info!("Starting {} workers", self.threads);
-
-            // start workers
-            let mut workers = Vec::new();
-            for idx in 0..self.threads {
-                let worker = self.start_worker(idx, self.accept.get_notify());
-                workers.push(worker.clone());
-                self.workers.push((idx, worker));
-            }
-
-            // start accept thread
-            for sock in &self.sockets {
-                info!("Starting server on {}", sock.1);
-            }
-            self.accept
-                .start(mem::replace(&mut self.sockets, Vec::new()), workers);
-
-            // handle signals
-            if !self.no_signals {
-                Signals::start(self.server.clone());
-            }
-
-            // start http server actor
-            let server = self.server.clone();
-            spawn(self);
-            server
-        }
-    }
-
-    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(lazy(move || {
-            Worker::start(rx1, rx2, services, avail, timeout);
-            Ok::<_, ()>(())
-        }));
-
-        worker
-    }
-
-    fn handle_cmd(&mut self, item: ServerCommand) {
-        match item {
-            ServerCommand::Pause(tx) => {
-                self.accept.send(Command::Pause);
-                let _ = tx.send(());
-            }
-            ServerCommand::Resume(tx) => {
-                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::Stop {
-                graceful,
-                completion,
-            } => {
-                let exit = self.exit;
-
-                // stop accept thread
-                self.accept.send(Command::Stop);
-
-                // stop workers
-                if !self.workers.is_empty() && graceful {
-                    spawn(
-                        futures_unordered(
-                            self.workers
-                                .iter()
-                                .map(move |worker| worker.1.stop(graceful)),
-                        )
-                        .collect()
-                        .then(move |_| {
-                            if let Some(tx) = completion {
-                                let _ = tx.send(());
-                            }
-                            if exit {
-                                spawn(sleep(Duration::from_millis(300)).then(|_| {
-                                    System::current().stop();
-                                    ok(())
-                                }));
-                            }
-                            ok(())
-                        }),
-                    )
-                } else {
-                    // we need to stop system if server was spawned
-                    if self.exit {
-                        spawn(sleep(Duration::from_millis(300)).then(|_| {
-                            System::current().stop();
-                            ok(())
-                        }));
-                    }
-                    if let Some(tx) = completion {
-                        let _ = tx.send(());
-                    }
-                }
-            }
-            ServerCommand::WorkerDied(idx) => {
-                let mut found = false;
-                for i in 0..self.workers.len() {
-                    if self.workers[i].0 == idx {
-                        self.workers.swap_remove(i);
-                        found = true;
-                        break;
-                    }
-                }
-
-                if found {
-                    error!("Worker has died {:?}, restarting", idx);
-
-                    let mut new_idx = self.workers.len();
-                    'found: loop {
-                        for i in 0..self.workers.len() {
-                            if self.workers[i].0 == new_idx {
-                                new_idx += 1;
-                                continue 'found;
-                            }
-                        }
-                        break;
-                    }
-
-                    let worker = self.start_worker(new_idx, self.accept.get_notify());
-                    self.workers.push((new_idx, worker.clone()));
-                    self.accept.send(Command::Worker(worker));
-                }
-            }
-        }
-    }
-}
-
-impl Future for ServerBuilder {
-    type Item = ();
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        loop {
-            match self.cmd.poll() {
-                Ok(Async::Ready(None)) | Err(_) => return Ok(Async::Ready(())),
-                Ok(Async::NotReady) => return Ok(Async::NotReady),
-                Ok(Async::Ready(Some(item))) => self.handle_cmd(item),
-            }
-        }
-    }
-}
-
-pub(super) fn bind_addr<S: net::ToSocketAddrs>(
-    addr: S,
-    backlog: i32,
-) -> io::Result<Vec<net::TcpListener>> {
-    let mut err = None;
-    let mut succ = false;
-    let mut sockets = Vec::new();
-    for addr in addr.to_socket_addrs()? {
-        match create_tcp_listener(addr, backlog) {
-            Ok(lst) => {
-                succ = true;
-                sockets.push(lst);
-            }
-            Err(e) => err = Some(e),
-        }
-    }
-
-    if !succ {
-        if let Some(e) = err.take() {
-            Err(e)
-        } else {
-            Err(io::Error::new(
-                io::ErrorKind::Other,
-                "Can not bind to address.",
-            ))
-        }
-    } else {
-        Ok(sockets)
-    }
-}
-
-fn create_tcp_listener(addr: net::SocketAddr, backlog: i32) -> io::Result<net::TcpListener> {
-    let builder = match addr {
-        net::SocketAddr::V4(_) => TcpBuilder::new_v4()?,
-        net::SocketAddr::V6(_) => TcpBuilder::new_v6()?,
-    };
-    builder.reuse_address(true)?;
-    builder.bind(addr)?;
-    Ok(builder.listen(backlog)?)
-}

actix-server/src/config.rs

@@ -1,276 +0,0 @@
-use std::collections::HashMap;
-use std::{fmt, io, net};
-
-use actix_server_config::{Io, ServerConfig};
-use actix_service::{IntoNewService, NewService};
-use futures::future::{join_all, Future};
-use log::error;
-use tokio_tcp::TcpStream;
-
-use crate::counter::CounterGuard;
-
-use super::builder::bind_addr;
-use super::services::{
-    BoxedServerService, InternalServiceFactory, ServerMessage, StreamService,
-};
-use super::Token;
-
-pub struct ServiceConfig {
-    pub(crate) services: Vec<(String, net::TcpListener)>,
-    pub(crate) apply: Option<Box<dyn ServiceRuntimeConfiguration>>,
-    pub(crate) threads: usize,
-    pub(crate) backlog: i32,
-}
-
-impl ServiceConfig {
-    pub(super) fn new(threads: usize, backlog: i32) -> ServiceConfig {
-        ServiceConfig {
-            threads,
-            backlog,
-            services: Vec::new(),
-            apply: None,
-        }
-    }
-
-    /// Set number of workers to start.
-    ///
-    /// By default server uses number of available logical cpu as workers
-    /// count.
-    pub fn workers(&mut self, num: usize) {
-        self.threads = num;
-    }
-
-    /// Add new service to server
-    pub fn bind<U, N: AsRef<str>>(&mut self, name: N, addr: U) -> io::Result<&mut Self>
-    where
-        U: net::ToSocketAddrs,
-    {
-        let sockets = bind_addr(addr, self.backlog)?;
-
-        for lst in sockets {
-            self.listen(name.as_ref(), lst);
-        }
-
-        Ok(self)
-    }
-
-    /// Add new service to server
-    pub fn listen<N: AsRef<str>>(&mut self, name: N, lst: net::TcpListener) -> &mut Self {
-        if self.apply.is_none() {
-            self.apply = Some(Box::new(not_configured));
-        }
-        self.services.push((name.as_ref().to_string(), lst));
-        self
-    }
-
-    /// Register service configuration function. This function get called
-    /// during worker runtime configuration. It get executed in worker thread.
-    pub fn apply<F>(&mut self, f: F) -> io::Result<()>
-    where
-        F: Fn(&mut ServiceRuntime) + Send + Clone + 'static,
-    {
-        self.apply = Some(Box::new(f));
-        Ok(())
-    }
-}
-
-pub(super) struct ConfiguredService {
-    rt: Box<dyn ServiceRuntimeConfiguration>,
-    names: HashMap<Token, (String, net::SocketAddr)>,
-    services: HashMap<String, Token>,
-}
-
-impl ConfiguredService {
-    pub(super) fn new(rt: Box<dyn ServiceRuntimeConfiguration>) -> Self {
-        ConfiguredService {
-            rt,
-            names: HashMap::new(),
-            services: HashMap::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);
-    }
-}
-
-impl InternalServiceFactory for ConfiguredService {
-    fn name(&self, token: Token) -> &str {
-        &self.names[&token].0
-    }
-
-    fn clone_factory(&self) -> Box<dyn InternalServiceFactory> {
-        Box::new(Self {
-            rt: self.rt.clone(),
-            names: self.names.clone(),
-            services: self.services.clone(),
-        })
-    }
-
-    fn create(&self) -> Box<dyn Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
-        // configure services
-        let mut rt = ServiceRuntime::new(self.services.clone());
-        self.rt.configure(&mut rt);
-        rt.validate();
-
-        let services = rt.services;
-
-        // on start futures
-        if rt.onstart.is_empty() {
-            // construct services
-            let mut fut = Vec::new();
-            for (token, ns) in services {
-                let config = ServerConfig::new(self.names[&token].1);
-                fut.push(ns.new_service(&config).map(move |service| (token, service)));
-            }
-
-            Box::new(join_all(fut).map_err(|e| {
-                error!("Can not construct service: {:?}", e);
-            }))
-        } else {
-            let names = self.names.clone();
-
-            // run onstart future and then construct services
-            Box::new(
-                join_all(rt.onstart)
-                    .map_err(|e| {
-                        error!("Can not construct service: {:?}", e);
-                    })
-                    .and_then(move |_| {
-                        // construct services
-                        let mut fut = Vec::new();
-                        for (token, ns) in services {
-                            let config = ServerConfig::new(names[&token].1);
-                            fut.push(
-                                ns.new_service(&config).map(move |service| (token, service)),
-                            );
-                        }
-                        join_all(fut).map_err(|e| {
-                            error!("Can not construct service: {:?}", e);
-                        })
-                    }),
-            )
-        }
-    }
-}
-
-pub(super) trait ServiceRuntimeConfiguration: Send {
-    fn clone(&self) -> Box<dyn ServiceRuntimeConfiguration>;
-
-    fn configure(&self, rt: &mut ServiceRuntime);
-}
-
-impl<F> ServiceRuntimeConfiguration for F
-where
-    F: Fn(&mut ServiceRuntime) + Send + Clone + 'static,
-{
-    fn clone(&self) -> Box<dyn ServiceRuntimeConfiguration> {
-        Box::new(self.clone())
-    }
-
-    fn configure(&self, rt: &mut ServiceRuntime) {
-        (self)(rt)
-    }
-}
-
-fn not_configured(_: &mut ServiceRuntime) {
-    error!("Service is not configured");
-}
-
-pub struct ServiceRuntime {
-    names: HashMap<String, Token>,
-    services: HashMap<Token, BoxedNewService>,
-    onstart: Vec<Box<dyn Future<Item = (), Error = ()>>>,
-}
-
-impl ServiceRuntime {
-    fn new(names: HashMap<String, Token>) -> Self {
-        ServiceRuntime {
-            names,
-            services: HashMap::new(),
-            onstart: Vec::new(),
-        }
-    }
-
-    fn validate(&self) {
-        for (name, token) in &self.names {
-            if !self.services.contains_key(&token) {
-                error!("Service {:?} is not configured", name);
-            }
-        }
-    }
-
-    /// Register service.
-    ///
-    /// Name of the service must be registered during configuration stage with
-    /// *ServiceConfig::bind()* or *ServiceConfig::listen()* methods.
-    pub fn service<T, F>(&mut self, name: &str, service: F)
-    where
-        F: IntoNewService<T>,
-        T: NewService<Config = ServerConfig, Request = Io<TcpStream>> + 'static,
-        T::Future: 'static,
-        T::Service: 'static,
-        T::InitError: fmt::Debug,
-    {
-        // let name = name.to_owned();
-        if let Some(token) = self.names.get(name) {
-            self.services.insert(
-                token.clone(),
-                Box::new(ServiceFactory {
-                    inner: service.into_new_service(),
-                }),
-            );
-        } else {
-            panic!("Unknown service: {:?}", name);
-        }
-    }
-
-    /// Execute future before services initialization.
-    pub fn on_start<F>(&mut self, fut: F)
-    where
-        F: Future<Item = (), Error = ()> + 'static,
-    {
-        self.onstart.push(Box::new(fut))
-    }
-}
-
-type BoxedNewService = Box<
-    dyn NewService<
-        Request = (Option<CounterGuard>, ServerMessage),
-        Response = (),
-        Error = (),
-        InitError = (),
-        Config = ServerConfig,
-        Service = BoxedServerService,
-        Future = Box<dyn Future<Item = BoxedServerService, Error = ()>>,
-    >,
->;
-
-struct ServiceFactory<T> {
-    inner: T,
-}
-
-impl<T> NewService for ServiceFactory<T>
-where
-    T: NewService<Config = ServerConfig, Request = Io<TcpStream>>,
-    T::Future: 'static,
-    T::Service: 'static,
-    T::Error: 'static,
-    T::InitError: fmt::Debug + 'static,
-{
-    type Request = (Option<CounterGuard>, ServerMessage);
-    type Response = ();
-    type Error = ();
-    type InitError = ();
-    type Config = ServerConfig;
-    type Service = BoxedServerService;
-    type Future = Box<dyn Future<Item = BoxedServerService, Error = ()>>;
-
-    fn new_service(&self, cfg: &ServerConfig) -> Self::Future {
-        Box::new(self.inner.new_service(cfg).map_err(|_| ()).map(|s| {
-            let service: BoxedServerService = Box::new(StreamService::new(s));
-            service
-        }))
-    }
-}

actix-server/src/lib.rs

@@ -1,42 +0,0 @@
-//! General purpose tcp server
-
-mod accept;
-mod builder;
-mod config;
-mod counter;
-mod server;
-mod services;
-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;
-pub use self::services::ServiceFactory;
-
-#[doc(hidden)]
-pub use self::socket::FromStream;
-
-#[doc(hidden)]
-pub use self::services::ServiceFactory as StreamServiceFactory;
-
-/// Socket id token
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub(crate) struct Token(usize);
-
-impl Token {
-    pub(crate) fn next(&mut self) -> Token {
-        let token = Token(self.0 + 1);
-        self.0 += 1;
-        token
-    }
-}
-
-/// Start server building process
-pub fn new() -> ServerBuilder {
-    ServerBuilder::default()
-}

actix-server/src/server.rs

@@ -1,70 +0,0 @@
-use futures::sync::mpsc::UnboundedSender;
-use futures::sync::oneshot;
-use futures::Future;
-
-use crate::builder::ServerBuilder;
-use crate::signals::Signal;
-
-#[derive(Debug)]
-pub(crate) enum ServerCommand {
-    WorkerDied(usize),
-    Pause(oneshot::Sender<()>),
-    Resume(oneshot::Sender<()>),
-    Signal(Signal),
-    /// Whether to try and shut down gracefully
-    Stop {
-        graceful: bool,
-        completion: Option<oneshot::Sender<()>>,
-    },
-}
-
-#[derive(Debug, Clone)]
-pub struct Server(UnboundedSender<ServerCommand>);
-
-impl Server {
-    pub(crate) fn new(tx: UnboundedSender<ServerCommand>) -> Self {
-        Server(tx)
-    }
-
-    /// Start server building process
-    pub fn build() -> ServerBuilder {
-        ServerBuilder::default()
-    }
-
-    pub(crate) fn signal(&self, sig: Signal) {
-        let _ = self.0.unbounded_send(ServerCommand::Signal(sig));
-    }
-
-    pub(crate) fn worker_died(&self, idx: usize) {
-        let _ = self.0.unbounded_send(ServerCommand::WorkerDied(idx));
-    }
-
-    /// Pause accepting incoming connections
-    ///
-    /// If socket contains some pending connection, they might be dropped.
-    /// All opened connection remains active.
-    pub fn pause(&self) -> impl Future<Item = (), Error = ()> {
-        let (tx, rx) = oneshot::channel();
-        let _ = self.0.unbounded_send(ServerCommand::Pause(tx));
-        rx.map_err(|_| ())
-    }
-
-    /// Resume accepting incoming connections
-    pub fn resume(&self) -> impl Future<Item = (), Error = ()> {
-        let (tx, rx) = oneshot::channel();
-        let _ = self.0.unbounded_send(ServerCommand::Resume(tx));
-        rx.map_err(|_| ())
-    }
-
-    /// 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<Item = (), Error = ()> {
-        let (tx, rx) = oneshot::channel();
-        let _ = self.0.unbounded_send(ServerCommand::Stop {
-            graceful,
-            completion: Some(tx),
-        });
-        rx.map_err(|_| ())
-    }
-}

actix-server/src/services.rs

@@ -1,186 +0,0 @@
-use std::marker::PhantomData;
-use std::net::SocketAddr;
-use std::time::Duration;
-
-use actix_rt::spawn;
-use actix_server_config::{Io, ServerConfig};
-use actix_service::{NewService, Service};
-use futures::future::{err, ok, FutureResult};
-use futures::{Future, Poll};
-use log::error;
-
-use super::Token;
-use crate::counter::CounterGuard;
-use crate::socket::{FromStream, StdStream};
-
-/// Server message
-pub(crate) enum ServerMessage {
-    /// New stream
-    Connect(StdStream),
-    /// Gracefull shutdown
-    Shutdown(Duration),
-    /// Force shutdown
-    ForceShutdown,
-}
-
-pub trait ServiceFactory<Stream: FromStream>: Send + Clone + 'static {
-    type NewService: NewService<Config = ServerConfig, Request = Io<Stream>>;
-
-    fn create(&self) -> Self::NewService;
-}
-
-pub(crate) trait InternalServiceFactory: Send {
-    fn name(&self, token: Token) -> &str;
-
-    fn clone_factory(&self) -> Box<dyn InternalServiceFactory>;
-
-    fn create(&self) -> Box<dyn Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>>;
-}
-
-pub(crate) type BoxedServerService = Box<
-    dyn Service<
-        Request = (Option<CounterGuard>, ServerMessage),
-        Response = (),
-        Error = (),
-        Future = FutureResult<(), ()>,
-    >,
->;
-
-pub(crate) struct StreamService<T> {
-    service: T,
-}
-
-impl<T> StreamService<T> {
-    pub(crate) fn new(service: T) -> Self {
-        StreamService { service }
-    }
-}
-
-impl<T, I> Service for StreamService<T>
-where
-    T: Service<Request = Io<I>>,
-    T::Future: 'static,
-    T::Error: 'static,
-    I: FromStream,
-{
-    type Request = (Option<CounterGuard>, ServerMessage);
-    type Response = ();
-    type Error = ();
-    type Future = FutureResult<(), ()>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready().map_err(|_| ())
-    }
-
-    fn call(&mut self, (guard, req): (Option<CounterGuard>, ServerMessage)) -> Self::Future {
-        match req {
-            ServerMessage::Connect(stream) => {
-                let stream = FromStream::from_stdstream(stream).map_err(|e| {
-                    error!("Can not convert to an async tcp stream: {}", e);
-                });
-
-                if let Ok(stream) = stream {
-                    spawn(self.service.call(Io::new(stream)).then(move |res| {
-                        drop(guard);
-                        res.map_err(|_| ()).map(|_| ())
-                    }));
-                    ok(())
-                } else {
-                    err(())
-                }
-            }
-            _ => ok(()),
-        }
-    }
-}
-
-pub(crate) struct StreamNewService<F: ServiceFactory<Io>, Io: FromStream> {
-    name: String,
-    inner: F,
-    token: Token,
-    addr: SocketAddr,
-    _t: PhantomData<Io>,
-}
-
-impl<F, Io> StreamNewService<F, Io>
-where
-    F: ServiceFactory<Io>,
-    Io: FromStream + Send + 'static,
-{
-    pub(crate) fn create(
-        name: String,
-        token: Token,
-        inner: F,
-        addr: SocketAddr,
-    ) -> Box<dyn InternalServiceFactory> {
-        Box::new(Self {
-            name,
-            token,
-            inner,
-            addr,
-            _t: PhantomData,
-        })
-    }
-}
-
-impl<F, Io> InternalServiceFactory for StreamNewService<F, Io>
-where
-    F: ServiceFactory<Io>,
-    Io: FromStream + Send + 'static,
-{
-    fn name(&self, _: Token) -> &str {
-        &self.name
-    }
-
-    fn clone_factory(&self) -> Box<dyn InternalServiceFactory> {
-        Box::new(Self {
-            name: self.name.clone(),
-            inner: self.inner.clone(),
-            token: self.token,
-            addr: self.addr,
-            _t: PhantomData,
-        })
-    }
-
-    fn create(&self) -> Box<dyn Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
-        let token = self.token;
-        let config = ServerConfig::new(self.addr);
-        Box::new(
-            self.inner
-                .create()
-                .new_service(&config)
-                .map_err(|_| ())
-                .map(move |inner| {
-                    let service: BoxedServerService = Box::new(StreamService::new(inner));
-                    vec![(token, service)]
-                }),
-        )
-    }
-}
-
-impl InternalServiceFactory for Box<dyn InternalServiceFactory> {
-    fn name(&self, token: Token) -> &str {
-        self.as_ref().name(token)
-    }
-
-    fn clone_factory(&self) -> Box<dyn InternalServiceFactory> {
-        self.as_ref().clone_factory()
-    }
-
-    fn create(&self) -> Box<dyn Future<Item = Vec<(Token, BoxedServerService)>, Error = ()>> {
-        self.as_ref().create()
-    }
-}
-
-impl<F, T, I> ServiceFactory<I> for F
-where
-    F: Fn() -> T + Send + Clone + 'static,
-    T: NewService<Config = ServerConfig, Request = Io<I>>,
-    I: FromStream,
-{
-    type NewService = T;
-
-    fn create(&self) -> T {
-        (self)()
-    }
-}

actix-server/src/signals.rs

@@ -1,118 +0,0 @@
-use std::io;
-
-use actix_rt::spawn;
-use futures::stream::futures_unordered;
-use futures::{Async, Future, Poll, Stream};
-
-use crate::server::Server;
-
-/// Different types of process signals
-#[derive(PartialEq, Clone, Copy, Debug)]
-pub(crate) enum Signal {
-    /// SIGHUP
-    Hup,
-    /// SIGINT
-    Int,
-    /// SIGTERM
-    Term,
-    /// SIGQUIT
-    Quit,
-}
-
-pub(crate) struct Signals {
-    srv: Server,
-    #[cfg(not(unix))]
-    stream: SigStream,
-    #[cfg(unix)]
-    streams: Vec<SigStream>,
-}
-
-type SigStream = Box<dyn Stream<Item = Signal, Error = io::Error>>;
-
-impl Signals {
-    pub(crate) fn start(srv: Server) {
-        let fut = {
-            #[cfg(not(unix))]
-            {
-                tokio_signal::ctrl_c()
-                    .map_err(|_| ())
-                    .and_then(move |stream| Signals {
-                        srv,
-                        stream: Box::new(stream.map(|_| Signal::Int)),
-                    })
-            }
-
-            #[cfg(unix)]
-            {
-                use tokio_signal::unix;
-
-                let mut sigs: Vec<Box<dyn Future<Item = SigStream, Error = io::Error>>> =
-                    Vec::new();
-                sigs.push(Box::new(
-                    tokio_signal::unix::Signal::new(tokio_signal::unix::SIGINT).map(|stream| {
-                        let s: SigStream = Box::new(stream.map(|_| Signal::Int));
-                        s
-                    }),
-                ));
-                sigs.push(Box::new(
-                    tokio_signal::unix::Signal::new(tokio_signal::unix::SIGHUP).map(
-                        |stream: unix::Signal| {
-                            let s: SigStream = Box::new(stream.map(|_| Signal::Hup));
-                            s
-                        },
-                    ),
-                ));
-                sigs.push(Box::new(
-                    tokio_signal::unix::Signal::new(tokio_signal::unix::SIGTERM).map(
-                        |stream| {
-                            let s: SigStream = Box::new(stream.map(|_| Signal::Term));
-                            s
-                        },
-                    ),
-                ));
-                sigs.push(Box::new(
-                    tokio_signal::unix::Signal::new(tokio_signal::unix::SIGQUIT).map(
-                        |stream| {
-                            let s: SigStream = Box::new(stream.map(|_| Signal::Quit));
-                            s
-                        },
-                    ),
-                ));
-                futures_unordered(sigs)
-                    .collect()
-                    .map_err(|_| ())
-                    .and_then(move |streams| Signals { srv, streams })
-            }
-        };
-        spawn(fut);
-    }
-}
-
-impl Future for Signals {
-    type Item = ();
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        #[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),
-            }
-        }
-        #[cfg(unix)]
-        {
-            for s in &mut self.streams {
-                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),
-                    }
-                }
-            }
-            Ok(Async::NotReady)
-        }
-    }
-}

actix-server/src/socket.rs

@@ -1,173 +0,0 @@
-use std::{fmt, io, net};
-
-use tokio_io::{AsyncRead, AsyncWrite};
-use tokio_reactor::Handle;
-use tokio_tcp::TcpStream;
-
-pub(crate) enum StdListener {
-    Tcp(net::TcpListener),
-    #[cfg(all(unix, feature = "uds"))]
-    Uds(std::os::unix::net::UnixListener),
-}
-
-pub(crate) enum SocketAddr {
-    Tcp(net::SocketAddr),
-    #[cfg(all(unix, feature = "uds"))]
-    Uds(std::os::unix::net::SocketAddr),
-}
-
-impl fmt::Display for SocketAddr {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            SocketAddr::Tcp(ref addr) => write!(f, "{}", addr),
-            #[cfg(all(unix, feature = "uds"))]
-            SocketAddr::Uds(ref addr) => write!(f, "{:?}", addr),
-        }
-    }
-}
-
-impl fmt::Debug for SocketAddr {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            SocketAddr::Tcp(ref addr) => write!(f, "{:?}", addr),
-            #[cfg(all(unix, feature = "uds"))]
-            SocketAddr::Uds(ref addr) => write!(f, "{:?}", addr),
-        }
-    }
-}
-
-impl fmt::Display for StdListener {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            StdListener::Tcp(ref lst) => write!(f, "{}", lst.local_addr().ok().unwrap()),
-            #[cfg(all(unix, feature = "uds"))]
-            StdListener::Uds(ref lst) => write!(f, "{:?}", lst.local_addr().ok().unwrap()),
-        }
-    }
-}
-
-impl StdListener {
-    pub(crate) fn local_addr(&self) -> SocketAddr {
-        match self {
-            StdListener::Tcp(lst) => SocketAddr::Tcp(lst.local_addr().unwrap()),
-            #[cfg(all(unix, feature = "uds"))]
-            StdListener::Uds(lst) => SocketAddr::Uds(lst.local_addr().unwrap()),
-        }
-    }
-
-    pub(crate) fn into_listener(self) -> SocketListener {
-        match self {
-            StdListener::Tcp(lst) => SocketListener::Tcp(
-                mio::net::TcpListener::from_std(lst)
-                    .expect("Can not create mio::net::TcpListener"),
-            ),
-            #[cfg(all(unix, feature = "uds"))]
-            StdListener::Uds(lst) => SocketListener::Uds(
-                mio_uds::UnixListener::from_listener(lst)
-                    .expect("Can not create mio_uds::UnixListener"),
-            ),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum StdStream {
-    Tcp(std::net::TcpStream),
-    #[cfg(all(unix, feature = "uds"))]
-    Uds(std::os::unix::net::UnixStream),
-}
-
-pub(crate) enum SocketListener {
-    Tcp(mio::net::TcpListener),
-    #[cfg(all(unix, feature = "uds"))]
-    Uds(mio_uds::UnixListener),
-}
-
-impl SocketListener {
-    pub(crate) fn accept(&self) -> io::Result<Option<(StdStream, SocketAddr)>> {
-        match *self {
-            SocketListener::Tcp(ref lst) => lst
-                .accept_std()
-                .map(|(stream, addr)| Some((StdStream::Tcp(stream), SocketAddr::Tcp(addr)))),
-            #[cfg(all(unix, feature = "uds"))]
-            SocketListener::Uds(ref lst) => lst.accept_std().map(|res| {
-                res.map(|(stream, addr)| (StdStream::Uds(stream), SocketAddr::Uds(addr)))
-            }),
-        }
-    }
-}
-
-impl mio::Evented for SocketListener {
-    fn register(
-        &self,
-        poll: &mio::Poll,
-        token: mio::Token,
-        interest: mio::Ready,
-        opts: mio::PollOpt,
-    ) -> io::Result<()> {
-        match *self {
-            SocketListener::Tcp(ref lst) => lst.register(poll, token, interest, opts),
-            #[cfg(all(unix, feature = "uds"))]
-            SocketListener::Uds(ref lst) => lst.register(poll, token, interest, opts),
-        }
-    }
-
-    fn reregister(
-        &self,
-        poll: &mio::Poll,
-        token: mio::Token,
-        interest: mio::Ready,
-        opts: mio::PollOpt,
-    ) -> io::Result<()> {
-        match *self {
-            SocketListener::Tcp(ref lst) => lst.reregister(poll, token, interest, opts),
-            #[cfg(all(unix, feature = "uds"))]
-            SocketListener::Uds(ref lst) => lst.reregister(poll, token, interest, opts),
-        }
-    }
-    fn deregister(&self, poll: &mio::Poll) -> io::Result<()> {
-        match *self {
-            SocketListener::Tcp(ref lst) => lst.deregister(poll),
-            #[cfg(all(unix, feature = "uds"))]
-            SocketListener::Uds(ref lst) => {
-                let res = lst.deregister(poll);
-
-                // cleanup file path
-                if let Ok(addr) = lst.local_addr() {
-                    if let Some(path) = addr.as_pathname() {
-                        let _ = std::fs::remove_file(path);
-                    }
-                }
-                res
-            }
-        }
-    }
-}
-
-pub trait FromStream: AsyncRead + AsyncWrite + Sized {
-    fn from_stdstream(sock: StdStream) -> io::Result<Self>;
-}
-
-impl FromStream for TcpStream {
-    fn from_stdstream(sock: StdStream) -> io::Result<Self> {
-        match sock {
-            StdStream::Tcp(stream) => TcpStream::from_std(stream, &Handle::default()),
-            #[cfg(all(unix, feature = "uds"))]
-            StdStream::Uds(_) => {
-                panic!("Should not happen, bug in server impl");
-            }
-        }
-    }
-}
-
-#[cfg(all(unix, feature = "uds"))]
-impl FromStream for tokio_uds::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_uds::UnixStream::from_std(stream, &Handle::default())
-            }
-        }
-    }
-}

actix-server/src/ssl/openssl.rs

@@ -1,130 +0,0 @@
-use std::marker::PhantomData;
-
-use actix_service::{NewService, Service};
-use futures::{future::ok, future::FutureResult, Async, Future, Poll};
-use openssl::ssl::{HandshakeError, SslAcceptor};
-use tokio_io::{AsyncRead, AsyncWrite};
-use tokio_openssl::{AcceptAsync, SslAcceptorExt, 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, P> NewService 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 = FutureResult<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, 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) -> Poll<(), Self::Error> {
-        if self.conns.available() {
-            Ok(Async::Ready(()))
-        } else {
-            Ok(Async::NotReady)
-        }
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        let (io, params, _) = req.into_parts();
-        OpensslAcceptorServiceFut {
-            _guard: self.conns.get(),
-            fut: SslAcceptorExt::accept_async(&self.acceptor, io),
-            params: Some(params),
-        }
-    }
-}
-
-pub struct OpensslAcceptorServiceFut<T, P>
-where
-    T: AsyncRead + AsyncWrite,
-{
-    fut: AcceptAsync<T>,
-    params: Option<P>,
-    _guard: CounterGuard,
-}
-
-impl<T: AsyncRead + AsyncWrite, P> Future for OpensslAcceptorServiceFut<T, P> {
-    type Item = Io<SslStream<T>, P>;
-    type Error = HandshakeError<T>;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        let io = futures::try_ready!(self.fut.poll());
-        let proto = if let Some(protos) = io.get_ref().ssl().selected_alpn_protocol() {
-            const H2: &[u8] = b"\x02h2";
-            const HTTP10: &[u8] = b"\x08http/1.0";
-            const HTTP11: &[u8] = b"\x08http/1.1";
-
-            if protos.windows(3).any(|window| window == H2) {
-                Protocol::Http2
-            } else if protos.windows(9).any(|window| window == HTTP11) {
-                Protocol::Http11
-            } else if protos.windows(9).any(|window| window == HTTP10) {
-                Protocol::Http10
-            } else {
-                Protocol::Unknown
-            }
-        } else {
-            Protocol::Unknown
-        };
-        Ok(Async::Ready(Io::from_parts(
-            io,
-            self.params.take().unwrap(),
-            proto,
-        )))
-    }
-}

actix-server/tests/test_server.rs

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

actix-service/CHANGES.md

@@ -1,183 +0,0 @@
-# Changes
-
-## [0.4.1] - 2019-06-06
-
-### Added
-
-* Add `new_apply_cfg` function
-
-## [0.4.0] - 2019-05-12
-
-### Changed
-
-* Use associated type for `NewService` config
-
-* Change `apply_cfg` function
-
-* Renamed helper functions
-
-### Added
-
-* Add `NewService::map_config` and `NewService::unit_config` combinators
-
-
-## [0.3.6] - 2019-04-07
-
-### Changed
-
-* Poll boxed service call result immediately
-
-
-## [0.3.5] - 2019-03-29
-
-### Added
-
-* Add `impl<S: Service> Service for Rc<RefCell<S>>`
-
-
-## [0.3.4] - 2019-03-12
-
-### Added
-
-* Add `Transform::from_err()` combinator
-
-* Add `apply_fn` helper
-
-* Add `apply_fn_factory` helper
-
-* Add `apply_transform` helper
-
-* Add `apply_cfg` helper
-
-
-## [0.3.3] - 2019-03-09
-
-### Added
-
-* Add `ApplyTransform` new service for transform and new service.
-
-* Add `NewService::apply_cfg()` combinator, allows to use
-  nested `NewService` with different config parameter.
-
-### Changed
-
-* Revert IntoFuture change
-
-
-## [0.3.2] - 2019-03-04
-
-### Changed
-
-* Change `NewService::Future` and `Transform::Future` to the `IntoFuture` trait.
-
-* Export `AndThenTransform` type
-
-
-## [0.3.1] - 2019-03-04
-
-### Changed
-
-* Simplify Transform trait
-
-
-## [0.3.0] - 2019-03-02
-
-## Added
-
-* Added boxed NewService and Service.
-
-## Changed
-
-* Added `Config` parameter to `NewService` trait.
-
-* Added `Config` parameter to `NewTransform` trait.
-
-
-## [0.2.2] - 2019-02-19
-
-### Added
-
-* Added `NewService` impl for `Rc<S> where S: NewService`
-
-* Added `NewService` impl for `Arc<S> where S: NewService`
-
-
-## [0.2.1] - 2019-02-03
-
-### Changed
-
-* Generalize `.apply` combinator with Transform trait
-
-
-## [0.2.0] - 2019-02-01
-
-### Changed
-
-* Use associated type instead of generic for Service definition.
-
-  * Before:
-
-    ```rust
-    impl Service<Request> for Client {
-        type Response = Response;
-        // ...
-    }
-    ```
-  * After:
-
-    ```rust
-    impl Service for Client {
-        type Request = Request;
-        type Response = Response;
-        // ...
-    }
-    ```
-
-
-## [0.1.6] - 2019-01-24
-
-### Changed
-
-* Use `FnMut` instead of `Fn` for .apply() and .map() combinators and `FnService` type
-
-* Change `.apply()` error semantic, new service's error is `From<Self::Error>`
-
-
-## [0.1.5] - 2019-01-13
-
-### Changed
-
-* Make `Out::Error` convertable from `T::Error` for apply combinator
-
-
-## [0.1.4] - 2019-01-11
-
-### Changed
-
-* Use `FnMut` instead of `Fn` for `FnService`
-
-
-## [0.1.3] - 2018-12-12
-
-### Changed
-
-* Split service combinators to separate trait
-
-
-## [0.1.2] - 2018-12-12
-
-### Fixed
-
-* Release future early for `.and_then()` and `.then()` combinators
-
-
-## [0.1.1] - 2018-12-09
-
-### Added
-
-* Added Service impl for Box<S: Service>
-
-
-## [0.1.0] - 2018-12-09
-
-* Initial import

actix-service/Cargo.toml

@@ -1,29 +0,0 @@
-[package]
-name = "actix-service"
-version = "0.4.1"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-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 = ".."
-
-[badges]
-travis-ci = { repository = "actix/actix-service", branch = "master" }
-appveyor = { repository = "actix/actix-net" }
-codecov = { repository = "actix/actix-service", branch = "master", service = "github" }
-
-[lib]
-name = "actix_service"
-path = "src/lib.rs"
-
-[dependencies]
-futures = "0.1.25"
-
-[dev-dependencies]
-actix-rt = "0.2"

actix-service/LICENSE-APACHE

@@ -1 +0,0 @@
-../LICENSE-APACHE

actix-service/LICENSE-MIT

@@ -1 +0,0 @@
-../LICENSE-MIT

actix-service/src/and_then_apply.rs

@@ -1,186 +0,0 @@
-use std::rc::Rc;
-
-use futures::{Async, Future, Poll};
-
-use crate::and_then::AndThen;
-use crate::from_err::FromErr;
-use crate::{NewService, Transform};
-
-/// `Apply` new service combinator
-pub struct AndThenTransform<T, A, B> {
-    a: A,
-    b: B,
-    t: Rc<T>,
-}
-
-impl<T, A, B> AndThenTransform<T, A, B>
-where
-    A: NewService,
-    B: NewService<Config = A::Config, InitError = A::InitError>,
-    T: Transform<B::Service, Request = A::Response, InitError = A::InitError>,
-    T::Error: From<A::Error>,
-{
-    /// Create new `ApplyNewService` new service instance
-    pub fn new(t: T, a: A, b: B) -> Self {
-        Self {
-            a,
-            b,
-            t: Rc::new(t),
-        }
-    }
-}
-
-impl<T, A, B> Clone for AndThenTransform<T, A, B>
-where
-    A: Clone,
-    B: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            a: self.a.clone(),
-            b: self.b.clone(),
-            t: self.t.clone(),
-        }
-    }
-}
-
-impl<T, A, B> NewService for AndThenTransform<T, A, B>
-where
-    A: NewService,
-    B: NewService<Config = A::Config, InitError = A::InitError>,
-    T: Transform<B::Service, Request = A::Response, InitError = A::InitError>,
-    T::Error: From<A::Error>,
-{
-    type Request = A::Request;
-    type Response = T::Response;
-    type Error = T::Error;
-
-    type Config = A::Config;
-    type InitError = T::InitError;
-    type Service = AndThen<FromErr<A::Service, T::Error>, T::Transform>;
-    type Future = AndThenTransformFuture<T, A, B>;
-
-    fn new_service(&self, cfg: &A::Config) -> Self::Future {
-        AndThenTransformFuture {
-            a: None,
-            t: None,
-            t_cell: self.t.clone(),
-            fut_a: self.a.new_service(cfg),
-            fut_b: self.b.new_service(cfg),
-            fut_t: None,
-        }
-    }
-}
-
-pub struct AndThenTransformFuture<T, A, B>
-where
-    A: NewService,
-    B: NewService<InitError = A::InitError>,
-    T: Transform<B::Service, Request = A::Response, InitError = A::InitError>,
-    T::Error: From<A::Error>,
-{
-    fut_a: A::Future,
-    fut_b: B::Future,
-    fut_t: Option<T::Future>,
-    a: Option<A::Service>,
-    t: Option<T::Transform>,
-    t_cell: Rc<T>,
-}
-
-impl<T, A, B> Future for AndThenTransformFuture<T, A, B>
-where
-    A: NewService,
-    B: NewService<InitError = A::InitError>,
-    T: Transform<B::Service, Request = A::Response, InitError = A::InitError>,
-    T::Error: From<A::Error>,
-{
-    type Item = AndThen<FromErr<A::Service, T::Error>, T::Transform>;
-    type Error = T::InitError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if self.fut_t.is_none() {
-            if let Async::Ready(service) = self.fut_b.poll()? {
-                self.fut_t = Some(self.t_cell.new_transform(service));
-            }
-        }
-
-        if self.a.is_none() {
-            if let Async::Ready(service) = self.fut_a.poll()? {
-                self.a = Some(service);
-            }
-        }
-
-        if let Some(ref mut fut) = self.fut_t {
-            if let Async::Ready(transform) = fut.poll()? {
-                self.t = Some(transform);
-            }
-        }
-
-        if self.a.is_some() && self.t.is_some() {
-            Ok(Async::Ready(AndThen::new(
-                FromErr::new(self.a.take().unwrap()),
-                self.t.take().unwrap(),
-            )))
-        } else {
-            Ok(Async::NotReady)
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use futures::future::{ok, FutureResult};
-    use futures::{Async, Future, Poll};
-
-    use crate::{IntoNewService, IntoService, NewService, Service, ServiceExt};
-
-    #[derive(Clone)]
-    struct Srv;
-    impl Service for Srv {
-        type Request = ();
-        type Response = ();
-        type Error = ();
-        type Future = FutureResult<(), ()>;
-
-        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-            Ok(Async::Ready(()))
-        }
-
-        fn call(&mut self, _: ()) -> Self::Future {
-            ok(())
-        }
-    }
-
-    #[test]
-    fn test_apply() {
-        let blank = |req| Ok(req);
-
-        let mut srv = blank
-            .into_service()
-            .apply_fn(Srv, |req: &'static str, srv: &mut Srv| {
-                srv.call(()).map(move |res| (req, res))
-            });
-        assert!(srv.poll_ready().is_ok());
-        let res = srv.call("srv").poll();
-        assert!(res.is_ok());
-        assert_eq!(res.unwrap(), Async::Ready(("srv", ())));
-    }
-
-    #[test]
-    fn test_new_service() {
-        let blank = || Ok::<_, ()>((|req| Ok(req)).into_service());
-
-        let new_srv = blank.into_new_service().apply(
-            |req: &'static str, srv: &mut Srv| srv.call(()).map(move |res| (req, res)),
-            || Ok(Srv),
-        );
-        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
-            assert!(srv.poll_ready().is_ok());
-            let res = srv.call("srv").poll();
-            assert!(res.is_ok());
-            assert_eq!(res.unwrap(), Async::Ready(("srv", ())));
-        } else {
-            panic!()
-        }
-    }
-}

actix-service/src/and_then_apply_fn.rs

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

actix-service/src/apply.rs

@@ -1,257 +0,0 @@
-use std::marker::PhantomData;
-
-use futures::{Async, Future, IntoFuture, Poll};
-
-use super::{IntoNewService, IntoService, NewService, Service};
-
-/// Apply tranform function to a service
-pub fn apply_fn<T, F, In, Out, U>(service: U, f: F) -> Apply<T, F, In, Out>
-where
-    T: Service,
-    F: FnMut(In, &mut T) -> Out,
-    Out: IntoFuture,
-    Out::Error: From<T::Error>,
-    U: IntoService<T>,
-{
-    Apply::new(service.into_service(), f)
-}
-
-/// Create factory for `apply` service.
-pub fn new_apply_fn<T, F, In, Out, U>(service: U, f: F) -> ApplyNewService<T, F, In, Out>
-where
-    T: NewService,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
-    Out::Error: From<T::Error>,
-    U: IntoNewService<T>,
-{
-    ApplyNewService::new(service.into_new_service(), f)
-}
-
-#[doc(hidden)]
-/// `Apply` service combinator
-pub struct Apply<T, F, In, Out>
-where
-    T: Service,
-{
-    service: T,
-    f: F,
-    r: PhantomData<(In, Out)>,
-}
-
-impl<T, F, In, Out> Apply<T, F, In, Out>
-where
-    T: Service,
-    F: FnMut(In, &mut T) -> Out,
-    Out: IntoFuture,
-    Out::Error: From<T::Error>,
-{
-    /// Create new `Apply` combinator
-    pub(crate) fn new<I: IntoService<T>>(service: I, f: F) -> Self {
-        Self {
-            service: service.into_service(),
-            f,
-            r: PhantomData,
-        }
-    }
-}
-
-impl<T, F, In, Out> Clone for Apply<T, F, In, Out>
-where
-    T: Service + Clone,
-    F: Clone,
-{
-    fn clone(&self) -> Self {
-        Apply {
-            service: self.service.clone(),
-            f: self.f.clone(),
-            r: PhantomData,
-        }
-    }
-}
-
-impl<T, F, In, Out> Service for Apply<T, F, In, Out>
-where
-    T: Service,
-    F: FnMut(In, &mut T) -> Out,
-    Out: IntoFuture,
-    Out::Error: From<T::Error>,
-{
-    type Request = In;
-    type Response = Out::Item;
-    type Error = Out::Error;
-    type Future = Out::Future;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready().map_err(|e| e.into())
-    }
-
-    fn call(&mut self, req: In) -> Self::Future {
-        (self.f)(req, &mut self.service).into_future()
-    }
-}
-
-/// `ApplyNewService` new service combinator
-pub struct ApplyNewService<T, F, In, Out>
-where
-    T: NewService,
-{
-    service: T,
-    f: F,
-    r: PhantomData<(In, Out)>,
-}
-
-impl<T, F, In, Out> ApplyNewService<T, F, In, Out>
-where
-    T: NewService,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
-    Out::Error: From<T::Error>,
-{
-    /// Create new `ApplyNewService` new service instance
-    pub(crate) fn new<F1: IntoNewService<T>>(service: F1, f: F) -> Self {
-        Self {
-            f,
-            service: service.into_new_service(),
-            r: PhantomData,
-        }
-    }
-}
-
-impl<T, F, In, Out> Clone for ApplyNewService<T, F, In, Out>
-where
-    T: NewService + Clone,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
-{
-    fn clone(&self) -> Self {
-        Self {
-            service: self.service.clone(),
-            f: self.f.clone(),
-            r: PhantomData,
-        }
-    }
-}
-
-impl<T, F, In, Out> NewService for ApplyNewService<T, F, In, Out>
-where
-    T: NewService,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
-    Out::Error: From<T::Error>,
-{
-    type Request = In;
-    type Response = Out::Item;
-    type Error = Out::Error;
-
-    type Config = T::Config;
-    type Service = Apply<T::Service, F, In, Out>;
-    type InitError = T::InitError;
-    type Future = ApplyNewServiceFuture<T, F, In, Out>;
-
-    fn new_service(&self, cfg: &T::Config) -> Self::Future {
-        ApplyNewServiceFuture::new(self.service.new_service(cfg), self.f.clone())
-    }
-}
-
-pub struct ApplyNewServiceFuture<T, F, In, Out>
-where
-    T: NewService,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
-{
-    fut: T::Future,
-    f: Option<F>,
-    r: PhantomData<(In, Out)>,
-}
-
-impl<T, F, In, Out> ApplyNewServiceFuture<T, F, In, Out>
-where
-    T: NewService,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
-{
-    fn new(fut: T::Future, f: F) -> Self {
-        ApplyNewServiceFuture {
-            f: Some(f),
-            fut,
-            r: PhantomData,
-        }
-    }
-}
-
-impl<T, F, In, Out> Future for ApplyNewServiceFuture<T, F, In, Out>
-where
-    T: NewService,
-    F: FnMut(In, &mut T::Service) -> Out + Clone,
-    Out: IntoFuture,
-    Out::Error: From<T::Error>,
-{
-    type Item = Apply<T::Service, F, In, Out>;
-    type Error = T::InitError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Async::Ready(service) = self.fut.poll()? {
-            Ok(Async::Ready(Apply::new(service, self.f.take().unwrap())))
-        } else {
-            Ok(Async::NotReady)
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use futures::future::{ok, FutureResult};
-    use futures::{Async, Future, Poll};
-
-    use super::*;
-    use crate::{IntoService, NewService, Service, ServiceExt};
-
-    #[derive(Clone)]
-    struct Srv;
-    impl Service for Srv {
-        type Request = ();
-        type Response = ();
-        type Error = ();
-        type Future = FutureResult<(), ()>;
-
-        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-            Ok(Async::Ready(()))
-        }
-
-        fn call(&mut self, _: ()) -> Self::Future {
-            ok(())
-        }
-    }
-
-    #[test]
-    fn test_call() {
-        let blank = |req| Ok(req);
-
-        let mut srv = blank
-            .into_service()
-            .apply_fn(Srv, |req: &'static str, srv| {
-                srv.call(()).map(move |res| (req, res))
-            });
-        assert!(srv.poll_ready().is_ok());
-        let res = srv.call("srv").poll();
-        assert!(res.is_ok());
-        assert_eq!(res.unwrap(), Async::Ready(("srv", ())));
-    }
-
-    #[test]
-    fn test_new_service() {
-        let new_srv = ApplyNewService::new(
-            || Ok::<_, ()>(Srv),
-            |req: &'static str, srv| srv.call(()).map(move |res| (req, res)),
-        );
-        if let Async::Ready(mut srv) = new_srv.new_service(&()).poll().unwrap() {
-            assert!(srv.poll_ready().is_ok());
-            let res = srv.call("srv").poll();
-            assert!(res.is_ok());
-            assert_eq!(res.unwrap(), Async::Ready(("srv", ())));
-        } else {
-            panic!()
-        }
-    }
-}

actix-service/src/apply_cfg.rs

@@ -1,252 +0,0 @@
-use std::marker::PhantomData;
-
-use futures::future::Future;
-use futures::{try_ready, Async, IntoFuture, Poll};
-
-use crate::cell::Cell;
-use crate::{IntoService, NewService, Service};
-
-/// Convert `Fn(&Config, &mut Service) -> Future<Service>` fn to a NewService
-pub fn apply_cfg<F, C, T, R, S>(
-    srv: T,
-    f: F,
-) -> impl NewService<
-    Config = C,
-    Request = S::Request,
-    Response = S::Response,
-    Error = S::Error,
-    Service = S,
-    InitError = R::Error,
-> + Clone
-where
-    F: FnMut(&C, &mut T) -> R,
-    T: Service,
-    R: IntoFuture,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    ApplyConfigService {
-        f: Cell::new(f),
-        srv: Cell::new(srv.into_service()),
-        _t: PhantomData,
-    }
-}
-
-/// Convert `Fn(&Config, &mut Service) -> Future<Service>` fn to a NewService
-/// Service get constructor from NewService.
-pub fn new_apply_cfg<F, C, T, R, S>(
-    srv: T,
-    f: F,
-) -> impl NewService<
-    Config = C,
-    Request = S::Request,
-    Response = S::Response,
-    Error = S::Error,
-    Service = S,
-    InitError = T::InitError,
-> + Clone
-where
-    C: Clone,
-    F: FnMut(&C, &mut T::Service) -> R,
-    T: NewService<Config = ()>,
-    R: IntoFuture<Error = T::InitError>,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    ApplyConfigNewService {
-        f: Cell::new(f),
-        srv: Cell::new(srv),
-        _t: PhantomData,
-    }
-}
-
-/// Convert `Fn(&Config) -> Future<Service>` fn to NewService
-struct ApplyConfigService<F, C, T, R, S>
-where
-    F: FnMut(&C, &mut T) -> R,
-    T: Service,
-    R: IntoFuture,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    f: Cell<F>,
-    srv: Cell<T>,
-    _t: PhantomData<(C, R, S)>,
-}
-
-impl<F, C, T, R, S> Clone for ApplyConfigService<F, C, T, R, S>
-where
-    F: FnMut(&C, &mut T) -> R,
-    T: Service,
-    R: IntoFuture,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    fn clone(&self) -> Self {
-        ApplyConfigService {
-            f: self.f.clone(),
-            srv: self.srv.clone(),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<F, C, T, R, S> NewService for ApplyConfigService<F, C, T, R, S>
-where
-    F: FnMut(&C, &mut T) -> R,
-    T: Service,
-    R: IntoFuture,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    type Config = C;
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = S::Error;
-    type Service = S;
-
-    type InitError = R::Error;
-    type Future = FnNewServiceConfigFut<R, S>;
-
-    fn new_service(&self, cfg: &C) -> Self::Future {
-        FnNewServiceConfigFut {
-            fut: unsafe { (self.f.get_mut_unsafe())(cfg, self.srv.get_mut_unsafe()) }
-                .into_future(),
-            _t: PhantomData,
-        }
-    }
-}
-
-struct FnNewServiceConfigFut<R, S>
-where
-    R: IntoFuture,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    fut: R::Future,
-    _t: PhantomData<(S,)>,
-}
-
-impl<R, S> Future for FnNewServiceConfigFut<R, S>
-where
-    R: IntoFuture,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    type Item = S;
-    type Error = R::Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        Ok(Async::Ready(try_ready!(self.fut.poll()).into_service()))
-    }
-}
-
-/// Convert `Fn(&Config) -> Future<Service>` fn to NewService
-struct ApplyConfigNewService<F, C, T, R, S>
-where
-    C: Clone,
-    F: FnMut(&C, &mut T::Service) -> R,
-    T: NewService<Config = ()>,
-    R: IntoFuture<Error = T::InitError>,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    f: Cell<F>,
-    srv: Cell<T>,
-    _t: PhantomData<(C, R, S)>,
-}
-
-impl<F, C, T, R, S> Clone for ApplyConfigNewService<F, C, T, R, S>
-where
-    C: Clone,
-    F: FnMut(&C, &mut T::Service) -> R,
-    T: NewService<Config = ()>,
-    R: IntoFuture<Error = T::InitError>,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    fn clone(&self) -> Self {
-        ApplyConfigNewService {
-            f: self.f.clone(),
-            srv: self.srv.clone(),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<F, C, T, R, S> NewService for ApplyConfigNewService<F, C, T, R, S>
-where
-    C: Clone,
-    F: FnMut(&C, &mut T::Service) -> R,
-    T: NewService<Config = ()>,
-    R: IntoFuture<Error = T::InitError>,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    type Config = C;
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = S::Error;
-    type Service = S;
-
-    type InitError = R::Error;
-    type Future = ApplyConfigNewServiceFut<F, C, T, R, S>;
-
-    fn new_service(&self, cfg: &C) -> Self::Future {
-        ApplyConfigNewServiceFut {
-            f: self.f.clone(),
-            cfg: cfg.clone(),
-            srv: Some(self.srv.get_ref().new_service(&())),
-            fut: None,
-            _t: PhantomData,
-        }
-    }
-}
-
-struct ApplyConfigNewServiceFut<F, C, T, R, S>
-where
-    C: Clone,
-    F: FnMut(&C, &mut T::Service) -> R,
-    T: NewService<Config = ()>,
-    R: IntoFuture<Error = T::InitError>,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    cfg: C,
-    f: Cell<F>,
-    srv: Option<T::Future>,
-    fut: Option<R::Future>,
-    _t: PhantomData<(S,)>,
-}
-
-impl<F, C, T, R, S> Future for ApplyConfigNewServiceFut<F, C, T, R, S>
-where
-    C: Clone,
-    F: FnMut(&C, &mut T::Service) -> R,
-    T: NewService<Config = ()>,
-    R: IntoFuture<Error = T::InitError>,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    type Item = S;
-    type Error = R::Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(ref mut fut) = self.srv {
-            match fut.poll()? {
-                Async::NotReady => return Ok(Async::NotReady),
-                Async::Ready(mut srv) => {
-                    let _ = self.srv.take();
-                    self.fut = Some(self.f.get_mut()(&self.cfg, &mut srv).into_future());
-                    return self.poll();
-                }
-            }
-        }
-
-        if let Some(ref mut fut) = self.fut {
-            Ok(Async::Ready(try_ready!(fut.poll()).into_service()))
-        } else {
-            Ok(Async::NotReady)
-        }
-    }
-}

actix-service/src/blank.rs

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

actix-service/src/boxed.rs

@@ -1,151 +0,0 @@
-use futures::future::{err, ok, Either, FutureResult};
-use futures::{Async, Future, IntoFuture, Poll};
-
-use crate::{NewService, Service};
-
-pub type BoxedService<Req, Res, Err> = Box<
-    Service<
-        Request = Req,
-        Response = Res,
-        Error = Err,
-        Future = BoxedServiceResponse<Res, Err>,
-    >,
->;
-
-pub type BoxedServiceResponse<Res, Err> =
-    Either<FutureResult<Res, Err>, Box<Future<Item = Res, Error = Err>>>;
-
-pub struct BoxedNewService<C, Req, Res, Err, InitErr>(Inner<C, Req, Res, Err, InitErr>);
-
-/// Create boxed new service
-pub fn new_service<T>(
-    service: T,
-) -> BoxedNewService<T::Config, T::Request, T::Response, T::Error, T::InitError>
-where
-    T: NewService + 'static,
-    T::Request: 'static,
-    T::Response: 'static,
-    T::Service: 'static,
-    T::Future: 'static,
-    T::Error: 'static,
-    T::InitError: 'static,
-{
-    BoxedNewService(Box::new(NewServiceWrapper {
-        service,
-        _t: std::marker::PhantomData,
-    }))
-}
-
-/// Create boxed service
-pub fn service<T>(service: T) -> BoxedService<T::Request, T::Response, T::Error>
-where
-    T: Service + 'static,
-    T::Future: 'static,
-{
-    Box::new(ServiceWrapper(service))
-}
-
-type Inner<C, Req, Res, Err, InitErr> = Box<
-    NewService<
-        Config = C,
-        Request = Req,
-        Response = Res,
-        Error = Err,
-        InitError = InitErr,
-        Service = BoxedService<Req, Res, Err>,
-        Future = Box<Future<Item = BoxedService<Req, Res, Err>, Error = InitErr>>,
-    >,
->;
-
-impl<C, Req, Res, Err, InitErr> NewService for BoxedNewService<C, Req, Res, Err, InitErr>
-where
-    Req: 'static,
-    Res: 'static,
-    Err: 'static,
-    InitErr: 'static,
-{
-    type Request = Req;
-    type Response = Res;
-    type Error = Err;
-    type InitError = InitErr;
-    type Config = C;
-    type Service = BoxedService<Req, Res, Err>;
-    type Future = Box<Future<Item = Self::Service, Error = Self::InitError>>;
-
-    fn new_service(&self, cfg: &C) -> Self::Future {
-        self.0.new_service(cfg)
-    }
-}
-
-struct NewServiceWrapper<C, T: NewService> {
-    service: T,
-    _t: std::marker::PhantomData<C>,
-}
-
-impl<C, T, Req, Res, Err, InitErr> NewService for NewServiceWrapper<C, T>
-where
-    Req: 'static,
-    Res: 'static,
-    Err: 'static,
-    InitErr: 'static,
-    T: NewService<Config = C, Request = Req, Response = Res, Error = Err, InitError = InitErr>,
-    T::Future: 'static,
-    T::Service: 'static,
-    <T::Service as Service>::Future: 'static,
-{
-    type Request = Req;
-    type Response = Res;
-    type Error = Err;
-    type InitError = InitErr;
-    type Config = C;
-    type Service = BoxedService<Req, Res, Err>;
-    type Future = Box<Future<Item = Self::Service, Error = Self::InitError>>;
-
-    fn new_service(&self, cfg: &C) -> Self::Future {
-        Box::new(
-            self.service
-                .new_service(cfg)
-                .into_future()
-                .map(ServiceWrapper::boxed),
-        )
-    }
-}
-
-struct ServiceWrapper<T: Service>(T);
-
-impl<T> ServiceWrapper<T>
-where
-    T: Service + 'static,
-    T::Future: 'static,
-{
-    fn boxed(service: T) -> BoxedService<T::Request, T::Response, T::Error> {
-        Box::new(ServiceWrapper(service))
-    }
-}
-
-impl<T, Req, Res, Err> Service for ServiceWrapper<T>
-where
-    T: Service<Request = Req, Response = Res, Error = Err>,
-    T::Future: 'static,
-{
-    type Request = Req;
-    type Response = Res;
-    type Error = Err;
-    type Future = Either<
-        FutureResult<Self::Response, Self::Error>,
-        Box<Future<Item = Self::Response, Error = Self::Error>>,
-    >;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.0.poll_ready()
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        let mut fut = self.0.call(req);
-        match fut.poll() {
-            Ok(Async::Ready(res)) => Either::A(ok(res)),
-            Err(e) => Either::A(err(e)),
-            Ok(Async::NotReady) => Either::B(Box::new(fut)),
-        }
-    }
-}

actix-service/src/cell.rs

@@ -1,40 +0,0 @@
-//! Custom cell impl
-use std::{cell::UnsafeCell, fmt, 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(crate) fn new(inner: T) -> Self {
-        Self {
-            inner: Rc::new(UnsafeCell::new(inner)),
-        }
-    }
-
-    pub(crate) fn get_ref(&self) -> &T {
-        unsafe { &*self.inner.as_ref().get() }
-    }
-
-    pub(crate) fn get_mut(&mut self) -> &mut T {
-        unsafe { &mut *self.inner.as_ref().get() }
-    }
-
-    pub(crate) unsafe fn get_mut_unsafe(&self) -> &mut T {
-        &mut *self.inner.as_ref().get()
-    }
-}

actix-service/src/fn_service.rs

@@ -1,310 +0,0 @@
-use std::marker::PhantomData;
-
-use futures::future::{ok, Future, FutureResult};
-use futures::{try_ready, Async, IntoFuture, Poll};
-
-use crate::{IntoNewService, IntoService, NewService, Service};
-
-/// Create `NewService` for function that can act as a Service
-pub fn service_fn<F, Req, Out, Cfg>(f: F) -> NewServiceFn<F, Req, Out, Cfg>
-where
-    F: FnMut(Req) -> Out + Clone,
-    Out: IntoFuture,
-{
-    NewServiceFn::new(f)
-}
-
-/// Create `NewService` for function that can produce services
-pub fn new_service_fn<F, C, R, S, E>(f: F) -> FnNewServiceNoConfig<F, C, R, S, E>
-where
-    F: Fn() -> R,
-    R: IntoFuture<Item = S, Error = E>,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    FnNewServiceNoConfig::new(f)
-}
-
-/// Create `NewService` for function that can produce services with configuration
-pub fn new_service_cfg<F, C, R, S, E>(f: F) -> FnNewServiceConfig<F, C, R, S, E>
-where
-    F: Fn(&C) -> R,
-    R: IntoFuture<Error = E>,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    FnNewServiceConfig::new(f)
-}
-
-pub struct ServiceFn<F, Req, Out>
-where
-    F: FnMut(Req) -> Out,
-    Out: IntoFuture,
-{
-    f: F,
-    _t: PhantomData<Req>,
-}
-
-impl<F, Req, Out> ServiceFn<F, Req, Out>
-where
-    F: FnMut(Req) -> Out,
-    Out: IntoFuture,
-{
-    pub(crate) fn new(f: F) -> Self {
-        ServiceFn { f, _t: PhantomData }
-    }
-}
-
-impl<F, Req, Out> Clone for ServiceFn<F, Req, Out>
-where
-    F: FnMut(Req) -> Out + Clone,
-    Out: IntoFuture,
-{
-    fn clone(&self) -> Self {
-        ServiceFn::new(self.f.clone())
-    }
-}
-
-impl<F, Req, Out> Service for ServiceFn<F, Req, Out>
-where
-    F: FnMut(Req) -> Out,
-    Out: IntoFuture,
-{
-    type Request = Req;
-    type Response = Out::Item;
-    type Error = Out::Error;
-    type Future = Out::Future;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, req: Req) -> Self::Future {
-        (self.f)(req).into_future()
-    }
-}
-
-impl<F, Req, Out> IntoService<ServiceFn<F, Req, Out>> for F
-where
-    F: FnMut(Req) -> Out,
-    Out: IntoFuture,
-{
-    fn into_service(self) -> ServiceFn<F, Req, Out> {
-        ServiceFn::new(self)
-    }
-}
-
-pub struct NewServiceFn<F, Req, Out, Cfg>
-where
-    F: FnMut(Req) -> Out,
-    Out: IntoFuture,
-{
-    f: F,
-    _t: PhantomData<(Req, Cfg)>,
-}
-
-impl<F, Req, Out, Cfg> NewServiceFn<F, Req, Out, Cfg>
-where
-    F: FnMut(Req) -> Out + Clone,
-    Out: IntoFuture,
-{
-    pub(crate) fn new(f: F) -> Self {
-        NewServiceFn { f, _t: PhantomData }
-    }
-}
-
-impl<F, Req, Out, Cfg> Clone for NewServiceFn<F, Req, Out, Cfg>
-where
-    F: FnMut(Req) -> Out + Clone,
-    Out: IntoFuture,
-{
-    fn clone(&self) -> Self {
-        NewServiceFn::new(self.f.clone())
-    }
-}
-
-impl<F, Req, Out, Cfg> NewService for NewServiceFn<F, Req, Out, Cfg>
-where
-    F: FnMut(Req) -> Out + Clone,
-    Out: IntoFuture,
-{
-    type Request = Req;
-    type Response = Out::Item;
-    type Error = Out::Error;
-
-    type Config = Cfg;
-    type Service = ServiceFn<F, Req, Out>;
-    type InitError = ();
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self, _: &Cfg) -> Self::Future {
-        ok(ServiceFn::new(self.f.clone()))
-    }
-}
-
-impl<F, Req, Out, Cfg> IntoService<ServiceFn<F, Req, Out>> for NewServiceFn<F, Req, Out, Cfg>
-where
-    F: FnMut(Req) -> Out + Clone,
-    Out: IntoFuture,
-{
-    fn into_service(self) -> ServiceFn<F, Req, Out> {
-        ServiceFn::new(self.f.clone())
-    }
-}
-
-impl<F, Req, Out, Cfg> IntoNewService<NewServiceFn<F, Req, Out, Cfg>> for F
-where
-    F: Fn(Req) -> Out + Clone,
-    Out: IntoFuture,
-{
-    fn into_new_service(self) -> NewServiceFn<F, Req, Out, Cfg> {
-        NewServiceFn::new(self)
-    }
-}
-
-/// Convert `Fn(&Config) -> Future<Service>` fn to NewService
-pub struct FnNewServiceConfig<F, C, R, S, E>
-where
-    F: Fn(&C) -> R,
-    R: IntoFuture<Error = E>,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    f: F,
-    _t: PhantomData<(C, R, S, E)>,
-}
-
-impl<F, C, R, S, E> FnNewServiceConfig<F, C, R, S, E>
-where
-    F: Fn(&C) -> R,
-    R: IntoFuture<Error = E>,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    pub fn new(f: F) -> Self {
-        FnNewServiceConfig { f, _t: PhantomData }
-    }
-}
-
-impl<F, C, R, S, E> NewService for FnNewServiceConfig<F, C, R, S, E>
-where
-    F: Fn(&C) -> R,
-    R: IntoFuture<Error = E>,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = S::Error;
-
-    type Config = C;
-    type Service = S;
-    type InitError = E;
-    type Future = FnNewServiceConfigFut<R, S, E>;
-
-    fn new_service(&self, cfg: &C) -> Self::Future {
-        FnNewServiceConfigFut {
-            fut: (self.f)(cfg).into_future(),
-            _t: PhantomData,
-        }
-    }
-}
-
-pub struct FnNewServiceConfigFut<R, S, E>
-where
-    R: IntoFuture<Error = E>,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    fut: R::Future,
-    _t: PhantomData<(S,)>,
-}
-
-impl<R, S, E> Future for FnNewServiceConfigFut<R, S, E>
-where
-    R: IntoFuture<Error = E>,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    type Item = S;
-    type Error = R::Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        Ok(Async::Ready(try_ready!(self.fut.poll()).into_service()))
-    }
-}
-
-impl<F, C, R, S, E> Clone for FnNewServiceConfig<F, C, R, S, E>
-where
-    F: Fn(&C) -> R + Clone,
-    R: IntoFuture<Error = E>,
-    R::Item: IntoService<S>,
-    S: Service,
-{
-    fn clone(&self) -> Self {
-        Self::new(self.f.clone())
-    }
-}
-
-/// Converter for `Fn() -> Future<Service>` fn
-pub struct FnNewServiceNoConfig<F, C, R, S, E>
-where
-    F: Fn() -> R,
-    R: IntoFuture<Item = S, Error = E>,
-    S: Service,
-{
-    f: F,
-    _t: PhantomData<C>,
-}
-
-impl<F, C, R, S, E> FnNewServiceNoConfig<F, C, R, S, E>
-where
-    F: Fn() -> R,
-    R: IntoFuture<Item = S, Error = E>,
-    S: Service,
-{
-    pub fn new(f: F) -> Self {
-        FnNewServiceNoConfig { f, _t: PhantomData }
-    }
-}
-
-impl<F, C, R, S, E> NewService for FnNewServiceNoConfig<F, C, R, S, E>
-where
-    F: Fn() -> R,
-    R: IntoFuture<Item = S, Error = E>,
-    S: Service,
-{
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = S::Error;
-    type Service = S;
-    type Config = C;
-    type InitError = E;
-    type Future = R::Future;
-
-    fn new_service(&self, _: &C) -> Self::Future {
-        (self.f)().into_future()
-    }
-}
-
-impl<F, C, R, S, E> Clone for FnNewServiceNoConfig<F, C, R, S, E>
-where
-    F: Fn() -> R + Clone,
-    R: IntoFuture<Item = S, Error = E>,
-    S: Service,
-{
-    fn clone(&self) -> Self {
-        Self::new(self.f.clone())
-    }
-}
-
-impl<F, C, R, S, E> IntoNewService<FnNewServiceNoConfig<F, C, R, S, E>> for F
-where
-    F: Fn() -> R,
-    R: IntoFuture<Item = S, Error = E>,
-    S: Service,
-{
-    fn into_new_service(self) -> FnNewServiceNoConfig<F, C, R, S, E> {
-        FnNewServiceNoConfig::new(self)
-    }
-}

actix-service/src/fn_transform.rs

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

actix-service/src/lib.rs

@@ -1,459 +0,0 @@
-use std::cell::RefCell;
-use std::rc::Rc;
-use std::sync::Arc;
-
-use futures::{Future, IntoFuture, Poll};
-
-mod and_then;
-mod and_then_apply;
-mod and_then_apply_fn;
-mod apply;
-mod apply_cfg;
-pub mod blank;
-pub mod boxed;
-mod cell;
-mod fn_service;
-mod fn_transform;
-mod from_err;
-mod map;
-mod map_config;
-mod map_err;
-mod map_init_err;
-mod then;
-mod transform;
-mod transform_err;
-
-pub use self::and_then::{AndThen, AndThenNewService};
-pub use self::apply::{apply_fn, new_apply_fn, Apply, ApplyNewService};
-pub use self::apply_cfg::{apply_cfg, new_apply_cfg};
-pub use self::fn_service::{new_service_cfg, new_service_fn, service_fn, ServiceFn};
-pub use self::fn_transform::transform_fn;
-pub use self::from_err::{FromErr, FromErrNewService};
-pub use self::map::{Map, MapNewService};
-pub use self::map_config::{MapConfig, MappedConfig, UnitConfig};
-pub use self::map_err::{MapErr, MapErrNewService};
-pub use self::map_init_err::MapInitErr;
-pub use self::then::{Then, ThenNewService};
-pub use self::transform::{apply_transform, IntoTransform, Transform};
-
-use self::and_then_apply::AndThenTransform;
-use self::and_then_apply_fn::{AndThenApply, AndThenApplyNewService};
-
-/// An asynchronous function from `Request` to a `Response`.
-pub trait Service {
-    /// Requests handled by the service.
-    type Request;
-
-    /// Responses given by the service.
-    type Response;
-
-    /// Errors produced by the service.
-    type Error;
-
-    /// The future response value.
-    type Future: Future<Item = Self::Response, Error = Self::Error>;
-
-    /// Returns `Ready` when the service is able to process requests.
-    ///
-    /// If the service is at capacity, then `NotReady` is returned and the task
-    /// is notified when the service becomes ready again. This function is
-    /// expected to be called while on a task.
-    ///
-    /// 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.
-    fn poll_ready(&mut self) -> Poll<(), Self::Error>;
-
-    /// Process the request and return the response asynchronously.
-    ///
-    /// This function is expected to be callable off task. As such,
-    /// implementations should take care to not call `poll_ready`. If the
-    /// service is at capacity and the request is unable to be handled, the
-    /// returned `Future` should resolve to an error.
-    ///
-    /// Calling `call` without calling `poll_ready` is permitted. The
-    /// implementation must be resilient to this fact.
-    fn call(&mut self, req: Self::Request) -> Self::Future;
-}
-
-/// An extension trait for `Service`s that provides a variety of convenient
-/// adapters
-pub trait ServiceExt: Service {
-    /// Apply function to specified service and use it as a next service in
-    /// chain.
-    fn apply_fn<F, B, B1, Out>(self, service: B1, f: F) -> AndThenApply<Self, B, F, Out>
-    where
-        Self: Sized,
-        F: FnMut(Self::Response, &mut B) -> Out,
-        Out: IntoFuture,
-        Out::Error: Into<Self::Error>,
-        B: Service<Error = Self::Error>,
-        B1: IntoService<B>,
-    {
-        AndThenApply::new(self, service, f)
-    }
-
-    /// Call another service after call to this one has resolved successfully.
-    ///
-    /// This function can be used to chain two services together and ensure that
-    /// the second service isn't called until call to the fist service have
-    /// finished. Result of the call to the first service is used as an
-    /// input parameter for the second service's call.
-    ///
-    /// Note that this function consumes the receiving service and returns a
-    /// wrapped version of it.
-    fn and_then<F, B>(self, service: F) -> AndThen<Self, B>
-    where
-        Self: Sized,
-        F: IntoService<B>,
-        B: Service<Request = Self::Response, Error = Self::Error>,
-    {
-        AndThen::new(self, service.into_service())
-    }
-
-    /// Map this service's error to any error implementing `From` for
-    /// this service`s `Error`.
-    ///
-    /// Note that this function consumes the receiving service and returns a
-    /// wrapped version of it.
-    fn from_err<E>(self) -> FromErr<Self, E>
-    where
-        Self: Sized,
-        E: From<Self::Error>,
-    {
-        FromErr::new(self)
-    }
-
-    /// Chain on a computation for when a call to the service finished,
-    /// passing the result of the call to the next service `B`.
-    ///
-    /// Note that this function consumes the receiving service and returns a
-    /// wrapped version of it.
-    fn then<B>(self, service: B) -> Then<Self, B>
-    where
-        Self: Sized,
-        B: Service<Request = Result<Self::Response, Self::Error>, Error = Self::Error>,
-    {
-        Then::new(self, 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.
-    fn map<F, R>(self, f: F) -> Map<Self, F, R>
-    where
-        Self: Sized,
-        F: FnMut(Self::Response) -> R,
-    {
-        Map::new(self, f)
-    }
-
-    /// Map this service's error to a different error, returning a new service.
-    ///
-    /// This function is similar to the `Result::map_err` where it will change
-    /// the error type of the underlying service. 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.
-    fn map_err<F, E>(self, f: F) -> MapErr<Self, F, E>
-    where
-        Self: Sized,
-        F: Fn(Self::Error) -> E,
-    {
-        MapErr::new(self, f)
-    }
-}
-
-impl<T: ?Sized> ServiceExt for T where T: Service {}
-
-/// Creates new `Service` values.
-///
-/// Acts as a service factory. This is useful for cases where new `Service`
-/// values must be produced. One case is a TCP servier listener. The listner
-/// accepts new TCP streams, obtains a new `Service` value using the
-/// `NewService` trait, and uses that new `Service` value to process inbound
-/// requests on that new TCP stream.
-///
-/// `Config` is a service factory configuration type.
-pub trait NewService {
-    /// Requests handled by the service.
-    type Request;
-
-    /// Responses given by the service
-    type Response;
-
-    /// Errors produced by the service
-    type Error;
-
-    /// Service factory configuration
-    type Config;
-
-    /// The `Service` value created by this factory
-    type Service: Service<
-        Request = Self::Request,
-        Response = Self::Response,
-        Error = Self::Error,
-    >;
-
-    /// Errors produced while building a service.
-    type InitError;
-
-    /// The future of the `Service` instance.
-    type Future: Future<Item = Self::Service, Error = Self::InitError>;
-
-    /// Create and return a new service value asynchronously.
-    fn new_service(&self, cfg: &Self::Config) -> Self::Future;
-
-    /// Apply transform service to specified service and use it as a next service in
-    /// chain.
-    fn apply<T, T1, B, B1>(self, transform: T1, service: B1) -> AndThenTransform<T, Self, B>
-    where
-        Self: Sized,
-        T: Transform<B::Service, Request = Self::Response, InitError = Self::InitError>,
-        T::Error: From<Self::Error>,
-        T1: IntoTransform<T, B::Service>,
-        B: NewService<Config = Self::Config, InitError = Self::InitError>,
-        B1: IntoNewService<B>,
-    {
-        AndThenTransform::new(transform.into_transform(), self, service.into_new_service())
-    }
-
-    /// Apply function to specified service and use it as a next service in
-    /// chain.
-    fn apply_fn<B, I, F, Out>(self, service: I, f: F) -> AndThenApplyNewService<Self, B, F, Out>
-    where
-        Self: Sized,
-        B: NewService<Config = Self::Config, Error = Self::Error, InitError = Self::InitError>,
-        I: IntoNewService<B>,
-        F: FnMut(Self::Response, &mut B::Service) -> Out,
-        Out: IntoFuture,
-        Out::Error: Into<Self::Error>,
-    {
-        AndThenApplyNewService::new(self, service, f)
-    }
-
-    /// Call another service after call to this one has resolved successfully.
-    fn and_then<F, B>(self, new_service: F) -> AndThenNewService<Self, B>
-    where
-        Self: Sized,
-        F: IntoNewService<B>,
-        B: NewService<
-            Config = Self::Config,
-            Request = Self::Response,
-            Error = Self::Error,
-            InitError = Self::InitError,
-        >,
-    {
-        AndThenNewService::new(self, new_service)
-    }
-
-    /// `NewService` that create service to map this service's error
-    /// and new service's init error to any error
-    /// implementing `From` for this service`s `Error`.
-    ///
-    /// Note that this function consumes the receiving new service and returns a
-    /// wrapped version of it.
-    fn from_err<E>(self) -> FromErrNewService<Self, E>
-    where
-        Self: Sized,
-        E: From<Self::Error>,
-    {
-        FromErrNewService::new(self)
-    }
-
-    /// 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 `B`.
-    ///
-    /// Note that this function consumes the receiving future and returns a
-    /// wrapped version of it.
-    fn then<F, B>(self, new_service: F) -> ThenNewService<Self, B>
-    where
-        Self: Sized,
-        F: IntoNewService<B>,
-        B: NewService<
-            Config = Self::Config,
-            Request = Result<Self::Response, Self::Error>,
-            Error = Self::Error,
-            InitError = Self::InitError,
-        >,
-    {
-        ThenNewService::new(self, new_service)
-    }
-
-    /// Map this service's output to a different type, returning a new service
-    /// of the resulting type.
-    fn map<F, R>(self, f: F) -> MapNewService<Self, F, R>
-    where
-        Self: Sized,
-        F: FnMut(Self::Response) -> R,
-    {
-        MapNewService::new(self, f)
-    }
-
-    /// Map this service's error to a different error, returning a new service.
-    fn map_err<F, E>(self, f: F) -> MapErrNewService<Self, F, E>
-    where
-        Self: Sized,
-        F: Fn(Self::Error) -> E + Clone,
-    {
-        MapErrNewService::new(self, f)
-    }
-
-    /// Map this factory's init error to a different error, returning a new service.
-    fn map_init_err<F, E>(self, f: F) -> MapInitErr<Self, F, E>
-    where
-        Self: Sized,
-        F: Fn(Self::InitError) -> E,
-    {
-        MapInitErr::new(self, f)
-    }
-
-    /// Map config to a different error, returning a new service.
-    fn map_config<F, C>(self, f: F) -> MapConfig<Self, F, C>
-    where
-        Self: Sized,
-        F: Fn(&C) -> MappedConfig<Self::Config>,
-    {
-        MapConfig::new(self, f)
-    }
-
-    /// Replace config with unit
-    fn unit_config<C>(self) -> UnitConfig<Self, C>
-    where
-        Self: NewService<Config = ()> + Sized,
-    {
-        UnitConfig::new(self)
-    }
-}
-
-impl<'a, S> Service for &'a mut S
-where
-    S: Service + 'a,
-{
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = S::Error;
-    type Future = S::Future;
-
-    fn poll_ready(&mut self) -> Poll<(), S::Error> {
-        (**self).poll_ready()
-    }
-
-    fn call(&mut self, request: Self::Request) -> S::Future {
-        (**self).call(request)
-    }
-}
-
-impl<S> Service for Box<S>
-where
-    S: Service + ?Sized,
-{
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = S::Error;
-    type Future = S::Future;
-
-    fn poll_ready(&mut self) -> Poll<(), S::Error> {
-        (**self).poll_ready()
-    }
-
-    fn call(&mut self, request: Self::Request) -> S::Future {
-        (**self).call(request)
-    }
-}
-
-impl<S> Service for Rc<RefCell<S>>
-where
-    S: Service,
-{
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = S::Error;
-    type Future = S::Future;
-
-    fn poll_ready(&mut self) -> Poll<(), S::Error> {
-        self.borrow_mut().poll_ready()
-    }
-
-    fn call(&mut self, request: Self::Request) -> S::Future {
-        self.borrow_mut().call(request)
-    }
-}
-
-impl<S> NewService for Rc<S>
-where
-    S: NewService,
-{
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = S::Error;
-    type Config = S::Config;
-    type Service = S::Service;
-    type InitError = S::InitError;
-    type Future = S::Future;
-
-    fn new_service(&self, cfg: &S::Config) -> S::Future {
-        self.as_ref().new_service(cfg)
-    }
-}
-
-impl<S> NewService for Arc<S>
-where
-    S: NewService,
-{
-    type Request = S::Request;
-    type Response = S::Response;
-    type Error = S::Error;
-    type Config = S::Config;
-    type Service = S::Service;
-    type InitError = S::InitError;
-    type Future = S::Future;
-
-    fn new_service(&self, cfg: &S::Config) -> S::Future {
-        self.as_ref().new_service(cfg)
-    }
-}
-
-/// Trait for types that can be converted to a `Service`
-pub trait IntoService<T>
-where
-    T: Service,
-{
-    /// Convert to a `Service`
-    fn into_service(self) -> T;
-}
-
-/// Trait for types that can be converted to a `NewService`
-pub trait IntoNewService<T>
-where
-    T: NewService,
-{
-    /// Convert to an `NewService`
-    fn into_new_service(self) -> T;
-}
-
-impl<T> IntoService<T> for T
-where
-    T: Service,
-{
-    fn into_service(self) -> T {
-        self
-    }
-}
-
-impl<T> IntoNewService<T> for T
-where
-    T: NewService,
-{
-    fn into_new_service(self) -> T {
-        self
-    }
-}

actix-service/src/map_config.rs

@@ -1,112 +0,0 @@
-use std::marker::PhantomData;
-
-use super::NewService;
-
-pub enum MappedConfig<'a, T> {
-    Ref(&'a T),
-    Owned(T),
-}
-
-/// `MapInitErr` service combinator
-pub struct MapConfig<A, F, C> {
-    a: A,
-    f: F,
-    e: PhantomData<C>,
-}
-
-impl<A, F, C> MapConfig<A, F, C> {
-    /// Create new `MapConfig` combinator
-    pub fn new(a: A, f: F) -> Self
-    where
-        A: NewService,
-        F: Fn(&C) -> MappedConfig<A::Config>,
-    {
-        Self {
-            a,
-            f,
-            e: PhantomData,
-        }
-    }
-}
-
-impl<A, F, C> Clone for MapConfig<A, F, C>
-where
-    A: Clone,
-    F: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            a: self.a.clone(),
-            f: self.f.clone(),
-            e: PhantomData,
-        }
-    }
-}
-
-impl<A, F, C> NewService for MapConfig<A, F, C>
-where
-    A: NewService,
-    F: Fn(&C) -> MappedConfig<A::Config>,
-{
-    type Request = A::Request;
-    type Response = A::Response;
-    type Error = A::Error;
-
-    type Config = C;
-    type Service = A::Service;
-    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),
-        }
-    }
-}
-
-/// `MapInitErr` service combinator
-pub struct UnitConfig<A, C> {
-    a: A,
-    e: PhantomData<C>,
-}
-
-impl<A, C> UnitConfig<A, C> {
-    /// Create new `UnitConfig` combinator
-    pub fn new(a: A) -> Self
-    where
-        A: NewService<Config = ()>,
-    {
-        Self { a, e: PhantomData }
-    }
-}
-
-impl<A, C> Clone for UnitConfig<A, C>
-where
-    A: Clone,
-{
-    fn clone(&self) -> Self {
-        Self {
-            a: self.a.clone(),
-            e: PhantomData,
-        }
-    }
-}
-
-impl<A, C> NewService for UnitConfig<A, C>
-where
-    A: NewService<Config = ()>,
-{
-    type Request = A::Request;
-    type Response = A::Response;
-    type Error = A::Error;
-
-    type Config = C;
-    type Service = A::Service;
-    type InitError = A::InitError;
-    type Future = A::Future;
-
-    fn new_service(&self, _: &C) -> Self::Future {
-        self.a.new_service(&())
-    }
-}

actix-service/src/transform.rs

@@ -1,232 +0,0 @@
-use std::rc::Rc;
-use std::sync::Arc;
-
-use futures::{Async, Future, IntoFuture, Poll};
-
-use crate::transform_err::{TransformFromErr, TransformMapInitErr};
-use crate::{IntoNewService, NewService, 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.
-pub trait Transform<S> {
-    /// Requests handled by the service.
-    type Request;
-
-    /// Responses given by the service.
-    type Response;
-
-    /// Errors produced by the service.
-    type Error;
-
-    /// The `TransformService` value created by this factory
-    type Transform: Service<
-        Request = Self::Request,
-        Response = Self::Response,
-        Error = Self::Error,
-    >;
-
-    /// Errors produced while building a service.
-    type InitError;
-
-    /// The future response value.
-    type Future: Future<Item = Self::Transform, Error = Self::InitError>;
-
-    /// Creates and returns a new Service component, asynchronously
-    fn new_transform(&self, service: S) -> Self::Future;
-
-    /// Map this service'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,
-    {
-        TransformMapInitErr::new(self, f)
-    }
-
-    /// Map this service's init error to any error implementing `From` for
-    /// this service`s `Error`.
-    ///
-    /// Note that this function consumes the receiving transform and returns a
-    /// wrapped version of it.
-    fn from_err<E>(self) -> TransformFromErr<Self, S, E>
-    where
-        Self: Sized,
-        E: From<Self::InitError>,
-    {
-        TransformFromErr::new(self)
-    }
-
-    // /// Map this service's init error to service's init error
-    // /// if it is implementing `Into` to this service`s `InitError`.
-    // ///
-    // /// Note that this function consumes the receiving transform and returns a
-    // /// wrapped version of it.
-    // fn into_err<E>(self) -> TransformIntoErr<Self, S>
-    // where
-    //     Self: Sized,
-    //     Self::InitError: From<Self::InitError>,
-    // {
-    //     TransformFromErr::new(self)
-    // }
-}
-
-impl<T, S> Transform<S> for Rc<T>
-where
-    T: Transform<S>,
-{
-    type Request = T::Request;
-    type Response = T::Response;
-    type Error = T::Error;
-    type InitError = T::InitError;
-    type Transform = T::Transform;
-    type Future = T::Future;
-
-    fn new_transform(&self, service: S) -> T::Future {
-        self.as_ref().new_transform(service)
-    }
-}
-
-impl<T, S> Transform<S> for Arc<T>
-where
-    T: Transform<S>,
-{
-    type Request = T::Request;
-    type Response = T::Response;
-    type Error = T::Error;
-    type InitError = T::InitError;
-    type Transform = T::Transform;
-    type Future = T::Future;
-
-    fn new_transform(&self, service: S) -> T::Future {
-        self.as_ref().new_transform(service)
-    }
-}
-
-/// Trait for types that can be converted to a *transform service*
-pub trait IntoTransform<T, S>
-where
-    T: Transform<S>,
-{
-    /// Convert to a `TransformService`
-    fn into_transform(self) -> T;
-}
-
-impl<T, S> IntoTransform<T, S> for T
-where
-    T: Transform<S>,
-{
-    fn into_transform(self) -> T {
-        self
-    }
-}
-
-/// Apply transform to service factory. Function returns
-/// services factory that in initialization creates
-/// service and applies transform to this service.
-pub fn apply_transform<T, S, F, U>(
-    t: F,
-    service: U,
-) -> impl NewService<
-    Config = S::Config,
-    Request = T::Request,
-    Response = T::Response,
-    Error = T::Error,
-    Service = T::Transform,
-    InitError = S::InitError,
-> + Clone
-where
-    S: NewService,
-    T: Transform<S::Service, InitError = S::InitError>,
-    F: IntoTransform<T, S::Service>,
-    U: IntoNewService<S>,
-{
-    ApplyTransform::new(t.into_transform(), service.into_new_service())
-}
-
-/// `Apply` transform to new service
-pub struct ApplyTransform<T, S> {
-    s: Rc<S>,
-    t: Rc<T>,
-}
-
-impl<T, S> ApplyTransform<T, S>
-where
-    S: NewService,
-    T: Transform<S::Service, InitError = S::InitError>,
-{
-    /// Create new `ApplyTransform` new service instance
-    pub fn new<F: IntoTransform<T, S::Service>>(t: F, service: S) -> Self {
-        Self {
-            s: Rc::new(service),
-            t: Rc::new(t.into_transform()),
-        }
-    }
-}
-
-impl<T, S> Clone for ApplyTransform<T, S> {
-    fn clone(&self) -> Self {
-        ApplyTransform {
-            s: self.s.clone(),
-            t: self.t.clone(),
-        }
-    }
-}
-
-impl<T, S> NewService for ApplyTransform<T, S>
-where
-    S: NewService,
-    T: Transform<S::Service, InitError = S::InitError>,
-{
-    type Request = T::Request;
-    type Response = T::Response;
-    type Error = T::Error;
-
-    type Config = S::Config;
-    type Service = T::Transform;
-    type InitError = T::InitError;
-    type Future = ApplyTransformFuture<T, S>;
-
-    fn new_service(&self, cfg: &S::Config) -> Self::Future {
-        ApplyTransformFuture {
-            t_cell: self.t.clone(),
-            fut_a: self.s.new_service(cfg).into_future(),
-            fut_t: None,
-        }
-    }
-}
-
-pub struct ApplyTransformFuture<T, S>
-where
-    S: NewService,
-    T: Transform<S::Service, InitError = S::InitError>,
-{
-    fut_a: S::Future,
-    fut_t: Option<<T::Future as IntoFuture>::Future>,
-    t_cell: Rc<T>,
-}
-
-impl<T, S> Future for ApplyTransformFuture<T, S>
-where
-    S: NewService,
-    T: Transform<S::Service, InitError = S::InitError>,
-{
-    type Item = T::Transform;
-    type Error = T::InitError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if self.fut_t.is_none() {
-            if let Async::Ready(service) = self.fut_a.poll()? {
-                self.fut_t = Some(self.t_cell.new_transform(service).into_future());
-            }
-        }
-        if let Some(ref mut fut) = self.fut_t {
-            fut.poll()
-        } else {
-            Ok(Async::NotReady)
-        }
-    }
-}

actix-service/src/transform_err.rs

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

actix-test-server/Cargo.toml

@@ -1,59 +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.1.0"
-
-log = "0.4"
-net2 = "0.2"
-futures = "0.1"
-tokio-tcp = "0.1"
-tokio-reactor = "0.1"
-
-# native-tls
-native-tls = { version="0.2", optional = true }
-
-# openssl
-openssl = { version="0.10", optional = true }
-
-#rustls
-rustls = { version = "^0.15", optional = true }
-tokio-rustls = { version = "^0.9", optional = true }
-webpki = { version = "0.19", optional = true }
-webpki-roots = { version = "0.16", optional = true }
-
-[dev-dependencies]
-actix-service = "0.4.0"

actix-test-server/LICENSE-APACHE

@@ -1 +0,0 @@
-../LICENSE-APACHE

actix-test-server/LICENSE-MIT

@@ -1 +0,0 @@
-../LICENSE-MIT

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-threadpool/CHANGES.md

@@ -1,13 +0,0 @@
-# Changes
-
-### Changed
-
-* Update `derive_more` to 0.15
-
-## [0.1.1] - 2019-06-05
-
-* Update parking_lot
-
-## [0.1.0] - 2019-03-28
-
-* Move threadpool to separate crate

actix-threadpool/Cargo.toml

@@ -1,27 +0,0 @@
-[package]
-name = "actix-threadpool"
-version = "0.1.1"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix thread pool for sync code"
-keywords = ["actix", "network", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-threadpool/"
-categories = ["network-programming", "asynchronous"]
-license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
-edition = "2018"
-workspace = ".."
-
-[lib]
-name = "actix_threadpool"
-path = "src/lib.rs"
-
-[dependencies]
-derive_more = "0.15"
-futures = "0.1.25"
-parking_lot = "0.8"
-lazy_static = "1.2"
-log = "0.4"
-num_cpus = "1.10"
-threadpool = "1.7"

actix-threadpool/LICENSE-APACHE

@@ -1 +0,0 @@
-../LICENSE-APACHE

actix-threadpool/LICENSE-MIT

@@ -1 +0,0 @@
-../LICENSE-MIT

actix-threadpool/src/lib.rs

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

actix-tower/CHANGES.md

@@ -1,2 +0,0 @@
-# Changes
-

actix-tower/Cargo.toml

@@ -1,29 +0,0 @@
-[package]
-name = "actix-tower"
-version = "0.1.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Marcus Griep <marcus@griep.us>"]
-description = "Actix Tower"
-keywords = ["network", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-net.git"
-documentation = "https://docs.rs/actix-tower/"
-categories = ["network-programming", "asynchronous"]
-license = "MIT/Apache-2.0"
-exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
-edition = "2018"
-workspace = ".."
-
-[badges]
-travis-ci = { repository = "actix/actix-tower", branch = "master" }
-appveyor = { repository = "actix/actix-net" }
-codecov = { repository = "actix/actix-tower", branch = "master", service = "github" }
-
-[lib]
-name = "actix_tower"
-path = "src/lib.rs"
-
-[dependencies]
-actix-service = "0.3.6"
-futures = "0.1.24"
-tower-service = "0.2.0"
-

actix-tower/LICENSE-APACHE

@@ -1 +0,0 @@
-../LICENSE-APACHE

actix-tower/LICENSE-MIT

@@ -1 +0,0 @@
-../LICENSE-MIT

actix-tower/src/lib.rs

@@ -1,580 +0,0 @@
-//! Utilities to provide interoperability between services based on the
-//! `actix-service` and `tower-service` crates.
-//!
-//! ## Example
-//!
-//! In the following example, we take a `RandomService`—which will always
-//! return 4—and wraps it with a middleware that will always add 1 to the
-//! result. This pattern can be further used to wrap services from either
-//! `tower-service` or `actix-service` with middleware provided by the other.
-//!
-//! ```
-//! use actix_tower::ActixServiceExt;
-//! # use futures::{Async, Future};
-//! use actix_service::Service;
-//!
-//! struct RandomService;
-//! impl Service for RandomService {
-//!     // …
-//! #    type Request = ();
-//! #    type Response = u32;
-//! #    type Error = ();
-//! #    type Future = futures::future::FutureResult<Self::Response, Self::Error>;
-//! #
-//! #    fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
-//! #        Ok(Async::Ready(()))
-//! #    }
-//! #
-//! #    fn call(&mut self, _req: Self::Request) -> Self::Future {
-//! #        futures::finished(4)
-//! #     }
-//! }
-//!
-//! struct AddOneMiddleware<S>(S);
-//! impl<S, R> tower_service::Service<R> for AddOneMiddleware<S>
-//! where
-//!     S: tower_service::Service<R, Response = u32>,
-//!     S::Future: 'static,
-//! {
-//!     /// …
-//! #    type Response = u32;
-//! #    type Error = S::Error;
-//! #    type Future = Box<dyn Future<Item = Self::Response, Error = Self::Error>>;
-//! #
-//! #    fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
-//! #        self.0.poll_ready()
-//! #    }
-//! #
-//! #    fn call(&mut self, req: R) -> Self::Future {
-//! #        let fut = self.0.call(req).map(|x| x + 1);
-//! #        Box::new(fut)
-//! #    }
-//! }
-//!
-//! let mut s = RandomService.wrap_with_tower_middleware(AddOneMiddleware);
-//! assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-//! assert_eq!(Ok(Async::Ready(5)), s.call(()).poll());
-//! ```
-
-use actix_service::Service as ActixService;
-use std::marker::PhantomData;
-use tower_service::Service as TowerService;
-
-/// Compatibility wrapper associating a `tower_service::Service` with a particular
-/// `Request` type, so that it can be used as an `actix_service::Service`.
-///
-/// Generally created through convenience methods on the `TowerServiceExt<R>` trait.
-pub struct ActixCompat<S, R> {
-    inner: S,
-    _phantom: PhantomData<R>,
-}
-
-impl<S, R> ActixCompat<S, R> {
-    /// Wraps a `tower_service::Service` in a compatibility wrapper.
-    pub fn new(inner: S) -> Self {
-        ActixCompat {
-            inner,
-            _phantom: PhantomData,
-        }
-    }
-}
-
-/// Extension trait for wrapping a `tower_service::Service` instance for use as
-/// an `actix_service::Service`.
-pub trait TowerServiceExt<R>: TowerService<R> + Sized {
-    /// Wraps a `tower_service::Service` in a compatibility wrapper.
-    ///
-    /// ```
-    /// use actix_service::Service;
-    /// use actix_tower::TowerServiceExt;
-    /// # use futures::{Async, Future};
-    ///
-    /// struct RandomService;
-    /// impl<R> tower_service::Service<R> for RandomService {
-    ///     // …
-    /// #    type Response = u32;
-    /// #    type Error = ();
-    /// #    type Future = futures::future::FutureResult<Self::Response, Self::Error>;
-    /// #
-    /// #    fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
-    /// #        Ok(Async::Ready(()))
-    /// #    }
-    /// #
-    /// #    fn call(&mut self, _req: R) -> Self::Future {
-    /// #        futures::finished(4)
-    /// #     }
-    /// }
-    ///
-    /// let mut s = RandomService.into_actix_service();
-    /// assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-    /// assert_eq!(Ok(Async::Ready(4)), s.call(()).poll());
-    /// ```
-    fn into_actix_service(self) -> ActixCompat<Self, R> {
-        ActixCompat::new(self)
-    }
-
-    /// Takes a function that, when provided with an `actix_service::Service` wraps it
-    /// and returns a new service. Useful for wrapping a `tower_service::Service` with
-    /// middleware built for `actix_service`.
-    ///
-    /// ```
-    /// use actix_tower::TowerServiceExt;
-    /// # use futures::{Async, Future};
-    /// use tower_service::Service;
-    ///
-    /// struct RandomService;
-    /// impl<R> Service<R> for RandomService {
-    ///     // …
-    /// #    type Response = u32;
-    /// #    type Error = ();
-    /// #    type Future = futures::future::FutureResult<Self::Response, Self::Error>;
-    /// #
-    /// #    fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
-    /// #        Ok(Async::Ready(()))
-    /// #    }
-    /// #
-    /// #    fn call(&mut self, _req: R) -> Self::Future {
-    /// #        futures::finished(4)
-    /// #     }
-    /// }
-    ///
-    /// struct AddOneTransform<S>(S);
-    /// impl<S> actix_service::Service for AddOneTransform<S>
-    /// where
-    ///     S: actix_service::Service<Response = u32>,
-    ///     S::Future: 'static,
-    /// {
-    ///     /// …
-    /// #    type Request = S::Request;
-    /// #    type Response = u32;
-    /// #    type Error = S::Error;
-    /// #    type Future = Box<dyn Future<Item = Self::Response, Error = Self::Error>>;
-    /// #
-    /// #    fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
-    /// #        self.0.poll_ready()
-    /// #    }
-    /// #
-    /// #    fn call(&mut self, req: Self::Request) -> Self::Future {
-    /// #        let fut = self.0.call(req).map(|x| x + 1);
-    /// #        Box::new(fut)
-    /// #    }
-    /// }
-    ///
-    /// let mut s = RandomService.wrap_with_actix_middleware(AddOneTransform);
-    /// assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-    /// assert_eq!(Ok(Async::Ready(5)), s.call(()).poll());
-    /// ```
-    fn wrap_with_actix_middleware<F, U>(self, f: F) -> TowerCompat<U>
-    where
-        F: FnOnce(ActixCompat<Self, R>) -> U,
-        U: ActixService<Request = R>,
-    {
-        f(self.into_actix_service()).into_tower_service()
-    }
-}
-
-impl<S, R> TowerServiceExt<R> for S where S: TowerService<R> + Sized {}
-
-impl<S, R> ActixService for ActixCompat<S, R>
-where
-    S: TowerService<R>,
-{
-    type Request = R;
-    type Response = S::Response;
-    type Error = S::Error;
-    type Future = S::Future;
-
-    fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
-        TowerService::poll_ready(&mut self.inner)
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        TowerService::call(&mut self.inner, req)
-    }
-}
-
-/// Compatibility wrapper associating an `actix_service::Service` with a particular
-/// `Request` type, so that it can be used as a `tower_service::Service`.
-///
-/// Generally created through convenience methods on the `ActixServiceExt<R>` trait.
-pub struct TowerCompat<S> {
-    inner: S,
-}
-
-impl<S> TowerCompat<S> {
-    /// Wraps an `actix_service::Service` in a compatibility wrapper.
-    pub fn new(inner: S) -> Self {
-        TowerCompat { inner }
-    }
-}
-
-/// Extension trait for wrapping an `actix_service::Service` instance for use as
-/// a `tower_service::Service`.
-pub trait ActixServiceExt: ActixService + Sized {
-    /// Wraps a `tower_service::Service` in a compatibility wrapper.
-    ///
-    /// ```
-    /// use actix_tower::ActixServiceExt;
-    /// # use futures::{Async, Future};
-    /// use tower_service::Service;
-    ///
-    /// struct RandomService;
-    /// impl actix_service::Service for RandomService {
-    ///     // …
-    /// #    type Request = ();
-    /// #    type Response = u32;
-    /// #    type Error = ();
-    /// #    type Future = futures::future::FutureResult<Self::Response, Self::Error>;
-    /// #
-    /// #    fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
-    /// #        Ok(Async::Ready(()))
-    /// #    }
-    /// #
-    /// #    fn call(&mut self, _req: Self::Request) -> Self::Future {
-    /// #        futures::finished(4)
-    /// #     }
-    /// }
-    ///
-    /// let mut s = RandomService.into_tower_service();
-    /// assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-    /// assert_eq!(Ok(Async::Ready(4)), s.call(()).poll());
-    /// ```
-    fn into_tower_service(self) -> TowerCompat<Self> {
-        TowerCompat::new(self)
-    }
-
-    /// Takes a function that, when provided with a `tower_service::Service` wraps it
-    /// and returns a new service. Useful for wrapping an `actix_service::Service` with
-    /// middleware built for `tower_service`.
-    ///
-    /// ```
-    /// use actix_tower::ActixServiceExt;
-    /// # use futures::{Async, Future};
-    /// use actix_service::Service;
-    ///
-    /// struct RandomService;
-    /// impl Service for RandomService {
-    ///     // …
-    /// #    type Request = ();
-    /// #    type Response = u32;
-    /// #    type Error = ();
-    /// #    type Future = futures::future::FutureResult<Self::Response, Self::Error>;
-    /// #
-    /// #    fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
-    /// #        Ok(Async::Ready(()))
-    /// #    }
-    /// #
-    /// #    fn call(&mut self, _req: Self::Request) -> Self::Future {
-    /// #        futures::finished(4)
-    /// #     }
-    /// }
-    ///
-    /// struct AddOneMiddleware<S>(S);
-    /// impl<S, R> tower_service::Service<R> for AddOneMiddleware<S>
-    /// where
-    ///     S: tower_service::Service<R, Response = u32>,
-    ///     S::Future: 'static,
-    /// {
-    ///     /// …
-    /// #    type Response = u32;
-    /// #    type Error = S::Error;
-    /// #    type Future = Box<dyn Future<Item = Self::Response, Error = Self::Error>>;
-    /// #
-    /// #    fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
-    /// #        self.0.poll_ready()
-    /// #    }
-    /// #
-    /// #    fn call(&mut self, req: R) -> Self::Future {
-    /// #        let fut = self.0.call(req).map(|x| x + 1);
-    /// #        Box::new(fut)
-    /// #    }
-    /// }
-    ///
-    /// let mut s = RandomService.wrap_with_tower_middleware(AddOneMiddleware);
-    /// assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-    /// assert_eq!(Ok(Async::Ready(5)), s.call(()).poll());
-    /// ```
-    fn wrap_with_tower_middleware<F, U>(self, f: F) -> ActixCompat<U, Self::Request>
-    where
-        F: FnOnce(TowerCompat<Self>) -> U,
-        U: TowerService<Self::Request>,
-    {
-        f(self.into_tower_service()).into_actix_service()
-    }
-}
-
-impl<S> ActixServiceExt for S where S: ActixService + Sized {}
-
-impl<S> TowerService<S::Request> for TowerCompat<S>
-where
-    S: ActixService,
-{
-    type Response = S::Response;
-    type Error = S::Error;
-    type Future = S::Future;
-
-    fn poll_ready(&mut self) -> futures::Poll<(), Self::Error> {
-        ActixService::poll_ready(&mut self.inner)
-    }
-
-    fn call(&mut self, req: S::Request) -> Self::Future {
-        ActixService::call(&mut self.inner, req)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    mod tower_service_into_actix_service {
-        use crate::TowerServiceExt;
-        use actix_service::{Service as ActixService, ServiceExt, Transform};
-        use futures::{future::FutureResult, Async, Future, Poll};
-        use tower_service::Service as TowerService;
-
-        #[test]
-        fn random_service_returns_4() {
-            let mut s = RandomService.into_actix_service();
-
-            assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-
-            assert_eq!(Ok(Async::Ready(4)), s.call(()).poll());
-        }
-
-        #[test]
-        fn random_service_can_combine() {
-            let mut s = RandomService.into_actix_service().map(|x| x + 1);
-
-            assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-
-            assert_eq!(Ok(Async::Ready(5)), s.call(()).poll());
-        }
-
-        #[test]
-        fn random_service_can_use_actix_middleware() {
-            let mut s = RandomService.wrap_with_actix_middleware(DoMathTransform);
-
-            assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-
-            assert_eq!(Ok(Async::Ready(68)), s.call(()).poll());
-        }
-
-        #[test]
-        fn random_service_and_add_service_chained() {
-            let s1 = RandomService.into_actix_service();
-            let s2 = AddOneService.into_actix_service();
-            let s3 = AddOneService.into_actix_service();
-
-            let mut s = s1.and_then(s2).and_then(s3);
-
-            assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-
-            assert_eq!(Ok(Async::Ready(6)), s.call(()).poll());
-        }
-
-        #[test]
-        fn random_service_and_add_service_and_ignoring_service_chained() {
-            let s1 = RandomService.into_actix_service();
-            let s2 = AddOneService.into_actix_service();
-            let s3 = AddOneService.into_actix_service();
-            let s4 = RandomService.into_actix_service();
-
-            let mut s = s1.and_then(s2).and_then(s3).and_then(s4);
-
-            assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-
-            assert_eq!(Ok(Async::Ready(4)), s.call(()).poll());
-        }
-
-        #[test]
-        fn random_service_can_be_transformed_to_do_math() {
-            let transform = DoMath;
-
-            let mut s = transform
-                .new_transform(RandomService.into_actix_service())
-                .wait()
-                .unwrap();
-
-            assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-
-            assert_eq!(Ok(Async::Ready(68)), s.call(()).poll());
-        }
-
-        struct RandomService;
-        impl<R> TowerService<R> for RandomService {
-            type Response = u32;
-            type Error = ();
-            type Future = FutureResult<Self::Response, Self::Error>;
-
-            fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-                Ok(Async::Ready(()))
-            }
-
-            fn call(&mut self, _req: R) -> Self::Future {
-                futures::finished(4)
-            }
-        }
-
-        struct AddOneService;
-        impl TowerService<u32> for AddOneService {
-            type Response = u32;
-            type Error = ();
-            type Future = FutureResult<Self::Response, Self::Error>;
-
-            fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-                Ok(Async::Ready(()))
-            }
-
-            fn call(&mut self, req: u32) -> Self::Future {
-                futures::finished(req + 1)
-            }
-        }
-
-        struct DoMathTransform<S>(S);
-        impl<S> ActixService for DoMathTransform<S>
-        where
-            S: ActixService<Response = u32>,
-            S::Future: 'static,
-        {
-            type Request = S::Request;
-            type Response = u32;
-            type Error = S::Error;
-            type Future = Box<dyn Future<Item = Self::Response, Error = Self::Error>>;
-
-            fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-                self.0.poll_ready()
-            }
-
-            fn call(&mut self, req: Self::Request) -> Self::Future {
-                let fut = self.0.call(req).map(|x| x * 17);
-                Box::new(fut)
-            }
-        }
-
-        struct DoMath;
-        impl<S> Transform<S> for DoMath
-        where
-            S: ActixService<Response = u32>,
-            S::Future: 'static,
-        {
-            type Request = S::Request;
-            type Response = u32;
-            type Error = S::Error;
-            type Transform = DoMathTransform<S>;
-            type InitError = ();
-            type Future = FutureResult<Self::Transform, Self::InitError>;
-
-            fn new_transform(&self, service: S) -> Self::Future {
-                futures::finished(DoMathTransform(service))
-            }
-        }
-    }
-
-    mod actix_service_into_tower_service {
-        use crate::{ActixServiceExt, TowerServiceExt};
-        use actix_service::{Service as ActixService, ServiceExt};
-        use futures::{future::FutureResult, Async, Future, Poll};
-        use tower_service::Service as TowerService;
-
-        #[test]
-        fn random_service_returns_4() {
-            let mut s = RandomService.into_tower_service();
-
-            assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-
-            assert_eq!(Ok(Async::Ready(4)), s.call(()).poll());
-        }
-
-        #[test]
-        fn random_service_can_use_tower_middleware() {
-            let mut s =
-                AddOneService::wrap(RandomService.into_tower_service()).into_actix_service();
-
-            assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-
-            assert_eq!(Ok(Async::Ready(5)), s.call(()).poll());
-        }
-
-        #[test]
-        fn do_math_service_can_use_tower_middleware() {
-            let mut s =
-                AddOneService::wrap(DoMathService.into_tower_service()).into_actix_service();
-
-            assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-
-            assert_eq!(Ok(Async::Ready(188)), s.call(11).poll());
-        }
-
-        #[test]
-        fn random_service_and_add_service_and_ignoring_service_chained() {
-            let s1 = RandomService.wrap_with_tower_middleware(AddOneService::wrap);
-            let s2 = DoMathService.wrap_with_tower_middleware(AddOneService::wrap);
-
-            let mut s = s1.and_then(s2);
-
-            assert_eq!(Ok(Async::Ready(())), s.poll_ready());
-
-            assert_eq!(Ok(Async::Ready(86)), s.call(()).poll());
-        }
-
-        struct RandomService;
-        impl ActixService for RandomService {
-            type Request = ();
-            type Response = u32;
-            type Error = ();
-            type Future = FutureResult<Self::Response, Self::Error>;
-
-            fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-                Ok(Async::Ready(()))
-            }
-
-            fn call(&mut self, _req: Self::Request) -> Self::Future {
-                futures::finished(4)
-            }
-        }
-
-        struct AddOneService<S> {
-            inner: S,
-        }
-
-        impl<S> AddOneService<S> {
-            fn wrap(inner: S) -> Self {
-                AddOneService { inner }
-            }
-        }
-
-        impl<S, R> TowerService<R> for AddOneService<S>
-        where
-            S: TowerService<R, Response = u32>,
-            S::Future: 'static,
-        {
-            type Response = u32;
-            type Error = S::Error;
-            type Future = Box<dyn Future<Item = Self::Response, Error = Self::Error>>;
-
-            fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-                self.inner.poll_ready()
-            }
-
-            fn call(&mut self, req: R) -> Self::Future {
-                let fut = self.inner.call(req).map(|x| x + 1);
-
-                Box::new(fut)
-            }
-        }
-
-        struct DoMathService;
-        impl ActixService for DoMathService {
-            type Request = u32;
-            type Response = u32;
-            type Error = ();
-            type Future = FutureResult<Self::Response, Self::Error>;
-
-            fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-                Ok(Async::Ready(()))
-            }
-
-            fn call(&mut self, req: Self::Request) -> Self::Future {
-                futures::finished(req * 17)
-            }
-        }
-    }
-}

actix-utils/CHANGES.md

@@ -1,160 +0,0 @@
-# Changes
-
-## [0.4.5] - 2019-07-19
-
-### Removed
-
-* Deprecated `CloneableService` as it is not safe
-
-
-## [0.4.4] - 2019-07-17
-
-### Changed
-
-* Undeprecate `FramedTransport` as it is actually useful
-
-
-## [0.4.3] - 2019-07-17
-
-### Deprecated
-
-* Deprecate `CloneableService` as it is not safe and in general not very useful
-
-* Deprecate `FramedTransport` in favor of `actix-ioframe`
-
-
-## [0.4.2] - 2019-06-26
-
-### Fixed
-
-* Do not block on sink drop for FramedTransport
-
-
-## [0.4.1] - 2019-05-15
-
-### Changed
-
-* Change `Either` constructor
-
-
-## [0.4.0] - 2019-05-11
-
-### Changed
-
-* Change `Either` to handle two nexted services
-
-* Upgrade actix-service 0.4
-
-### Deleted
-
-* Framed related services
-
-* Stream related services
-
-## [0.3.5] - 2019-04-04
-
-### Added
-
-* Allow to send messages to `FramedTransport` via mpsc channel.
-
-### Changed
-
-* Remove 'static constraint from Clonable service
-
-
-## [0.3.4] - 2019-03-12
-
-### Changed
-
-* `TimeoutService`, `InOrderService`, `InFlightService` accepts generic IntoService services.
-
-### Fixed
-
-* Fix `InFlightService::poll_ready()` nested service readiness check
-
-* Fix `InOrderService::poll_ready()` nested service readiness check
-
-
-## [0.3.3] - 2019-03-09
-
-### Changed
-
-* Revert IntoFuture change
-
-* Add generic config param for IntoFramed and TakeOne new services
-
-
-## [0.3.2] - 2019-03-04
-
-### Changed
-
-* Use IntoFuture for new services
-
-
-## [0.3.1] - 2019-03-04
-
-### Changed
-
-* Use new type of transform trait
-
-
-## [0.3.0] - 2019-03-02
-
-### Changed
-
-* Use new `NewService` trait
-
-* BoxedNewService` and `BoxedService` types moved to actix-service crate.
-
-
-## [0.2.4] - 2019-02-21
-
-### Changed
-
-* Custom `BoxedNewService` implementation.
-
-
-## [0.2.3] - 2019-02-21
-
-### Added
-
-* Add `BoxedNewService` and `BoxedService`
-
-
-## [0.2.2] - 2019-02-11
-
-### Added
-
-* Add `Display` impl for `TimeoutError`
-
-* Add `Display` impl for `InOrderError`
-
-
-## [0.2.1] - 2019-02-06
-
-### Added
-
-* Add `InOrder` service. the service yields responses as they become available,
-  in the order that their originating requests were submitted to the service.
-
-### Changed
-
-* Convert `Timeout` and `InFlight` services to a transforms
-
-
-## [0.2.0] - 2019-02-01
-
-* Fix framed transport error handling
-
-* Added Clone impl for Either service
-
-* Added Clone impl for Timeout service factory
-
-* Added Service and NewService for Stream dispatcher
-
-* Switch to actix-service 0.2
-
-
-## [0.1.0] - 2018-12-09
-
-* Move utils services to separate crate

actix-utils/Cargo.toml

@@ -1,31 +0,0 @@
-[package]
-name = "actix-utils"
-version = "0.4.5"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix utils - various actix net related services"
-keywords = ["network", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-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 = "0.4.1"
-actix-codec = "0.1.2"
-bytes = "0.4"
-either = "1.5.2"
-futures = "0.1.25"
-tokio-timer = "0.2.8"
-tokio-current-thread = "0.1.4"
-log = "0.4"
-
-[dev-dependencies]
-actix-rt = "0.2.2"

actix-utils/LICENSE-APACHE

@@ -1 +0,0 @@
-../LICENSE-APACHE

actix-utils/LICENSE-MIT

@@ -1 +0,0 @@
-../LICENSE-MIT

actix-utils/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 fn get_ref(&self) -> &T {
-        unsafe { &*self.inner.as_ref().get() }
-    }
-
-    pub fn get_mut(&mut self) -> &mut T {
-        unsafe { &mut *self.inner.as_ref().get() }
-    }
-}

actix-utils/src/counter.rs

@@ -1,78 +0,0 @@
-use std::cell::Cell;
-use std::rc::Rc;
-
-use futures::task::AtomicTask;
-
-#[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>);
-
-struct CounterInner {
-    count: Cell<usize>,
-    capacity: usize,
-    task: AtomicTask,
-}
-
-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: AtomicTask::new(),
-        }))
-    }
-
-    pub fn get(&self) -> CounterGuard {
-        CounterGuard::new(self.0.clone())
-    }
-
-    /// Check if counter is not at capacity
-    pub fn available(&self) -> bool {
-        self.0.available()
-    }
-
-    /// Get total number of acquired counts
-    pub fn total(&self) -> usize {
-        self.0.count.get()
-    }
-}
-
-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) {
-        let num = self.count.get() + 1;
-        self.count.set(num);
-        if num == self.capacity {
-            self.task.register();
-        }
-    }
-
-    fn dec(&self) {
-        let num = self.count.get();
-        self.count.set(num - 1);
-        if num == self.capacity {
-            self.task.notify();
-        }
-    }
-
-    fn available(&self) -> bool {
-        self.count.get() < self.capacity
-    }
-}