1
0
mirror of https://github.com/fafhrd91/actix-web synced 2025-07-09 12:26:16 +02:00

Compare commits

...

30 Commits

Author SHA1 Message Date
d38eb00793 no readme 2018-12-11 08:36:03 -08:00
3c9d95bd9f no readme 2018-12-11 08:33:28 -08:00
331db2eb47 use released version 2018-12-11 08:28:44 -08:00
de66b5c776 fix examples 2018-12-11 08:20:19 -08:00
4adbbad450 update travis config 2018-12-11 08:13:58 -08:00
42ec3454d9 add signals support 2018-12-10 21:06:54 -08:00
e6daca7995 try to parse host first 2018-12-10 18:08:07 -08:00
d35c87d228 move helper services to separate package 2018-12-10 16:16:40 -08:00
ba006d95c7 prepare actix-utils 2018-12-10 08:42:31 -08:00
9577b7bbed add helper fn 2018-12-09 22:19:26 -08:00
8ad93f4838 move server to separate crate 2018-12-09 22:14:29 -08:00
ffb07c8884 use actix-rt for server impl 2018-12-09 21:51:35 -08:00
cdd6904aa0 rename Server to ServerBuilder 2018-12-09 20:30:14 -08:00
98a151db4f add actix single threaded runtime 2018-12-09 19:55:40 -08:00
227ea15683 remove unused code 2018-12-09 15:21:23 -08:00
e50be58fdb move codec to separate crate 2018-12-09 15:19:25 -08:00
3288b7648d update changes 2018-12-09 10:16:35 -08:00
43e14818c4 migrate to actix-service crate 2018-12-09 10:15:49 -08:00
a60bf691d5 add Service impl for Box<S> 2018-12-09 10:14:08 -08:00
5f37d85f9b move service to separate crate 2018-12-09 09:56:23 -08:00
e8aa73a44b update tests 2018-12-06 14:53:55 -08:00
8fe7ce533c convert to edition 2018 2018-12-06 14:04:42 -08:00
42a4679635 use FnMut for apply combinator 2018-12-05 17:43:31 -08:00
36a15efeac do not export cell 2018-12-03 17:46:25 -08:00
5937a06ebe export cell 2018-12-03 13:49:46 -08:00
a16ad6b2cd cleanup clonable service 2018-11-30 11:55:30 -08:00
8108f19580 update tests 2018-11-29 17:17:02 -10:00
1b1ae01b5a migrate to new Service<Request> trait 2018-11-29 16:56:15 -10:00
c62567f85f allow to skip name resolution 2018-11-21 08:07:04 -10:00
410204a41e Framed::is_write_buf_empty() checks if write buffer is flushed 2018-11-17 18:46:26 -08:00
74 changed files with 2858 additions and 1719 deletions

View File

@ -16,7 +16,7 @@ matrix:
env: env:
global: global:
# - RUSTFLAGS="-C link-dead-code" - RUSTFLAGS="-C link-dead-code"
- OPENSSL_VERSION=openssl-1.0.2 - OPENSSL_VERSION=openssl-1.0.2
before_install: before_install:
@ -33,6 +33,12 @@ script:
if [[ "$TRAVIS_RUST_VERSION" != "nightly" ]]; then if [[ "$TRAVIS_RUST_VERSION" != "nightly" ]]; then
cargo clean cargo clean
cargo test --features="ssl,tls,rust-tls" -- --nocapture cargo test --features="ssl,tls,rust-tls" -- --nocapture
cd actix-codec && cargo test && cd ..
cd actix-service && cargo test && cd ..
cd actix-server && cargo test --features="ssl,tls,rust-tls" -- --nocapture && cd ..
cd actix-rt && cargo test && cd ..
cd actix-connector && cargo test && cd ..
cd actix-utils && cargo test && cd ..
fi fi
- | - |
if [[ "$TRAVIS_RUST_VERSION" == "nightly" ]]; then if [[ "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
@ -40,15 +46,10 @@ script:
cargo tarpaulin --features="ssl,tls,rust-tls" --out Xml cargo tarpaulin --features="ssl,tls,rust-tls" --out Xml
bash <(curl -s https://codecov.io/bash) bash <(curl -s https://codecov.io/bash)
echo "Uploaded code coverage" echo "Uploaded code coverage"
fi cd actix-service && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
cd actix-rt && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
# Upload docs cd actix-connector && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
after_success: cd actix-codec && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
- | cd actix-server && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "beta" ]]; then cd actix-utils && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash) && cd ..
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 fi

View File

@ -1,5 +1,25 @@
# Changes # Changes
## [0.3.0] - xxx
* Split `Service` trait to separate crate
* Use new `Service<Request>` trait
## [0.2.4] - 2018-11-21
### Added
* Allow to skip name resolution stage in Connector
## [0.2.3] - 2018-11-17
### Added
* Framed::is_write_buf_empty() checks if write buffer is flushed
## [0.2.2] - 2018-11-14 ## [0.2.2] - 2018-11-14
### Added ### Added

View File

@ -1,6 +1,6 @@
[package] [package]
name = "actix-net" name = "actix-net"
version = "0.2.2" version = "0.3.0"
authors = ["Nikolay Kim <fafhrd91@gmail.com>"] authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
description = "Actix net - framework for the compisible network services for Rust (experimental)" description = "Actix net - framework for the compisible network services for Rust (experimental)"
readme = "README.md" readme = "README.md"
@ -11,73 +11,24 @@ documentation = "https://docs.rs/actix-net/"
categories = ["network-programming", "asynchronous"] categories = ["network-programming", "asynchronous"]
license = "MIT/Apache-2.0" license = "MIT/Apache-2.0"
exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"] exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
edition = "2018"
[package.metadata.docs.rs] [workspace]
features = ["ssl", "tls", "rust-tls"] members = [
"actix-codec",
[badges] "actix-connector",
travis-ci = { repository = "actix/actix-net", branch = "master" } "actix-service",
# appveyor = { repository = "fafhrd91/actix-web-hdy9d" } "actix-server",
codecov = { repository = "actix/actix-net", branch = "master", service = "github" } "actix-rt",
"actix-utils",
[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-proto = "^0.5.0"
trust-dns-resolver = "^0.10.0"
# 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] [dev-dependencies]
actix-service = "0.1.1"
actix-codec = "0.1.0"
actix-rt = { path="actix-rt" }
actix-server = { path="actix-server", features=["ssl"] }
env_logger = "0.5" env_logger = "0.5"
futures = "0.1.24"
[profile.release] openssl = { version="0.10" }
lto = true tokio-openssl = { version="0.3" }
opt-level = 3
codegen-units = 1

View File

@ -13,7 +13,7 @@ Actix net - framework for composable network services (experimental)
```rust ```rust
fn main() { fn main() {
let sys = actix::System::new("test"); let sys = actix_rt::System::new("test");
// load ssl keys // load ssl keys
let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap(); let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
@ -26,7 +26,7 @@ fn main() {
// bind socket address and start workers. By default server uses number of // bind socket address and start workers. By default server uses number of
// available logical cpu as threads count. actix net start separate // available logical cpu as threads count. actix net start separate
// instances of service pipeline in each worker. // instances of service pipeline in each worker.
Server::default() actix_server::build()
.bind( .bind(
// configure service pipeline // configure service pipeline
"basic", "0.0.0.0:8443", "basic", "0.0.0.0:8443",

5
actix-codec/CHANGES.md Normal file
View File

@ -0,0 +1,5 @@
# Changes
## [0.1.0] - 2018-12-09
* Move codec to separate crate

25
actix-codec/Cargo.toml Normal file
View File

@ -0,0 +1,25 @@
[package]
name = "actix-codec"
version = "0.1.0"
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"
futures = "0.1.24"
tokio-io = "0.1"
tokio-codec = "0.1"
log = "0.4"

View File

@ -135,6 +135,11 @@ impl<T, U> Framed<T, U> {
&mut self.inner.get_mut().get_mut().0 &mut self.inner.get_mut().get_mut().0
} }
/// Check if write buffer is empty.
pub fn is_write_buf_empty(&self) -> bool {
self.inner.get_ref().is_empty()
}
/// Check if write buffer is full. /// Check if write buffer is full.
pub fn is_write_buf_full(&self) -> bool { pub fn is_write_buf_full(&self) -> bool {
self.inner.get_ref().is_full() self.inner.get_ref().is_full()

View File

@ -1,7 +1,8 @@
use std::fmt; use std::fmt;
use bytes::BytesMut; use bytes::BytesMut;
use futures::{Async, Poll, Sink, StartSend, Stream}; use futures::{try_ready, Async, Poll, Sink, StartSend, Stream};
use log::trace;
use tokio_codec::Decoder; use tokio_codec::Decoder;
use tokio_io::AsyncRead; use tokio_io::AsyncRead;
@ -133,7 +134,7 @@ where
pub fn framed_read2<T>(inner: T) -> FramedRead2<T> { pub fn framed_read2<T>(inner: T) -> FramedRead2<T> {
FramedRead2 { FramedRead2 {
inner: inner, inner,
eof: false, eof: false,
is_readable: false, is_readable: false,
buffer: BytesMut::with_capacity(INITIAL_CAPACITY), buffer: BytesMut::with_capacity(INITIAL_CAPACITY),
@ -146,9 +147,9 @@ pub fn framed_read2_with_buffer<T>(inner: T, mut buf: BytesMut) -> FramedRead2<T
buf.reserve(bytes_to_reserve); buf.reserve(bytes_to_reserve);
} }
FramedRead2 { FramedRead2 {
inner: inner, inner,
eof: false, eof: false,
is_readable: buf.len() > 0, is_readable: !buf.is_empty(),
buffer: buf, buffer: buf,
} }
} }
@ -187,13 +188,13 @@ where
// readable again, at which point the stream is terminated. // readable again, at which point the stream is terminated.
if self.is_readable { if self.is_readable {
if self.eof { if self.eof {
let frame = try!(self.inner.decode_eof(&mut self.buffer)); let frame = self.inner.decode_eof(&mut self.buffer)?;
return Ok(Async::Ready(frame)); return Ok(Async::Ready(frame));
} }
trace!("attempting to decode a frame"); trace!("attempting to decode a frame");
if let Some(frame) = try!(self.inner.decode(&mut self.buffer)) { if let Some(frame) = self.inner.decode(&mut self.buffer)? {
trace!("frame decoded from buffer"); trace!("frame decoded from buffer");
return Ok(Async::Ready(Some(frame))); return Ok(Async::Ready(Some(frame)));
} }

View File

@ -2,7 +2,8 @@ use std::fmt;
use std::io::{self, Read}; use std::io::{self, Read};
use bytes::BytesMut; use bytes::BytesMut;
use futures::{Async, AsyncSink, Poll, Sink, StartSend, Stream}; use futures::{try_ready, Async, AsyncSink, Poll, Sink, StartSend, Stream};
use log::trace;
use tokio_codec::{Decoder, Encoder}; use tokio_codec::{Decoder, Encoder};
use tokio_io::{AsyncRead, AsyncWrite}; use tokio_io::{AsyncRead, AsyncWrite};
@ -77,6 +78,11 @@ impl<T, E> FramedWrite<T, E> {
pub fn is_full(&self) -> bool { pub fn is_full(&self) -> bool {
self.inner.is_full() self.inner.is_full()
} }
/// Check if write buffer is empty.
pub fn is_empty(&self) -> bool {
self.inner.is_empty()
}
} }
impl<T, E> FramedWrite<T, E> impl<T, E> FramedWrite<T, E>
@ -106,7 +112,7 @@ where
} }
fn close(&mut self) -> Poll<(), Self::SinkError> { fn close(&mut self) -> Poll<(), Self::SinkError> {
Ok(try!(self.inner.close())) Ok(self.inner.close()?)
} }
} }
@ -194,6 +200,10 @@ impl<T> FramedWrite2<T> {
pub fn is_full(&self) -> bool { pub fn is_full(&self) -> bool {
self.buffer.len() >= self.high_watermark self.buffer.len() >= self.high_watermark
} }
pub fn is_empty(&self) -> bool {
self.buffer.is_empty()
}
} }
impl<T> FramedWrite2<T> impl<T> FramedWrite2<T>
@ -245,7 +255,8 @@ where
io::ErrorKind::WriteZero, io::ErrorKind::WriteZero,
"failed to \ "failed to \
write frame to transport", write frame to transport",
).into()); )
.into());
} }
// TODO: Add a way to `bytes` to do this w/o returning the drained // TODO: Add a way to `bytes` to do this w/o returning the drained
@ -257,12 +268,12 @@ where
try_ready!(self.inner.poll_flush()); try_ready!(self.inner.poll_flush());
trace!("framed transport flushed"); trace!("framed transport flushed");
return Ok(Async::Ready(())); Ok(Async::Ready(()))
} }
fn close(&mut self) -> Poll<(), Self::SinkError> { fn close(&mut self) -> Poll<(), Self::SinkError> {
try_ready!(self.poll_complete()); try_ready!(self.poll_complete());
Ok(try!(self.inner.shutdown())) Ok(self.inner.shutdown()?)
} }
} }

View File

@ -10,16 +10,15 @@
//! [`Stream`]: # //! [`Stream`]: #
//! [transports]: # //! [transports]: #
#![deny(missing_docs, missing_debug_implementations, warnings)]
mod bcodec; mod bcodec;
mod framed; mod framed;
// mod framed2;
mod framed_read; mod framed_read;
mod framed_write; mod framed_write;
pub use self::bcodec::BytesCodec; pub use self::bcodec::BytesCodec;
pub use self::framed::{Framed, FramedParts}; pub use self::framed::{Framed, FramedParts};
// pub use self::framed2::{Framed2, FramedParts2};
pub use self::framed_read::FramedRead; pub use self::framed_read::FramedRead;
pub use self::framed_write::FramedWrite; pub use self::framed_write::FramedWrite;
pub use tokio_codec::{Decoder, Encoder};
pub use tokio_io::{AsyncRead, AsyncWrite};

View File

@ -0,0 +1,5 @@
# Changes
## [0.1.0] - 2018-12-09
* Move server to separate crate

View File

@ -0,0 +1,40 @@
[package]
name = "actix-connector"
version = "0.1.0"
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-net/"
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"]
[lib]
name = "actix_connector"
path = "src/lib.rs"
[features]
default = []
# openssl
ssl = ["openssl", "tokio-openssl"]
[dependencies]
actix-service = "0.1.1"
actix-codec = "0.1.0"
actix-rt = "0.1.0"
futures = "0.1"
tokio-tcp = "0.1"
trust-dns-proto = "^0.5.0"
trust-dns-resolver = "^0.10.0"
# openssl
openssl = { version="0.10", optional = true }
tokio-openssl = { version="0.3", optional = true }

View File

@ -4,16 +4,14 @@ use std::net::{IpAddr, SocketAddr};
use std::time::Duration; use std::time::Duration;
use std::{fmt, io}; use std::{fmt, io};
use futures::{ use actix_service::{NewService, Service};
future::{ok, FutureResult}, use futures::future::{ok, Either, FutureResult};
Async, Future, Poll, use futures::{try_ready, Async, Future, Poll};
};
use tokio_tcp::{ConnectFuture, TcpStream}; use tokio_tcp::{ConnectFuture, TcpStream};
use trust_dns_resolver::config::{ResolverConfig, ResolverOpts}; use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
use trust_dns_resolver::system_conf::read_system_conf; use trust_dns_resolver::system_conf::read_system_conf;
use super::resolver::{RequestHost, ResolveError, Resolver, ResolverFuture}; use super::resolver::{RequestHost, ResolveError, Resolver, ResolverFuture};
use super::service::{NewService, Service};
/// Port of the request /// Port of the request
pub trait RequestPort { pub trait RequestPort {
@ -58,17 +56,24 @@ impl From<io::Error> for ConnectorError {
/// Connect request /// Connect request
#[derive(Eq, PartialEq, Debug, Hash)] #[derive(Eq, PartialEq, Debug, Hash)]
pub struct Connect { pub struct Connect {
pub host: String, pub kind: ConnectKind,
pub port: u16,
pub timeout: Duration, pub timeout: Duration,
} }
#[derive(Eq, PartialEq, Debug, Hash)]
pub enum ConnectKind {
Host { host: String, port: u16 },
Addr { host: String, addr: SocketAddr },
}
impl Connect { impl Connect {
/// Create new `Connect` instance. /// Create new `Connect` instance.
pub fn new<T: AsRef<str>>(host: T, port: u16) -> Connect { pub fn new<T: AsRef<str>>(host: T, port: u16) -> Connect {
Connect { Connect {
port, kind: ConnectKind::Host {
host: host.as_ref().to_owned(), host: host.as_ref().to_owned(),
port,
},
timeout: Duration::from_secs(1), timeout: Duration::from_secs(1),
} }
} }
@ -82,12 +87,25 @@ impl Connect {
.parse::<u16>() .parse::<u16>()
.map_err(|_| ConnectorError::InvalidInput)?; .map_err(|_| ConnectorError::InvalidInput)?;
Ok(Connect { Ok(Connect {
port, kind: ConnectKind::Host {
host: host.to_owned(), host: host.to_owned(),
port,
},
timeout: Duration::from_secs(1), timeout: Duration::from_secs(1),
}) })
} }
/// Create new `Connect` instance from host and address. Connector skips name resolution stage for such connect messages.
pub fn with_address<T: Into<String>>(host: T, addr: SocketAddr) -> Connect {
Connect {
kind: ConnectKind::Addr {
addr,
host: host.into(),
},
timeout: Duration::from_secs(1),
}
}
/// Set connect timeout /// Set connect timeout
/// ///
/// By default timeout is set to a 1 second. /// By default timeout is set to a 1 second.
@ -99,19 +117,25 @@ impl Connect {
impl RequestHost for Connect { impl RequestHost for Connect {
fn host(&self) -> &str { fn host(&self) -> &str {
&self.host match self.kind {
ConnectKind::Host { ref host, .. } => host,
ConnectKind::Addr { ref host, .. } => host,
}
} }
} }
impl RequestPort for Connect { impl RequestPort for Connect {
fn port(&self) -> u16 { fn port(&self) -> u16 {
self.port match self.kind {
ConnectKind::Host { port, .. } => port,
ConnectKind::Addr { addr, .. } => addr.port(),
}
} }
} }
impl fmt::Display for Connect { impl fmt::Display for Connect {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}:{}", self.host, self.port) write!(f, "{}:{}", self.host(), self.port())
} }
} }
@ -143,8 +167,8 @@ impl Connector {
/// Create new connector with custom resolver /// Create new connector with custom resolver
pub fn with_resolver( pub fn with_resolver(
resolver: Resolver<Connect>, resolver: Resolver<Connect>,
) -> impl Service<Request = Connect, Response = (Connect, TcpStream), Error = ConnectorError> ) -> impl Service<Connect, Response = (Connect, TcpStream), Error = ConnectorError> + Clone
+ Clone { {
Connector { resolver } Connector { resolver }
} }
@ -153,7 +177,7 @@ impl Connector {
cfg: ResolverConfig, cfg: ResolverConfig,
opts: ResolverOpts, opts: ResolverOpts,
) -> impl NewService< ) -> impl NewService<
Request = Connect, Connect,
Response = (Connect, TcpStream), Response = (Connect, TcpStream),
Error = ConnectorError, Error = ConnectorError,
InitError = E, InitError = E,
@ -170,20 +194,28 @@ impl Clone for Connector {
} }
} }
impl Service for Connector { impl Service<Connect> for Connector {
type Request = Connect;
type Response = (Connect, TcpStream); type Response = (Connect, TcpStream);
type Error = ConnectorError; type Error = ConnectorError;
type Future = ConnectorFuture; type Future = Either<ConnectorFuture, ConnectorTcpFuture>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> { fn poll_ready(&mut self) -> Poll<(), Self::Error> {
Ok(Async::Ready(())) Ok(Async::Ready(()))
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: Connect) -> Self::Future {
ConnectorFuture { match req.kind {
fut: self.resolver.call(req), ConnectKind::Host { .. } => Either::A(ConnectorFuture {
fut2: None, fut: self.resolver.call(req),
fut2: None,
}),
ConnectKind::Addr { addr, .. } => {
let mut addrs = VecDeque::new();
addrs.push_back(addr.ip());
Either::B(ConnectorTcpFuture {
fut: TcpConnectorResponse::new(req, addrs),
})
}
} }
} }
} }
@ -216,6 +248,20 @@ impl Future for ConnectorFuture {
} }
} }
#[doc(hidden)]
pub struct ConnectorTcpFuture {
fut: TcpConnectorResponse<Connect>,
}
impl Future for ConnectorTcpFuture {
type Item = (Connect, TcpStream);
type Error = ConnectorError;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
self.fut.poll().map_err(ConnectorError::IoError)
}
}
/// Tcp stream connector service /// Tcp stream connector service
pub struct TcpConnector<T: RequestPort>(PhantomData<T>); pub struct TcpConnector<T: RequestPort>(PhantomData<T>);
@ -225,8 +271,7 @@ impl<T: RequestPort> Default for TcpConnector<T> {
} }
} }
impl<T: RequestPort> Service for TcpConnector<T> { impl<T: RequestPort> Service<(T, VecDeque<IpAddr>)> for TcpConnector<T> {
type Request = (T, VecDeque<IpAddr>);
type Response = (T, TcpStream); type Response = (T, TcpStream);
type Error = io::Error; type Error = io::Error;
type Future = TcpConnectorResponse<T>; type Future = TcpConnectorResponse<T>;
@ -235,7 +280,7 @@ impl<T: RequestPort> Service for TcpConnector<T> {
Ok(Async::Ready(())) Ok(Async::Ready(()))
} }
fn call(&mut self, (req, addrs): Self::Request) -> Self::Future { fn call(&mut self, (req, addrs): (T, VecDeque<IpAddr>)) -> Self::Future {
TcpConnectorResponse::new(req, addrs) TcpConnectorResponse::new(req, addrs)
} }
} }
@ -306,8 +351,7 @@ impl DefaultConnector {
} }
} }
impl Service for DefaultConnector { impl Service<Connect> for DefaultConnector {
type Request = Connect;
type Response = TcpStream; type Response = TcpStream;
type Error = ConnectorError; type Error = ConnectorError;
type Future = DefaultConnectorFuture; type Future = DefaultConnectorFuture;
@ -316,7 +360,7 @@ impl Service for DefaultConnector {
self.0.poll_ready() self.0.poll_ready()
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: Connect) -> Self::Future {
DefaultConnectorFuture { DefaultConnectorFuture {
fut: self.0.call(req), fut: self.0.call(req),
} }
@ -325,7 +369,7 @@ impl Service for DefaultConnector {
#[doc(hidden)] #[doc(hidden)]
pub struct DefaultConnectorFuture { pub struct DefaultConnectorFuture {
fut: ConnectorFuture, fut: Either<ConnectorFuture, ConnectorTcpFuture>,
} }
impl Future for DefaultConnectorFuture { impl Future for DefaultConnectorFuture {

View File

@ -0,0 +1,16 @@
//! Actix Connector - tcp connector service
//!
//! ## Package feature
//!
//! * `tls` - enables ssl support via `native-tls` crate
//! * `ssl` - enables ssl support via `openssl` crate
//! * `rust-tls` - enables ssl support via `rustls` crate
mod connector;
mod resolver;
pub mod ssl;
pub use self::connector::{
Connect, Connector, ConnectorError, DefaultConnector, RequestPort, TcpConnector,
};
pub use self::resolver::{RequestHost, Resolver};

View File

@ -2,17 +2,14 @@ use std::collections::VecDeque;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::net::IpAddr; use std::net::IpAddr;
use actix_service::Service;
use futures::{Async, Future, Poll}; use futures::{Async, Future, Poll};
use tokio_current_thread::spawn;
use trust_dns_resolver::config::{ResolverConfig, ResolverOpts}; use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
pub use trust_dns_resolver::error::ResolveError; pub use trust_dns_resolver::error::ResolveError;
use trust_dns_resolver::lookup_ip::LookupIpFuture; use trust_dns_resolver::lookup_ip::LookupIpFuture;
use trust_dns_resolver::system_conf::read_system_conf; use trust_dns_resolver::system_conf::read_system_conf;
use trust_dns_resolver::{AsyncResolver, Background}; use trust_dns_resolver::{AsyncResolver, Background};
use super::service::Service;
/// Host name of the request /// Host name of the request
pub trait RequestHost { pub trait RequestHost {
fn host(&self) -> &str; fn host(&self) -> &str;
@ -45,7 +42,7 @@ impl<T: RequestHost> Resolver<T> {
/// Create new resolver instance with custom configuration and options. /// Create new resolver instance with custom configuration and options.
pub fn new(cfg: ResolverConfig, opts: ResolverOpts) -> Self { pub fn new(cfg: ResolverConfig, opts: ResolverOpts) -> Self {
let (resolver, bg) = AsyncResolver::new(cfg, opts); let (resolver, bg) = AsyncResolver::new(cfg, opts);
spawn(bg); actix_rt::Arbiter::spawn(bg);
Resolver { Resolver {
resolver, resolver,
req: PhantomData, req: PhantomData,
@ -70,8 +67,7 @@ impl<T> Clone for Resolver<T> {
} }
} }
impl<T: RequestHost> Service for Resolver<T> { impl<T: RequestHost> Service<T> for Resolver<T> {
type Request = T;
type Response = (T, VecDeque<IpAddr>); type Response = (T, VecDeque<IpAddr>);
type Error = ResolveError; type Error = ResolveError;
type Future = ResolverFuture<T>; type Future = ResolverFuture<T>;
@ -80,8 +76,14 @@ impl<T: RequestHost> Service for Resolver<T> {
Ok(Async::Ready(())) Ok(Async::Ready(()))
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: T) -> Self::Future {
ResolverFuture::new(req, &self.resolver) if let Ok(ip) = req.host().parse() {
let mut addrs = VecDeque::new();
addrs.push_back(ip);
ResolverFuture::new(req, &self.resolver, Some(addrs))
} else {
ResolverFuture::new(req, &self.resolver, None)
}
} }
} }
@ -94,13 +96,13 @@ pub struct ResolverFuture<T> {
} }
impl<T: RequestHost> ResolverFuture<T> { impl<T: RequestHost> ResolverFuture<T> {
pub fn new(addr: T, resolver: &AsyncResolver) -> Self { pub fn new(addr: T, resolver: &AsyncResolver, addrs: Option<VecDeque<IpAddr>>) -> Self {
// we need to do dns resolution // we need to do dns resolution
let lookup = Some(resolver.lookup_ip(addr.host())); let lookup = Some(resolver.lookup_ip(addr.host()));
ResolverFuture { ResolverFuture {
lookup, lookup,
addrs,
req: Some(addr), req: Some(addr),
addrs: None,
} }
} }
} }

View File

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

View File

@ -0,0 +1,106 @@
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::resolver::RequestHost;
/// Openssl connector factory
pub struct OpensslConnector<R, T, E> {
connector: SslConnector,
_t: PhantomData<(R, T, E)>,
}
impl<R, T, E> OpensslConnector<R, T, E> {
pub fn new(connector: SslConnector) -> Self {
OpensslConnector {
connector,
_t: PhantomData,
}
}
}
impl<R: RequestHost, T: AsyncRead + AsyncWrite> OpensslConnector<R, T, ()> {
pub fn service(
connector: SslConnector,
) -> impl Service<(R, T), Response = (R, SslStream<T>), Error = HandshakeError<T>> {
OpensslConnectorService {
connector: connector,
_t: PhantomData,
}
}
}
impl<R, T, E> Clone for OpensslConnector<R, T, E> {
fn clone(&self) -> Self {
Self {
connector: self.connector.clone(),
_t: PhantomData,
}
}
}
impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService<(R, T)>
for OpensslConnector<R, T, E>
{
type Response = (R, SslStream<T>);
type Error = HandshakeError<T>;
type Service = OpensslConnectorService<R, T>;
type InitError = E;
type Future = FutureResult<Self::Service, Self::InitError>;
fn new_service(&self) -> Self::Future {
ok(OpensslConnectorService {
connector: self.connector.clone(),
_t: PhantomData,
})
}
}
pub struct OpensslConnectorService<R, T> {
connector: SslConnector,
_t: PhantomData<(R, T)>,
}
impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service<(R, T)>
for OpensslConnectorService<R, T>
{
type Response = (R, SslStream<T>);
type Error = HandshakeError<T>;
type Future = ConnectAsyncExt<R, T>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
Ok(Async::Ready(()))
}
fn call(&mut self, (req, stream): (R, T)) -> Self::Future {
ConnectAsyncExt {
fut: SslConnectorExt::connect_async(&self.connector, req.host(), stream),
req: Some(req),
}
}
}
pub struct ConnectAsyncExt<R, T> {
req: Option<R>,
fut: ConnectAsync<T>,
}
impl<R, T> Future for ConnectAsyncExt<R, T>
where
R: RequestHost,
T: AsyncRead + AsyncWrite,
{
type Item = (R, SslStream<T>);
type Error = HandshakeError<T>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
match self.fut.poll()? {
Async::Ready(stream) => Ok(Async::Ready((self.req.take().unwrap(), stream))),
Async::NotReady => Ok(Async::NotReady),
}
}
}

5
actix-rt/CHANGES.md Normal file
View File

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

27
actix-rt/Cargo.toml Normal file
View File

@ -0,0 +1,27 @@
[package]
name = "actix-rt"
version = "0.1.0"
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]
log = "0.4"
bytes = "0.4"
futures = "0.1.24"
tokio-current-thread = "0.1"
tokio-executor = "0.1.5"
tokio-reactor = "0.1.7"
tokio-timer = "0.2.8"

267
actix-rt/src/arbiter.rs Normal file
View File

@ -0,0 +1,267 @@
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, Sender};
use futures::{future, Async, Future, IntoFuture, Poll, Stream};
use tokio_current_thread::spawn;
use crate::builder::Builder;
use crate::system::System;
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>),
}
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"),
}
}
}
#[derive(Debug, Clone)]
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 current arbiter's address
pub fn current() -> Arbiter {
ADDR.with(|cell| match *cell.borrow() {
Some(ref addr) => addr.clone(),
None => panic!("Arbiter is not running"),
})
}
/// Stop arbiter
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.
pub fn spawn<F>(future: F)
where
F: Future<Item = (), Error = ()> + 'static,
{
RUNNING.with(move |cell| {
if cell.get() {
spawn(Box::new(future));
} else {
Q.with(move |cell| cell.borrow_mut().push(Box::new(future)));
}
});
}
/// Executes a future 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 on the arbiter's thread and spawn.
pub fn send<F>(&self, future: F)
where
F: Future<Item = (), Error = ()> + Send + 'static,
{
let _ = self
.0
.unbounded_send(ArbiterCommand::Execute(Box::new(future)));
}
}
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);
}
},
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),
}
}
}
}
// /// Execute function in arbiter's thread
// impl<I: Send, E: Send> Handler<Execute<I, E>> for SystemArbiter {
// type Result = Result<I, E>;
// fn handle(&mut self, msg: Execute<I, E>, _: &mut Context<Self>) -> Result<I, E> {
// msg.exec()
// }
// }

175
actix-rt/src/builder.rs Normal file
View File

@ -0,0 +1,175 @@
use std::borrow::Cow;
use std::io;
use futures::future::{lazy, Future};
use futures::sync::mpsc::unbounded;
use futures::sync::oneshot::{channel, Receiver};
use tokio_current_thread::CurrentThread;
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(|| {})
}
/// This function will start tokio runtime and will finish once the
/// `System::stop()` message get called.
/// Function `f` get called within tokio runtime context.
pub fn run<F>(self, f: F) -> i32
where
F: FnOnce() + 'static,
{
self.create_runtime(f).run()
}
fn create_runtime<F>(self, f: F) -> SystemRunner
where
F: FnOnce() + 'static,
{
let (stop_tx, stop) = channel();
let (sys_sender, sys_receiver) = unbounded();
let arbiter = Arbiter::new_system();
let system = System::construct(sys_sender, arbiter.clone(), 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,
))
}
}
/// 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) -> i32 {
let SystemRunner { mut rt, stop, .. } = self;
// run loop
let _ = rt.block_on(lazy(move || {
Arbiter::run_system();
Ok::<_, ()>(())
}));
let code = match rt.block_on(stop) {
Ok(code) => code,
Err(_) => 1,
};
Arbiter::stop_system();
code
}
/// 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
}
}

27
actix-rt/src/lib.rs Normal file
View File

@ -0,0 +1,27 @@
//! 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::{Handle, Runtime};
pub use self::system::System;
/// 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);
}

92
actix-rt/src/mod.rs Normal file
View File

@ -0,0 +1,92 @@
//! 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)
}

236
actix-rt/src/runtime.rs Normal file
View File

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

118
actix-rt/src/system.rs Normal file
View File

@ -0,0 +1,118 @@
use std::cell::RefCell;
use futures::sync::mpsc::UnboundedSender;
use crate::arbiter::{Arbiter, SystemCommand};
use crate::builder::{Builder, SystemRunner};
/// System is a runtime manager.
#[derive(Clone, Debug)]
pub struct System {
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,
};
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()
}
/// 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"),
})
}
/// 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) -> i32
where
F: FnOnce() + 'static,
{
Self::builder().run(f)
}
}

5
actix-server/CHANGES.md Normal file
View File

@ -0,0 +1,5 @@
# Changes
## [0.1.0] - 2018-12-09
* Move server to separate crate

68
actix-server/Cargo.toml Normal file
View File

@ -0,0 +1,68 @@
[package]
name = "actix-server"
version = "0.1.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"]
[lib]
name = "actix_server"
path = "src/lib.rs"
[features]
default = []
# tls
tls = ["native-tls"]
# openssl
ssl = ["openssl", "tokio-openssl"]
# rustls
rust-tls = ["rustls", "tokio-rustls", "webpki", "webpki-roots"]
[dependencies]
actix-service = "0.1.1"
actix-rt = "0.1.0"
log = "0.4"
num_cpus = "1.0"
# io
mio = "^0.6.13"
net2 = "0.2"
bytes = "0.4"
futures = "0.1"
slab = "0.4"
tokio-io = "0.1"
tokio-tcp = "0.1"
tokio-timer = "0.2"
tokio-reactor = "0.1"
tokio-signal = "0.2"
# 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.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]
env_logger = "0.5"

View File

@ -2,14 +2,14 @@ use std::sync::mpsc as sync_mpsc;
use std::time::{Duration, Instant}; use std::time::{Duration, Instant};
use std::{io, net, thread}; use std::{io, net, thread};
use futures::{sync::mpsc, Future}; use actix_rt::System;
use futures::future::{lazy, Future};
use log::{error, info};
use mio; use mio;
use slab::Slab; use slab::Slab;
use tokio_timer::Delay; use tokio_timer::Delay;
use actix::{msgs::Execute, Arbiter, System}; use super::server::Server;
use super::server::ServerCommand;
use super::worker::{Conn, WorkerClient}; use super::worker::{Conn, WorkerClient};
use super::Token; use super::Token;
@ -53,14 +53,11 @@ pub(crate) struct AcceptLoop {
notify_ready: mio::SetReadiness, notify_ready: mio::SetReadiness,
tx: sync_mpsc::Sender<Command>, tx: sync_mpsc::Sender<Command>,
rx: Option<sync_mpsc::Receiver<Command>>, rx: Option<sync_mpsc::Receiver<Command>>,
srv: Option<( srv: Option<Server>,
mpsc::UnboundedSender<ServerCommand>,
mpsc::UnboundedReceiver<ServerCommand>,
)>,
} }
impl AcceptLoop { impl AcceptLoop {
pub fn new() -> AcceptLoop { pub fn new(srv: Server) -> AcceptLoop {
let (tx, rx) = sync_mpsc::channel(); let (tx, rx) = sync_mpsc::channel();
let (cmd_reg, cmd_ready) = mio::Registration::new2(); let (cmd_reg, cmd_ready) = mio::Registration::new2();
let (notify_reg, notify_ready) = mio::Registration::new2(); let (notify_reg, notify_ready) = mio::Registration::new2();
@ -72,7 +69,7 @@ impl AcceptLoop {
notify_ready, notify_ready,
notify_reg: Some(notify_reg), notify_reg: Some(notify_reg),
rx: Some(rx), rx: Some(rx),
srv: Some(mpsc::unbounded()), srv: Some(srv),
} }
} }
@ -89,18 +86,17 @@ impl AcceptLoop {
&mut self, &mut self,
socks: Vec<(Token, net::TcpListener)>, socks: Vec<(Token, net::TcpListener)>,
workers: Vec<WorkerClient>, workers: Vec<WorkerClient>,
) -> mpsc::UnboundedReceiver<ServerCommand> { ) {
let (tx, rx) = self.srv.take().expect("Can not re-use AcceptInfo"); let srv = self.srv.take().expect("Can not re-use AcceptInfo");
Accept::start( Accept::start(
self.rx.take().expect("Can not re-use AcceptInfo"), self.rx.take().expect("Can not re-use AcceptInfo"),
self.cmd_reg.take().expect("Can not re-use AcceptInfo"), self.cmd_reg.take().expect("Can not re-use AcceptInfo"),
self.notify_reg.take().expect("Can not re-use AcceptInfo"), self.notify_reg.take().expect("Can not re-use AcceptInfo"),
socks, socks,
tx, srv,
workers, workers,
); );
rx
} }
} }
@ -109,7 +105,7 @@ struct Accept {
rx: sync_mpsc::Receiver<Command>, rx: sync_mpsc::Receiver<Command>,
sockets: Slab<ServerSocketInfo>, sockets: Slab<ServerSocketInfo>,
workers: Vec<WorkerClient>, workers: Vec<WorkerClient>,
srv: mpsc::UnboundedSender<ServerCommand>, srv: Server,
timer: (mio::Registration, mio::SetReadiness), timer: (mio::Registration, mio::SetReadiness),
next: usize, next: usize,
backpressure: bool, backpressure: bool,
@ -134,20 +130,20 @@ fn connection_error(e: &io::Error) -> bool {
} }
impl Accept { impl Accept {
#![cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))] #![allow(clippy::too_many_arguments)]
pub(crate) fn start( pub(crate) fn start(
rx: sync_mpsc::Receiver<Command>, rx: sync_mpsc::Receiver<Command>,
cmd_reg: mio::Registration, cmd_reg: mio::Registration,
notify_reg: mio::Registration, notify_reg: mio::Registration,
socks: Vec<(Token, net::TcpListener)>, socks: Vec<(Token, net::TcpListener)>,
srv: mpsc::UnboundedSender<ServerCommand>, srv: Server,
workers: Vec<WorkerClient>, workers: Vec<WorkerClient>,
) { ) {
let sys = System::current(); let sys = System::current();
// start accept thread // start accept thread
let _ = thread::Builder::new() let _ = thread::Builder::new()
.name("actix-web accept loop".to_owned()) .name("actix-server accept loop".to_owned())
.spawn(move || { .spawn(move || {
System::set_current(sys); System::set_current(sys);
let mut accept = Accept::new(rx, socks, workers, srv); let mut accept = Accept::new(rx, socks, workers, srv);
@ -180,7 +176,7 @@ impl Accept {
rx: sync_mpsc::Receiver<Command>, rx: sync_mpsc::Receiver<Command>,
socks: Vec<(Token, net::TcpListener)>, socks: Vec<(Token, net::TcpListener)>,
workers: Vec<WorkerClient>, workers: Vec<WorkerClient>,
srv: mpsc::UnboundedSender<ServerCommand>, srv: Server,
) -> Accept { ) -> Accept {
// Create a poll instance // Create a poll instance
let poll = match mio::Poll::new() { let poll = match mio::Poll::new() {
@ -375,9 +371,7 @@ impl Accept {
match self.workers[self.next].send(msg) { match self.workers[self.next].send(msg) {
Ok(_) => (), Ok(_) => (),
Err(tmp) => { Err(tmp) => {
let _ = self.srv.unbounded_send(ServerCommand::WorkerDied( self.srv.worker_died(self.workers[self.next].idx);
self.workers[self.next].idx,
));
msg = tmp; msg = tmp;
self.workers.swap_remove(self.next); self.workers.swap_remove(self.next);
if self.workers.is_empty() { if self.workers.is_empty() {
@ -403,9 +397,7 @@ impl Accept {
return; return;
} }
Err(tmp) => { Err(tmp) => {
let _ = self.srv.unbounded_send(ServerCommand::WorkerDied( self.srv.worker_died(self.workers[self.next].idx);
self.workers[self.next].idx,
));
msg = tmp; msg = tmp;
self.workers.swap_remove(self.next); self.workers.swap_remove(self.next);
if self.workers.is_empty() { if self.workers.is_empty() {
@ -448,19 +440,14 @@ impl Accept {
info.timeout = Some(Instant::now() + Duration::from_millis(500)); info.timeout = Some(Instant::now() + Duration::from_millis(500));
let r = self.timer.1.clone(); let r = self.timer.1.clone();
System::current().arbiter().do_send(Execute::new( System::current().arbiter().send(lazy(move || {
move || -> Result<(), ()> { Delay::new(Instant::now() + Duration::from_millis(510))
Arbiter::spawn( .map_err(|_| ())
Delay::new(Instant::now() + Duration::from_millis(510)) .and_then(move |_| {
.map_err(|_| ()) let _ = r.set_readiness(mio::Ready::readable());
.and_then(move |_| { Ok(())
let _ = r.set_readiness(mio::Ready::readable()); })
Ok(()) }));
}),
);
Ok(())
},
));
return; return;
} }
} }

View File

@ -1,29 +1,27 @@
use std::time::Duration; use std::time::Duration;
use std::{io, mem, net}; use std::{io, mem, net};
use futures::sync::{mpsc, mpsc::unbounded}; use actix_rt::{spawn, Arbiter, System};
use futures::{Future, Sink, Stream}; 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 net2::TcpBuilder;
use num_cpus; use num_cpus;
use tokio_timer::sleep;
use actix::{ use crate::accept::{AcceptLoop, AcceptNotify, Command};
actors::signal, fut, msgs::Execute, Actor, ActorFuture, Addr, Arbiter, AsyncContext, use crate::config::{ConfiguredService, ServiceConfig};
Context, Handler, Response, StreamHandler, System, WrapFuture, use crate::server::{Server, ServerCommand};
}; use crate::services::{InternalServiceFactory, StreamNewService, StreamServiceFactory};
use crate::services::{ServiceFactory, ServiceNewService};
use crate::signals::{Signal, Signals};
use crate::worker::{self, Worker, WorkerAvailability, WorkerClient};
use crate::Token;
use super::accept::{AcceptLoop, AcceptNotify, Command}; /// Server builder
use super::config::{ConfiguredService, ServiceConfig}; pub struct ServerBuilder {
use super::services::{InternalServiceFactory, StreamNewService, StreamServiceFactory};
use super::services::{ServiceFactory, ServiceNewService};
use super::worker::{self, Worker, WorkerAvailability, WorkerClient};
use super::{PauseServer, ResumeServer, StopServer, Token};
pub(crate) enum ServerCommand {
WorkerDied(usize),
}
/// Server
pub struct Server {
threads: usize, threads: usize,
token: Token, token: Token,
workers: Vec<(usize, WorkerClient)>, workers: Vec<(usize, WorkerClient)>,
@ -32,30 +30,35 @@ pub struct Server {
accept: AcceptLoop, accept: AcceptLoop,
exit: bool, exit: bool,
shutdown_timeout: Duration, shutdown_timeout: Duration,
signals: Option<Addr<signal::ProcessSignals>>,
no_signals: bool, no_signals: bool,
cmd: UnboundedReceiver<ServerCommand>,
server: Server,
} }
impl Default for Server { impl Default for ServerBuilder {
fn default() -> Self { fn default() -> Self {
Self::new() Self::new()
} }
} }
impl Server { impl ServerBuilder {
/// Create new Server instance /// Create new Server builder instance
pub fn new() -> Server { pub fn new() -> ServerBuilder {
Server { let (tx, rx) = unbounded();
let server = Server::new(tx);
ServerBuilder {
threads: num_cpus::get(), threads: num_cpus::get(),
token: Token(0), token: Token(0),
workers: Vec::new(), workers: Vec::new(),
services: Vec::new(), services: Vec::new(),
sockets: Vec::new(), sockets: Vec::new(),
accept: AcceptLoop::new(), accept: AcceptLoop::new(server.clone()),
exit: false, exit: false,
shutdown_timeout: Duration::from_secs(30), shutdown_timeout: Duration::from_secs(30),
signals: None,
no_signals: false, no_signals: false,
cmd: rx,
server,
} }
} }
@ -87,13 +90,6 @@ impl Server {
self self
} }
#[doc(hidden)]
/// Set alternative address for `ProcessSignals` actor.
pub fn signals(mut self, addr: Addr<signal::ProcessSignals>) -> Self {
self.signals = Some(addr);
self
}
/// Disable signal handling /// Disable signal handling
pub fn disable_signals(mut self) -> Self { pub fn disable_signals(mut self) -> Self {
self.no_signals = true; self.no_signals = true;
@ -117,7 +113,7 @@ impl Server {
/// ///
/// This function is useful for moving parts of configuration to a /// This function is useful for moving parts of configuration to a
/// different module or even library. /// different module or even library.
pub fn configure<F>(mut self, f: F) -> io::Result<Server> pub fn configure<F>(mut self, f: F) -> io::Result<ServerBuilder>
where where
F: Fn(&mut ServiceConfig) -> io::Result<()>, F: Fn(&mut ServiceConfig) -> io::Result<()>,
{ {
@ -136,7 +132,7 @@ impl Server {
Ok(self) Ok(self)
} }
/// Add new service to server /// 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> pub fn bind<F, U, N: AsRef<str>>(mut self, name: N, addr: U, factory: F) -> io::Result<Self>
where where
F: StreamServiceFactory, F: StreamServiceFactory,
@ -157,7 +153,7 @@ impl Server {
Ok(self) Ok(self)
} }
/// Add new service to server /// Add new service to the server.
pub fn listen<F, N: AsRef<str>>( pub fn listen<F, N: AsRef<str>>(
mut self, mut self,
name: N, name: N,
@ -177,7 +173,7 @@ impl Server {
self self
} }
/// Add new service to server /// Add new service to the server.
pub fn listen2<F, N: AsRef<str>>( pub fn listen2<F, N: AsRef<str>>(
mut self, mut self,
name: N, name: N,
@ -225,10 +221,10 @@ impl Server {
sys.run(); sys.run();
} }
/// Starts Server Actor and returns its address /// Starts processing incoming connections and return server controller.
pub fn start(mut self) -> Addr<Server> { pub fn start(mut self) -> Server {
if self.sockets.is_empty() { if self.sockets.is_empty() {
panic!("Service should have at least one bound socket"); panic!("Server should have at least one bound socket");
} else { } else {
info!("Starting {} workers", self.threads); info!("Starting {} workers", self.threads);
@ -244,33 +240,18 @@ impl Server {
for sock in &self.sockets { for sock in &self.sockets {
info!("Starting server on {}", sock.1.local_addr().ok().unwrap()); info!("Starting server on {}", sock.1.local_addr().ok().unwrap());
} }
let rx = self self.accept
.accept
.start(mem::replace(&mut self.sockets, Vec::new()), workers); .start(mem::replace(&mut self.sockets, Vec::new()), workers);
// start http server actor // handle signals
let signals = self.subscribe_to_signals(); if !self.no_signals {
let addr = Actor::create(move |ctx| { Signals::start(self.server.clone());
ctx.add_stream(rx);
self
});
if let Some(signals) = signals {
signals.do_send(signal::Subscribe(addr.clone().recipient()))
} }
addr
}
}
// subscribe to os signals // start http server actor
fn subscribe_to_signals(&self) -> Option<Addr<signal::ProcessSignals>> { let server = self.server.clone();
if !self.no_signals { spawn(self);
if let Some(ref signals) = self.signals { server
Some(signals.clone())
} else {
Some(System::current().registry().get::<signal::ProcessSignals>())
}
} else {
None
} }
} }
@ -283,118 +264,99 @@ impl Server {
let services: Vec<Box<InternalServiceFactory>> = let services: Vec<Box<InternalServiceFactory>> =
self.services.iter().map(|v| v.clone_factory()).collect(); self.services.iter().map(|v| v.clone_factory()).collect();
Arbiter::new(format!("actix-net-worker-{}", idx)).do_send(Execute::new(move || { Arbiter::new().send(lazy(move || {
Worker::start(rx1, rx2, services, avail, timeout.clone()); Worker::start(rx1, rx2, services, avail, timeout);
Ok::<_, ()>(()) Ok::<_, ()>(())
})); }));
worker worker
} }
}
impl Actor for Server { fn handle_cmd(&mut self, item: ServerCommand) {
type Context = Context<Self>; match item {
} ServerCommand::Pause(tx) => {
self.accept.send(Command::Pause);
/// Signals support let _ = tx.send(());
/// Handle `SIGINT`, `SIGTERM`, `SIGQUIT` signals and stop actix system
/// message to `System` actor.
impl Handler<signal::Signal> for Server {
type Result = ();
fn handle(&mut self, msg: signal::Signal, ctx: &mut Context<Self>) {
match msg.0 {
signal::SignalType::Int => {
info!("SIGINT received, exiting");
self.exit = true;
Handler::<StopServer>::handle(self, StopServer { graceful: false }, ctx);
} }
signal::SignalType::Term => { ServerCommand::Resume(tx) => {
info!("SIGTERM received, stopping"); self.accept.send(Command::Resume);
self.exit = true; let _ = tx.send(());
Handler::<StopServer>::handle(self, StopServer { graceful: true }, ctx);
} }
signal::SignalType::Quit => { ServerCommand::Signal(sig) => {
info!("SIGQUIT received, exiting"); // Signals support
self.exit = true; // Handle `SIGINT`, `SIGTERM`, `SIGQUIT` signals and stop actix system
Handler::<StopServer>::handle(self, StopServer { graceful: false }, ctx); 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;
impl Handler<PauseServer> for Server { // stop accept thread
type Result = (); self.accept.send(Command::Stop);
fn handle(&mut self, _: PauseServer, _: &mut Context<Self>) { // stop workers
self.accept.send(Command::Pause); if !self.workers.is_empty() {
} spawn(
} futures_unordered(
self.workers
impl Handler<ResumeServer> for Server { .iter()
type Result = (); .map(move |worker| worker.1.stop(graceful)),
)
fn handle(&mut self, _: ResumeServer, _: &mut Context<Self>) { .collect()
self.accept.send(Command::Resume); .then(move |_| {
} if let Some(tx) = completion {
} let _ = tx.send(());
impl Handler<StopServer> for Server {
type Result = Response<(), ()>;
fn handle(&mut self, msg: StopServer, ctx: &mut Context<Self>) -> Self::Result {
// stop accept thread
self.accept.send(Command::Stop);
// stop workers
let (tx, rx) = mpsc::channel(1);
for worker in &self.workers {
let tx2 = tx.clone();
ctx.spawn(
worker
.1
.stop(msg.graceful)
.into_actor(self)
.then(move |_, slf, ctx| {
slf.workers.pop();
if slf.workers.is_empty() {
let _ = tx2.send(());
// we need to stop system if server was spawned
if slf.exit {
ctx.run_later(Duration::from_millis(300), |_, _| {
System::current().stop();
});
} }
} if exit {
spawn(sleep(Duration::from_millis(300)).then(|_| {
fut::ok(()) System::current().stop();
}), ok(())
); }));
} }
ok(())
if !self.workers.is_empty() { }),
Response::async(rx.into_future().map(|_| ()).map_err(|_| ())) )
} else { } else {
// we need to stop system if server was spawned // we need to stop system if server was spawned
if self.exit { if self.exit {
ctx.run_later(Duration::from_millis(300), |_, _| { spawn(sleep(Duration::from_millis(300)).then(|_| {
System::current().stop(); System::current().stop();
}); ok(())
}));
}
if let Some(tx) = completion {
let _ = tx.send(());
}
}
} }
Response::reply(Ok(()))
}
}
}
/// Commands from accept threads
impl StreamHandler<ServerCommand, ()> for Server {
fn finished(&mut self, _: &mut Context<Self>) {}
fn handle(&mut self, msg: ServerCommand, _: &mut Context<Self>) {
match msg {
ServerCommand::WorkerDied(idx) => { ServerCommand::WorkerDied(idx) => {
let mut found = false; let mut found = false;
for i in 0..self.workers.len() { for i in 0..self.workers.len() {
@ -428,6 +390,21 @@ impl StreamHandler<ServerCommand, ()> for Server {
} }
} }
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) -> io::Result<Vec<net::TcpListener>> { pub(super) fn bind_addr<S: net::ToSocketAddrs>(addr: S) -> io::Result<Vec<net::TcpListener>> {
let mut err = None; let mut err = None;
let mut succ = false; let mut succ = false;

View File

@ -1,13 +1,14 @@
use std::collections::HashMap; use std::collections::HashMap;
use std::{fmt, io, net}; use std::{fmt, io, net};
use actix_service::{IntoNewService, NewService};
use futures::future::{join_all, Future}; use futures::future::{join_all, Future};
use log::error;
use tokio_tcp::TcpStream; use tokio_tcp::TcpStream;
use counter::CounterGuard; use crate::counter::CounterGuard;
use service::{IntoNewService, NewService};
use super::server::bind_addr; use super::builder::bind_addr;
use super::services::{ use super::services::{
BoxedServerService, InternalServiceFactory, ServerMessage, StreamService, BoxedServerService, InternalServiceFactory, ServerMessage, StreamService,
}; };
@ -111,7 +112,7 @@ impl InternalServiceFactory for ConfiguredService {
pub(super) trait ServiceRuntimeConfiguration: Send { pub(super) trait ServiceRuntimeConfiguration: Send {
fn clone(&self) -> Box<ServiceRuntimeConfiguration>; fn clone(&self) -> Box<ServiceRuntimeConfiguration>;
fn configure(&self, &mut ServiceRuntime); fn configure(&self, rt: &mut ServiceRuntime);
} }
impl<F> ServiceRuntimeConfiguration for F impl<F> ServiceRuntimeConfiguration for F
@ -154,8 +155,8 @@ impl ServiceRuntime {
pub fn service<T, F>(&mut self, name: &str, service: F) pub fn service<T, F>(&mut self, name: &str, service: F)
where where
F: IntoNewService<T>, F: IntoNewService<T, TcpStream>,
T: NewService<Request = TcpStream, Response = ()> + 'static, T: NewService<TcpStream, Response = ()> + 'static,
T::Future: 'static, T::Future: 'static,
T::Service: 'static, T::Service: 'static,
T::InitError: fmt::Debug, T::InitError: fmt::Debug,
@ -176,7 +177,7 @@ impl ServiceRuntime {
type BoxedNewService = Box< type BoxedNewService = Box<
NewService< NewService<
Request = (Option<CounterGuard>, ServerMessage), (Option<CounterGuard>, ServerMessage),
Response = (), Response = (),
Error = (), Error = (),
InitError = (), InitError = (),
@ -189,15 +190,14 @@ struct ServiceFactory<T> {
inner: T, inner: T,
} }
impl<T> NewService for ServiceFactory<T> impl<T> NewService<(Option<CounterGuard>, ServerMessage)> for ServiceFactory<T>
where where
T: NewService<Request = TcpStream, Response = ()>, T: NewService<TcpStream, Response = ()>,
T::Future: 'static, T::Future: 'static,
T::Service: 'static, T::Service: 'static,
T::Error: 'static, T::Error: 'static,
T::InitError: fmt::Debug + 'static, T::InitError: fmt::Debug + 'static,
{ {
type Request = (Option<CounterGuard>, ServerMessage);
type Response = (); type Response = ();
type Error = (); type Error = ();
type InitError = (); type InitError = ();

33
actix-server/src/lib.rs Normal file
View File

@ -0,0 +1,33 @@
//! General purpose tcp server
mod accept;
mod builder;
mod config;
mod counter;
mod server;
mod services;
mod signals;
pub mod ssl;
mod worker;
pub use self::builder::ServerBuilder;
pub use self::config::{ServiceConfig, ServiceRuntime};
pub use self::server::Server;
pub use self::services::{ServerMessage, ServiceFactory, StreamServiceFactory};
/// 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 build() -> ServerBuilder {
ServerBuilder::default()
}

View File

@ -0,0 +1,69 @@
use futures::sync::mpsc::UnboundedSender;
use futures::sync::oneshot;
use futures::Future;
use crate::builder::ServerBuilder;
use crate::signals::Signal;
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(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(|_| ())
}
}

View File

@ -1,15 +1,16 @@
use std::net; use std::net;
use std::time::Duration; use std::time::Duration;
use actix_rt::spawn;
use actix_service::{NewService, Service};
use futures::future::{err, ok, FutureResult}; use futures::future::{err, ok, FutureResult};
use futures::{Future, Poll}; use futures::{Future, Poll};
use tokio_current_thread::spawn; use log::error;
use tokio_reactor::Handle; use tokio_reactor::Handle;
use tokio_tcp::TcpStream; use tokio_tcp::TcpStream;
use super::Token; use super::Token;
use counter::CounterGuard; use crate::counter::CounterGuard;
use service::{NewService, Service};
/// Server message /// Server message
pub enum ServerMessage { pub enum ServerMessage {
@ -22,13 +23,13 @@ pub enum ServerMessage {
} }
pub trait StreamServiceFactory: Send + Clone + 'static { pub trait StreamServiceFactory: Send + Clone + 'static {
type NewService: NewService<Request = TcpStream, Response = ()>; type NewService: NewService<TcpStream, Response = ()>;
fn create(&self) -> Self::NewService; fn create(&self) -> Self::NewService;
} }
pub trait ServiceFactory: Send + Clone + 'static { pub trait ServiceFactory: Send + Clone + 'static {
type NewService: NewService<Request = ServerMessage, Response = ()>; type NewService: NewService<ServerMessage, Response = ()>;
fn create(&self) -> Self::NewService; fn create(&self) -> Self::NewService;
} }
@ -43,7 +44,7 @@ pub(crate) trait InternalServiceFactory: Send {
pub(crate) type BoxedServerService = Box< pub(crate) type BoxedServerService = Box<
Service< Service<
Request = (Option<CounterGuard>, ServerMessage), (Option<CounterGuard>, ServerMessage),
Response = (), Response = (),
Error = (), Error = (),
Future = FutureResult<(), ()>, Future = FutureResult<(), ()>,
@ -60,13 +61,12 @@ impl<T> StreamService<T> {
} }
} }
impl<T> Service for StreamService<T> impl<T> Service<(Option<CounterGuard>, ServerMessage)> for StreamService<T>
where where
T: Service<Request = TcpStream, Response = ()>, T: Service<TcpStream, Response = ()>,
T::Future: 'static, T::Future: 'static,
T::Error: 'static, T::Error: 'static,
{ {
type Request = (Option<CounterGuard>, ServerMessage);
type Response = (); type Response = ();
type Error = (); type Error = ();
type Future = FutureResult<(), ()>; type Future = FutureResult<(), ()>;
@ -107,13 +107,12 @@ impl<T> ServerService<T> {
} }
} }
impl<T> Service for ServerService<T> impl<T> Service<(Option<CounterGuard>, ServerMessage)> for ServerService<T>
where where
T: Service<Request = ServerMessage, Response = ()>, T: Service<ServerMessage, Response = ()>,
T::Future: 'static, T::Future: 'static,
T::Error: 'static, T::Error: 'static,
{ {
type Request = (Option<CounterGuard>, ServerMessage);
type Response = (); type Response = ();
type Error = (); type Error = ();
type Future = FutureResult<(), ()>; type Future = FutureResult<(), ()>;
@ -240,7 +239,7 @@ impl InternalServiceFactory for Box<InternalServiceFactory> {
impl<F, T> ServiceFactory for F impl<F, T> ServiceFactory for F
where where
F: Fn() -> T + Send + Clone + 'static, F: Fn() -> T + Send + Clone + 'static,
T: NewService<Request = ServerMessage, Response = ()>, T: NewService<ServerMessage, Response = ()>,
{ {
type NewService = T; type NewService = T;
@ -252,7 +251,7 @@ where
impl<F, T> StreamServiceFactory for F impl<F, T> StreamServiceFactory for F
where where
F: Fn() -> T + Send + Clone + 'static, F: Fn() -> T + Send + Clone + 'static,
T: NewService<Request = TcpStream, Response = ()>, T: NewService<TcpStream, Response = ()>,
{ {
type NewService = T; type NewService = T;

116
actix-server/src/signals.rs Normal file
View File

@ -0,0 +1,116 @@
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<Stream<Item = Signal, Error = io::Error>>;
impl Signals {
pub(crate) fn start(srv: Server) {
let fut = {
#[cfg(not(unix))]
{
tokio_signal::ctrl_c().and_then(move |stream| Signals {
srv,
stream: Box::new(stream.map(|_| Signal::Int)),
})
}
#[cfg(unix)]
{
use tokio_signal::unix;
let mut sigs: Vec<Box<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)
}
}
}

View File

@ -1,12 +1,12 @@
//! SSL Services //! SSL Services
use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::atomic::{AtomicUsize, Ordering};
use super::counter::Counter; use crate::counter::Counter;
#[cfg(feature = "ssl")] #[cfg(feature = "ssl")]
mod openssl; mod openssl;
#[cfg(feature = "ssl")] #[cfg(feature = "ssl")]
pub use self::openssl::{OpensslAcceptor, OpensslConnector}; pub use self::openssl::OpensslAcceptor;
#[cfg(feature = "tls")] #[cfg(feature = "tls")]
mod nativetls; mod nativetls;
@ -28,7 +28,7 @@ pub fn max_concurrent_ssl_connect(num: usize) {
MAX_CONN.store(num, Ordering::Relaxed); MAX_CONN.store(num, Ordering::Relaxed);
} }
pub(crate) const MAX_CONN: AtomicUsize = AtomicUsize::new(256); pub(crate) static MAX_CONN: AtomicUsize = AtomicUsize::new(256);
thread_local! { thread_local! {
static MAX_CONN_COUNTER: Counter = Counter::new(MAX_CONN.load(Ordering::Relaxed)); static MAX_CONN_COUNTER: Counter = Counter::new(MAX_CONN.load(Ordering::Relaxed));

View File

@ -1,13 +1,13 @@
use std::io; use std::io;
use std::marker::PhantomData; use std::marker::PhantomData;
use actix_service::{NewService, Service};
use futures::{future::ok, future::FutureResult, Async, Future, Poll}; use futures::{future::ok, future::FutureResult, Async, Future, Poll};
use native_tls::{self, Error, HandshakeError, TlsAcceptor}; use native_tls::{self, Error, HandshakeError, TlsAcceptor};
use tokio_io::{AsyncRead, AsyncWrite}; use tokio_io::{AsyncRead, AsyncWrite};
use super::MAX_CONN_COUNTER; use super::MAX_CONN_COUNTER;
use counter::{Counter, CounterGuard}; use crate::counter::{Counter, CounterGuard};
use service::{NewService, Service};
/// Support `SSL` connections via native-tls package /// Support `SSL` connections via native-tls package
/// ///
@ -21,7 +21,7 @@ impl<T: AsyncRead + AsyncWrite> NativeTlsAcceptor<T> {
/// Create `NativeTlsAcceptor` instance /// Create `NativeTlsAcceptor` instance
pub fn new(acceptor: TlsAcceptor) -> Self { pub fn new(acceptor: TlsAcceptor) -> Self {
NativeTlsAcceptor { NativeTlsAcceptor {
acceptor: acceptor.into(), acceptor,
io: PhantomData, io: PhantomData,
} }
} }
@ -36,8 +36,7 @@ impl<T: AsyncRead + AsyncWrite> Clone for NativeTlsAcceptor<T> {
} }
} }
impl<T: AsyncRead + AsyncWrite> NewService for NativeTlsAcceptor<T> { impl<T: AsyncRead + AsyncWrite> NewService<T> for NativeTlsAcceptor<T> {
type Request = T;
type Response = TlsStream<T>; type Response = TlsStream<T>;
type Error = Error; type Error = Error;
type Service = NativeTlsAcceptorService<T>; type Service = NativeTlsAcceptorService<T>;
@ -61,8 +60,7 @@ pub struct NativeTlsAcceptorService<T> {
conns: Counter, conns: Counter,
} }
impl<T: AsyncRead + AsyncWrite> Service for NativeTlsAcceptorService<T> { impl<T: AsyncRead + AsyncWrite> Service<T> for NativeTlsAcceptorService<T> {
type Request = T;
type Response = TlsStream<T>; type Response = TlsStream<T>;
type Error = Error; type Error = Error;
type Future = Accept<T>; type Future = Accept<T>;
@ -75,7 +73,7 @@ impl<T: AsyncRead + AsyncWrite> Service for NativeTlsAcceptorService<T> {
} }
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: T) -> Self::Future {
Accept { Accept {
_guard: self.conns.get(), _guard: self.conns.get(),
inner: Some(self.acceptor.accept(req)), inner: Some(self.acceptor.accept(req)),

View File

@ -0,0 +1,99 @@
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 super::MAX_CONN_COUNTER;
use crate::counter::{Counter, CounterGuard};
/// Support `SSL` connections via openssl package
///
/// `ssl` feature enables `OpensslAcceptor` type
pub struct OpensslAcceptor<T> {
acceptor: SslAcceptor,
io: PhantomData<T>,
}
impl<T> OpensslAcceptor<T> {
/// Create default `OpensslAcceptor`
pub fn new(acceptor: SslAcceptor) -> Self {
OpensslAcceptor {
acceptor,
io: PhantomData,
}
}
}
impl<T: AsyncRead + AsyncWrite> Clone for OpensslAcceptor<T> {
fn clone(&self) -> Self {
Self {
acceptor: self.acceptor.clone(),
io: PhantomData,
}
}
}
impl<T: AsyncRead + AsyncWrite> NewService<T> for OpensslAcceptor<T> {
type Response = SslStream<T>;
type Error = HandshakeError<T>;
type Service = OpensslAcceptorService<T>;
type InitError = ();
type Future = FutureResult<Self::Service, Self::InitError>;
fn new_service(&self) -> Self::Future {
MAX_CONN_COUNTER.with(|conns| {
ok(OpensslAcceptorService {
acceptor: self.acceptor.clone(),
conns: conns.clone(),
io: PhantomData,
})
})
}
}
pub struct OpensslAcceptorService<T> {
acceptor: SslAcceptor,
io: PhantomData<T>,
conns: Counter,
}
impl<T: AsyncRead + AsyncWrite> Service<T> for OpensslAcceptorService<T> {
type Response = SslStream<T>;
type Error = HandshakeError<T>;
type Future = OpensslAcceptorServiceFut<T>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
if self.conns.available() {
Ok(Async::Ready(()))
} else {
Ok(Async::NotReady)
}
}
fn call(&mut self, req: T) -> Self::Future {
OpensslAcceptorServiceFut {
_guard: self.conns.get(),
fut: SslAcceptorExt::accept_async(&self.acceptor, req),
}
}
}
pub struct OpensslAcceptorServiceFut<T>
where
T: AsyncRead + AsyncWrite,
{
fut: AcceptAsync<T>,
_guard: CounterGuard,
}
impl<T: AsyncRead + AsyncWrite> Future for OpensslAcceptorServiceFut<T> {
type Item = SslStream<T>;
type Error = HandshakeError<T>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
self.fut.poll()
}
}

View File

@ -2,14 +2,14 @@ use std::io;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::sync::Arc; use std::sync::Arc;
use actix_service::{NewService, Service};
use futures::{future::ok, future::FutureResult, Async, Future, Poll}; use futures::{future::ok, future::FutureResult, Async, Future, Poll};
use rustls::{ServerConfig, ServerSession}; use rustls::{ServerConfig, ServerSession};
use tokio_io::{AsyncRead, AsyncWrite}; use tokio_io::{AsyncRead, AsyncWrite};
use tokio_rustls::{Accept, TlsAcceptor, TlsStream}; use tokio_rustls::{Accept, TlsAcceptor, TlsStream};
use super::MAX_CONN_COUNTER; use super::MAX_CONN_COUNTER;
use counter::{Counter, CounterGuard}; use crate::counter::{Counter, CounterGuard};
use service::{NewService, Service};
/// Support `SSL` connections via rustls package /// Support `SSL` connections via rustls package
/// ///
@ -38,8 +38,7 @@ impl<T> Clone for RustlsAcceptor<T> {
} }
} }
impl<T: AsyncRead + AsyncWrite> NewService for RustlsAcceptor<T> { impl<T: AsyncRead + AsyncWrite> NewService<T> for RustlsAcceptor<T> {
type Request = T;
type Response = TlsStream<T, ServerSession>; type Response = TlsStream<T, ServerSession>;
type Error = io::Error; type Error = io::Error;
type Service = RustlsAcceptorService<T>; type Service = RustlsAcceptorService<T>;
@ -63,8 +62,7 @@ pub struct RustlsAcceptorService<T> {
conns: Counter, conns: Counter,
} }
impl<T: AsyncRead + AsyncWrite> Service for RustlsAcceptorService<T> { impl<T: AsyncRead + AsyncWrite> Service<T> for RustlsAcceptorService<T> {
type Request = T;
type Response = TlsStream<T, ServerSession>; type Response = TlsStream<T, ServerSession>;
type Error = io::Error; type Error = io::Error;
type Future = RustlsAcceptorServiceFut<T>; type Future = RustlsAcceptorServiceFut<T>;
@ -77,7 +75,7 @@ impl<T: AsyncRead + AsyncWrite> Service for RustlsAcceptorService<T> {
} }
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: T) -> Self::Future {
RustlsAcceptorServiceFut { RustlsAcceptorServiceFut {
_guard: self.conns.get(), _guard: self.conns.get(),
fut: self.acceptor.accept(req), fut: self.acceptor.accept(req),

View File

@ -2,19 +2,17 @@ use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::Arc; use std::sync::Arc;
use std::{mem, net, time}; use std::{mem, net, time};
use actix_rt::{spawn, Arbiter};
use futures::sync::mpsc::{UnboundedReceiver, UnboundedSender}; use futures::sync::mpsc::{UnboundedReceiver, UnboundedSender};
use futures::sync::oneshot; use futures::sync::oneshot;
use futures::{future, Async, Future, Poll, Stream}; use futures::{future, Async, Future, Poll, Stream};
use tokio_current_thread::spawn; use log::{error, info, trace};
use tokio_timer::{sleep, Delay}; use tokio_timer::{sleep, Delay};
use actix::msgs::StopArbiter; use crate::accept::AcceptNotify;
use actix::{Arbiter, Message}; use crate::counter::Counter;
use crate::services::{BoxedServerService, InternalServiceFactory, ServerMessage};
use super::accept::AcceptNotify; use crate::Token;
use super::services::{BoxedServerService, InternalServiceFactory, ServerMessage};
use super::Token;
use counter::Counter;
pub(crate) struct WorkerCommand(Conn); pub(crate) struct WorkerCommand(Conn);
@ -25,14 +23,14 @@ pub(crate) struct StopCommand {
result: oneshot::Sender<bool>, result: oneshot::Sender<bool>,
} }
#[derive(Debug, Message)] #[derive(Debug)]
pub(crate) struct Conn { pub(crate) struct Conn {
pub io: net::TcpStream, pub io: net::TcpStream,
pub token: Token, pub token: Token,
pub peer: Option<net::SocketAddr>, pub peer: Option<net::SocketAddr>,
} }
const MAX_CONNS: AtomicUsize = AtomicUsize::new(25600); static MAX_CONNS: AtomicUsize = AtomicUsize::new(25600);
/// Sets the maximum per-worker number of concurrent connections. /// Sets the maximum per-worker number of concurrent connections.
/// ///
@ -166,8 +164,9 @@ impl Worker {
future::join_all(fut) future::join_all(fut)
.map_err(|e| { .map_err(|e| {
error!("Can not start worker: {:?}", e); error!("Can not start worker: {:?}", e);
Arbiter::current().do_send(StopArbiter(0)); Arbiter::current().stop();
}).and_then(move |services| { })
.and_then(move |services| {
for item in services { for item in services {
for (idx, token, service) in item { for (idx, token, service) in item {
while token.0 >= wrk.services.len() { while token.0 >= wrk.services.len() {
@ -192,7 +191,7 @@ impl Worker {
let timeout = self.shutdown_timeout; let timeout = self.shutdown_timeout;
self.services.iter_mut().for_each(move |h| { self.services.iter_mut().for_each(move |h| {
if let Some(h) = h { if let Some(h) = h {
let _ = h.1.call((None, ServerMessage::Shutdown(timeout.clone()))); let _ = h.1.call((None, ServerMessage::Shutdown(timeout)));
} }
}); });
} }
@ -249,36 +248,33 @@ impl Future for Worker {
fn poll(&mut self) -> Poll<Self::Item, Self::Error> { fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
// `StopWorker` message handler // `StopWorker` message handler
match self.rx2.poll() { if let Ok(Async::Ready(Some(StopCommand { graceful, result }))) = self.rx2.poll() {
Ok(Async::Ready(Some(StopCommand { graceful, result }))) => { self.availability.set(false);
self.availability.set(false); let num = num_connections();
if num == 0 {
info!("Shutting down worker, 0 connections");
let _ = result.send(true);
return Ok(Async::Ready(()));
} else if graceful {
self.shutdown(false);
let num = num_connections(); let num = num_connections();
if num == 0 { if num != 0 {
info!("Shutting down worker, 0 connections"); info!("Graceful worker shutdown, {} connections", num);
self.state = WorkerState::Shutdown(
sleep(time::Duration::from_secs(1)),
sleep(self.shutdown_timeout),
result,
);
} else {
let _ = result.send(true); let _ = result.send(true);
return Ok(Async::Ready(())); return Ok(Async::Ready(()));
} else if graceful {
self.shutdown(false);
let num = num_connections();
if num != 0 {
info!("Graceful worker shutdown, {} connections", num);
self.state = WorkerState::Shutdown(
sleep(time::Duration::from_secs(1)),
sleep(self.shutdown_timeout),
result,
);
} else {
let _ = result.send(true);
return Ok(Async::Ready(()));
}
} else {
info!("Force shutdown worker, {} connections", num);
self.shutdown(true);
let _ = result.send(false);
return Ok(Async::Ready(()));
} }
} else {
info!("Force shutdown worker, {} connections", num);
self.shutdown(true);
let _ = result.send(false);
return Ok(Async::Ready(()));
} }
_ => (),
} }
let state = mem::replace(&mut self.state, WorkerState::None); let state = mem::replace(&mut self.state, WorkerState::None);
@ -366,7 +362,7 @@ impl Future for Worker {
let num = num_connections(); let num = num_connections();
if num == 0 { if num == 0 {
let _ = tx.send(true); let _ = tx.send(true);
Arbiter::current().do_send(StopArbiter(0)); Arbiter::current().stop();
return Ok(Async::Ready(())); return Ok(Async::Ready(()));
} }
@ -376,7 +372,7 @@ impl Future for Worker {
Async::Ready(_) => { Async::Ready(_) => {
self.shutdown(true); self.shutdown(true);
let _ = tx.send(false); let _ = tx.send(false);
Arbiter::current().do_send(StopArbiter(0)); Arbiter::current().stop();
return Ok(Async::Ready(())); return Ok(Async::Ready(()));
} }
} }

12
actix-service/CHANGES.md Normal file
View File

@ -0,0 +1,12 @@
# Changes
## [0.1.1] - 2018-12-09
### Added
* Added Service impl for Box<S: Service>
## [0.1.0] - 2018-12-09
* Initial import

26
actix-service/Cargo.toml Normal file
View File

@ -0,0 +1,26 @@
[package]
name = "actix-service"
version = "0.1.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 = "fafhrd91/actix-web-hdy9d" }
codecov = { repository = "actix/actix-service", branch = "master", service = "github" }
[lib]
name = "actix_service"
path = "src/lib.rs"
[dependencies]
futures = "0.1.24"

View File

@ -1,7 +1,7 @@
use futures::{Async, Future, Poll}; use futures::{try_ready, Async, Future, Poll};
use super::{IntoNewService, NewService, Service}; use super::{IntoNewService, NewService, Service};
use cell::Cell; use crate::cell::Cell;
/// Service for the `and_then` combinator, chaining a computation onto the end /// Service for the `and_then` combinator, chaining a computation onto the end
/// of another service which completes successfully. /// of another service which completes successfully.
@ -12,21 +12,20 @@ pub struct AndThen<A, B> {
b: Cell<B>, b: Cell<B>,
} }
impl<A, B> AndThen<A, B> impl<A, B> AndThen<A, B> {
where
A: Service,
B: Service<Request = A::Response, Error = A::Error>,
{
/// Create new `AndThen` combinator /// Create new `AndThen` combinator
pub fn new(a: A, b: B) -> Self { pub fn new<Request>(a: A, b: B) -> Self
where
A: Service<Request>,
B: Service<A::Response, Error = A::Error>,
{
Self { a, b: Cell::new(b) } Self { a, b: Cell::new(b) }
} }
} }
impl<A, B> Clone for AndThen<A, B> impl<A, B> Clone for AndThen<A, B>
where where
A: Service + Clone, A: Clone,
B: Service<Request = A::Response, Error = A::Error>,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
AndThen { AndThen {
@ -36,40 +35,39 @@ where
} }
} }
impl<A, B> Service for AndThen<A, B> impl<A, B, Request> Service<Request> for AndThen<A, B>
where where
A: Service, A: Service<Request>,
B: Service<Request = A::Response, Error = A::Error>, B: Service<A::Response, Error = A::Error>,
{ {
type Request = A::Request;
type Response = B::Response; type Response = B::Response;
type Error = A::Error; type Error = A::Error;
type Future = AndThenFuture<A, B>; type Future = AndThenFuture<A, B, Request>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> { fn poll_ready(&mut self) -> Poll<(), Self::Error> {
let _ = try_ready!(self.a.poll_ready()); try_ready!(self.a.poll_ready());
self.b.borrow_mut().poll_ready() self.b.get_mut().poll_ready()
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: Request) -> Self::Future {
AndThenFuture::new(self.a.call(req), self.b.clone()) AndThenFuture::new(self.a.call(req), self.b.clone())
} }
} }
pub struct AndThenFuture<A, B> pub struct AndThenFuture<A, B, Request>
where where
A: Service, A: Service<Request>,
B: Service<Request = A::Response, Error = A::Error>, B: Service<A::Response, Error = A::Error>,
{ {
b: Cell<B>, b: Cell<B>,
fut_b: Option<B::Future>, fut_b: Option<B::Future>,
fut_a: A::Future, fut_a: A::Future,
} }
impl<A, B> AndThenFuture<A, B> impl<A, B, Request> AndThenFuture<A, B, Request>
where where
A: Service, A: Service<Request>,
B: Service<Request = A::Response, Error = A::Error>, B: Service<A::Response, Error = A::Error>,
{ {
fn new(fut_a: A::Future, b: Cell<B>) -> Self { fn new(fut_a: A::Future, b: Cell<B>) -> Self {
AndThenFuture { AndThenFuture {
@ -80,11 +78,10 @@ where
} }
} }
impl<A, B> Future for AndThenFuture<A, B> impl<A, B, Request> Future for AndThenFuture<A, B, Request>
where where
A: Service, A: Service<Request>,
B: Service<Request = A::Response, Error = A::Error>, B: Service<A::Response, Error = A::Error>,
B::Error: Into<A::Error>,
{ {
type Item = B::Response; type Item = B::Response;
type Error = A::Error; type Error = A::Error;
@ -96,7 +93,7 @@ where
match self.fut_a.poll() { match self.fut_a.poll() {
Ok(Async::Ready(resp)) => { Ok(Async::Ready(resp)) => {
self.fut_b = Some(self.b.borrow_mut().call(resp)); self.fut_b = Some(self.b.get_mut().call(resp));
self.poll() self.poll()
} }
Ok(Async::NotReady) => Ok(Async::NotReady), Ok(Async::NotReady) => Ok(Async::NotReady),
@ -111,13 +108,13 @@ pub struct AndThenNewService<A, B> {
b: B, b: B,
} }
impl<A, B> AndThenNewService<A, B> impl<A, B> AndThenNewService<A, B> {
where
A: NewService,
B: NewService,
{
/// Create new `AndThen` combinator /// Create new `AndThen` combinator
pub fn new<F: IntoNewService<B>>(a: A, f: F) -> Self { pub fn new<Request, F: IntoNewService<B, A::Response>>(a: A, f: F) -> Self
where
A: NewService<Request>,
B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
{
Self { Self {
a, a,
b: f.into_new_service(), b: f.into_new_service(),
@ -125,18 +122,17 @@ where
} }
} }
impl<A, B> NewService for AndThenNewService<A, B> impl<A, B, Request> NewService<Request> for AndThenNewService<A, B>
where where
A: NewService, A: NewService<Request>,
B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>, B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
{ {
type Request = A::Request;
type Response = B::Response; type Response = B::Response;
type Error = A::Error; type Error = A::Error;
type Service = AndThen<A::Service, B::Service>; type Service = AndThen<A::Service, B::Service>;
type InitError = A::InitError; type InitError = A::InitError;
type Future = AndThenNewServiceFuture<A, B>; type Future = AndThenNewServiceFuture<A, B, Request>;
fn new_service(&self) -> Self::Future { fn new_service(&self) -> Self::Future {
AndThenNewServiceFuture::new(self.a.new_service(), self.b.new_service()) AndThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
@ -145,8 +141,8 @@ where
impl<A, B> Clone for AndThenNewService<A, B> impl<A, B> Clone for AndThenNewService<A, B>
where where
A: NewService + Clone, A: Clone,
B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError> + Clone, B: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -156,10 +152,10 @@ where
} }
} }
pub struct AndThenNewServiceFuture<A, B> pub struct AndThenNewServiceFuture<A, B, Request>
where where
A: NewService, A: NewService<Request>,
B: NewService, B: NewService<A::Response>,
{ {
fut_b: B::Future, fut_b: B::Future,
fut_a: A::Future, fut_a: A::Future,
@ -167,10 +163,10 @@ where
b: Option<B::Service>, b: Option<B::Service>,
} }
impl<A, B> AndThenNewServiceFuture<A, B> impl<A, B, Request> AndThenNewServiceFuture<A, B, Request>
where where
A: NewService, A: NewService<Request>,
B: NewService, B: NewService<A::Response>,
{ {
fn new(fut_a: A::Future, fut_b: B::Future) -> Self { fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
AndThenNewServiceFuture { AndThenNewServiceFuture {
@ -182,10 +178,10 @@ where
} }
} }
impl<A, B> Future for AndThenNewServiceFuture<A, B> impl<A, B, Request> Future for AndThenNewServiceFuture<A, B, Request>
where where
A: NewService, A: NewService<Request>,
B: NewService<Request = A::Response, Error = A::Error, InitError = A::InitError>, B: NewService<A::Response, Error = A::Error, InitError = A::InitError>,
{ {
type Item = AndThen<A::Service, B::Service>; type Item = AndThen<A::Service, B::Service>;
type Error = A::InitError; type Error = A::InitError;
@ -222,11 +218,10 @@ mod tests {
use std::rc::Rc; use std::rc::Rc;
use super::*; use super::*;
use service::{NewServiceExt, Service, ServiceExt}; use crate::{NewService, Service};
struct Srv1(Rc<Cell<usize>>); struct Srv1(Rc<Cell<usize>>);
impl Service for Srv1 { impl Service<&'static str> for Srv1 {
type Request = &'static str;
type Response = &'static str; type Response = &'static str;
type Error = (); type Error = ();
type Future = FutureResult<Self::Response, ()>; type Future = FutureResult<Self::Response, ()>;
@ -236,7 +231,7 @@ mod tests {
Ok(Async::Ready(())) Ok(Async::Ready(()))
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: &'static str) -> Self::Future {
ok(req) ok(req)
} }
} }
@ -244,8 +239,7 @@ mod tests {
#[derive(Clone)] #[derive(Clone)]
struct Srv2(Rc<Cell<usize>>); struct Srv2(Rc<Cell<usize>>);
impl Service for Srv2 { impl Service<&'static str> for Srv2 {
type Request = &'static str;
type Response = (&'static str, &'static str); type Response = (&'static str, &'static str);
type Error = (); type Error = ();
type Future = FutureResult<Self::Response, ()>; type Future = FutureResult<Self::Response, ()>;
@ -255,7 +249,7 @@ mod tests {
Ok(Async::Ready(())) Ok(Async::Ready(()))
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: &'static str) -> Self::Future {
ok((req, "srv2")) ok((req, "srv2"))
} }
} }

View File

@ -5,21 +5,23 @@ use futures::{Async, Future, IntoFuture, Poll};
use super::{IntoNewService, IntoService, NewService, Service}; use super::{IntoNewService, IntoService, NewService, Service};
/// `Apply` service combinator /// `Apply` service combinator
pub struct Apply<T, F, R, Req> { pub struct Apply<T, F, In, Out, Request>
where
T: Service<Request>,
{
service: T, service: T,
f: F, f: F,
r: PhantomData<(Req, R)>, r: PhantomData<(In, Out, Request)>,
} }
impl<T, F, R, Req> Apply<T, F, R, Req> impl<T, F, In, Out, Request> Apply<T, F, In, Out, Request>
where where
T: Service, T: Service<Request>,
T::Error: Into<<R::Future as Future>::Error>, F: Fn(In, &mut T) -> Out,
F: Fn(Req, &mut T) -> R, Out: IntoFuture,
R: IntoFuture,
{ {
/// Create new `Apply` combinator /// Create new `Apply` combinator
pub fn new<I: IntoService<T>>(service: I, f: F) -> Self { pub fn new<I: IntoService<T, Request>>(service: I, f: F) -> Self {
Self { Self {
service: service.into_service(), service: service.into_service(),
f, f,
@ -28,12 +30,10 @@ where
} }
} }
impl<T, F, R, Req> Clone for Apply<T, F, R, Req> impl<T, F, In, Out, Request> Clone for Apply<T, F, In, Out, Request>
where where
T: Service + Clone, T: Service<Request> + Clone,
T::Error: Into<<R::Future as Future>::Error>, F: Clone,
F: Fn(Req, &mut T) -> R + Clone,
R: IntoFuture,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Apply { Apply {
@ -44,42 +44,43 @@ where
} }
} }
impl<T, F, R, Req> Service for Apply<T, F, R, Req> impl<T, F, In, Out, Request> Service<In> for Apply<T, F, In, Out, Request>
where where
T: Service, T: Service<Request, Error = Out::Error>,
T::Error: Into<<R::Future as Future>::Error>, F: Fn(In, &mut T) -> Out,
F: Fn(Req, &mut T) -> R, Out: IntoFuture,
R: IntoFuture,
{ {
type Request = Req; type Response = Out::Item;
type Response = <R::Future as Future>::Item; type Error = Out::Error;
type Error = <R::Future as Future>::Error; type Future = Out::Future;
type Future = R::Future;
fn poll_ready(&mut self) -> Poll<(), Self::Error> { fn poll_ready(&mut self) -> Poll<(), Self::Error> {
self.service.poll_ready().map_err(|e| e.into()) self.service.poll_ready()
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: In) -> Self::Future {
(self.f)(req, &mut self.service).into_future() (self.f)(req, &mut self.service).into_future()
} }
} }
/// `ApplyNewService` new service combinator /// `ApplyNewService` new service combinator
pub struct ApplyNewService<T, F, R, Req> { pub struct ApplyNewService<T, F, In, Out, Request>
where
T: NewService<Request>,
{
service: T, service: T,
f: F, f: F,
r: PhantomData<Fn(Req) -> R>, r: PhantomData<(In, Out, Request)>,
} }
impl<T, F, R, Req> ApplyNewService<T, F, R, Req> impl<T, F, In, Out, Request> ApplyNewService<T, F, In, Out, Request>
where where
T: NewService, T: NewService<Request>,
F: Fn(Req, &mut T::Service) -> R, F: Fn(In, &mut T::Service) -> Out,
R: IntoFuture, Out: IntoFuture,
{ {
/// Create new `ApplyNewService` new service instance /// Create new `ApplyNewService` new service instance
pub fn new<F1: IntoNewService<T>>(service: F1, f: F) -> Self { pub fn new<F1: IntoNewService<T, Request>>(service: F1, f: F) -> Self {
Self { Self {
f, f,
service: service.into_new_service(), service: service.into_new_service(),
@ -88,11 +89,11 @@ where
} }
} }
impl<T, F, R, Req> Clone for ApplyNewService<T, F, R, Req> impl<T, F, In, Out, Request> Clone for ApplyNewService<T, F, In, Out, Request>
where where
T: NewService + Clone, T: NewService<Request> + Clone,
F: Fn(Req, &mut T::Service) -> R + Clone, F: Fn(Out, &mut T::Service) -> Out + Clone,
R: IntoFuture, Out: IntoFuture,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -103,42 +104,40 @@ where
} }
} }
impl<T, F, R, Req> NewService for ApplyNewService<T, F, R, Req> impl<T, F, In, Out, Request> NewService<In> for ApplyNewService<T, F, In, Out, Request>
where where
T: NewService, T: NewService<Request, Error = Out::Error>,
T::Error: Into<<R::Future as Future>::Error>, F: Fn(In, &mut T::Service) -> Out + Clone,
F: Fn(Req, &mut T::Service) -> R + Clone, Out: IntoFuture,
R: IntoFuture,
{ {
type Request = Req; type Response = Out::Item;
type Response = <R::Future as Future>::Item; type Error = Out::Error;
type Error = <R::Future as Future>::Error; type Service = Apply<T::Service, F, In, Out, Request>;
type Service = Apply<T::Service, F, R, Req>;
type InitError = T::InitError; type InitError = T::InitError;
type Future = ApplyNewServiceFuture<T, F, R, Req>; type Future = ApplyNewServiceFuture<T, F, In, Out, Request>;
fn new_service(&self) -> Self::Future { fn new_service(&self) -> Self::Future {
ApplyNewServiceFuture::new(self.service.new_service(), self.f.clone()) ApplyNewServiceFuture::new(self.service.new_service(), self.f.clone())
} }
} }
pub struct ApplyNewServiceFuture<T, F, R, Req> pub struct ApplyNewServiceFuture<T, F, In, Out, Request>
where where
T: NewService, T: NewService<Request>,
F: Fn(Req, &mut T::Service) -> R, F: Fn(In, &mut T::Service) -> Out,
R: IntoFuture, Out: IntoFuture,
{ {
fut: T::Future, fut: T::Future,
f: Option<F>, f: Option<F>,
r: PhantomData<Fn(Req) -> R>, r: PhantomData<(In, Out)>,
} }
impl<T, F, R, Req> ApplyNewServiceFuture<T, F, R, Req> impl<T, F, In, Out, Request> ApplyNewServiceFuture<T, F, In, Out, Request>
where where
T: NewService, T: NewService<Request>,
F: Fn(Req, &mut T::Service) -> R, F: Fn(In, &mut T::Service) -> Out,
R: IntoFuture, Out: IntoFuture,
{ {
fn new(fut: T::Future, f: F) -> Self { fn new(fut: T::Future, f: F) -> Self {
ApplyNewServiceFuture { ApplyNewServiceFuture {
@ -149,14 +148,13 @@ where
} }
} }
impl<T, F, R, Req> Future for ApplyNewServiceFuture<T, F, R, Req> impl<T, F, In, Out, Request> Future for ApplyNewServiceFuture<T, F, In, Out, Request>
where where
T: NewService, T: NewService<Request>,
T::Error: Into<<R::Future as Future>::Error>, F: Fn(In, &mut T::Service) -> Out,
F: Fn(Req, &mut T::Service) -> R, Out: IntoFuture,
R: IntoFuture,
{ {
type Item = Apply<T::Service, F, R, Req>; type Item = Apply<T::Service, F, In, Out, Request>;
type Error = T::InitError; type Error = T::InitError;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> { fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@ -173,14 +171,11 @@ mod tests {
use futures::future::{ok, FutureResult}; use futures::future::{ok, FutureResult};
use futures::{Async, Future, Poll}; use futures::{Async, Future, Poll};
use service::{ use crate::{IntoNewService, IntoService, NewService, Service};
IntoNewService, IntoService, NewService, NewServiceExt, Service, ServiceExt,
};
#[derive(Clone)] #[derive(Clone)]
struct Srv; struct Srv;
impl Service for Srv { impl Service<()> for Srv {
type Request = ();
type Response = (); type Response = ();
type Error = (); type Error = ();
type Future = FutureResult<(), ()>; type Future = FutureResult<(), ()>;

32
actix-service/src/cell.rs Normal file
View File

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

View File

@ -42,12 +42,11 @@ where
} }
} }
impl<F, Req, Resp, E, Fut> Service for FnService<F, Req, Resp, E, Fut> impl<F, Req, Resp, E, Fut> Service<Req> for FnService<F, Req, Resp, E, Fut>
where where
F: Fn(Req) -> Fut, F: Fn(Req) -> Fut,
Fut: IntoFuture<Item = Resp, Error = E>, Fut: IntoFuture<Item = Resp, Error = E>,
{ {
type Request = Req;
type Response = Resp; type Response = Resp;
type Error = E; type Error = E;
type Future = Fut::Future; type Future = Fut::Future;
@ -61,7 +60,7 @@ where
} }
} }
impl<F, Req, Resp, Err, Fut> IntoService<FnService<F, Req, Resp, Err, Fut>> for F impl<F, Req, Resp, Err, Fut> IntoService<FnService<F, Req, Resp, Err, Fut>, Req> for F
where where
F: Fn(Req) -> Fut + 'static, F: Fn(Req) -> Fut + 'static,
Fut: IntoFuture<Item = Resp, Error = Err>, Fut: IntoFuture<Item = Resp, Error = Err>,
@ -93,12 +92,11 @@ where
} }
} }
impl<F, Req, Resp, Err, Fut> NewService for FnNewService<F, Req, Resp, Err, Fut> impl<F, Req, Resp, Err, Fut> NewService<Req> for FnNewService<F, Req, Resp, Err, Fut>
where where
F: Fn(Req) -> Fut + Clone, F: Fn(Req) -> Fut + Clone,
Fut: IntoFuture<Item = Resp, Error = Err>, Fut: IntoFuture<Item = Resp, Error = Err>,
{ {
type Request = Req;
type Response = Resp; type Response = Resp;
type Error = Err; type Error = Err;
type Service = FnService<F, Req, Resp, Err, Fut>; type Service = FnService<F, Req, Resp, Err, Fut>;
@ -110,7 +108,7 @@ where
} }
} }
impl<F, Req, Resp, Err, Fut> IntoNewService<FnNewService<F, Req, Resp, Err, Fut>> for F impl<F, Req, Resp, Err, Fut> IntoNewService<FnNewService<F, Req, Resp, Err, Fut>, Req> for F
where where
F: Fn(Req) -> Fut + Clone + 'static, F: Fn(Req) -> Fut + Clone + 'static,
Fut: IntoFuture<Item = Resp, Error = Err>, Fut: IntoFuture<Item = Resp, Error = Err>,

View File

@ -7,16 +7,17 @@ use super::{NewService, Service};
/// Service for the `from_err` combinator, changing the error type of a service. /// Service for the `from_err` combinator, changing the error type of a service.
/// ///
/// This is created by the `ServiceExt::from_err` method. /// This is created by the `ServiceExt::from_err` method.
pub struct FromErr<A, E> pub struct FromErr<A, E> {
where
A: Service,
{
service: A, service: A,
f: PhantomData<E>, f: PhantomData<E>,
} }
impl<A: Service, E: From<A::Error>> FromErr<A, E> { impl<A, E> FromErr<A, E> {
pub(crate) fn new(service: A) -> Self { pub(crate) fn new<Request>(service: A) -> Self
where
A: Service<Request>,
E: From<A::Error>,
{
FromErr { FromErr {
service, service,
f: PhantomData, f: PhantomData,
@ -26,8 +27,7 @@ impl<A: Service, E: From<A::Error>> FromErr<A, E> {
impl<A, E> Clone for FromErr<A, E> impl<A, E> Clone for FromErr<A, E>
where where
A: Service + Clone, A: Clone,
E: From<A::Error>,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
FromErr { FromErr {
@ -37,21 +37,20 @@ where
} }
} }
impl<A, E> Service for FromErr<A, E> impl<A, E, Request> Service<Request> for FromErr<A, E>
where where
A: Service, A: Service<Request>,
E: From<A::Error>, E: From<A::Error>,
{ {
type Request = A::Request;
type Response = A::Response; type Response = A::Response;
type Error = E; type Error = E;
type Future = FromErrFuture<A, E>; type Future = FromErrFuture<A, E, Request>;
fn poll_ready(&mut self) -> Poll<(), E> { fn poll_ready(&mut self) -> Poll<(), E> {
Ok(self.service.poll_ready().map_err(E::from)?) Ok(self.service.poll_ready().map_err(E::from)?)
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: Request) -> Self::Future {
FromErrFuture { FromErrFuture {
fut: self.service.call(req), fut: self.service.call(req),
f: PhantomData, f: PhantomData,
@ -59,14 +58,14 @@ where
} }
} }
pub struct FromErrFuture<A: Service, E> { pub struct FromErrFuture<A: Service<Request>, E, Request> {
fut: A::Future, fut: A::Future,
f: PhantomData<E>, f: PhantomData<E>,
} }
impl<A, E> Future for FromErrFuture<A, E> impl<A, E, Request> Future for FromErrFuture<A, E, Request>
where where
A: Service, A: Service<Request>,
E: From<A::Error>, E: From<A::Error>,
{ {
type Item = A::Response; type Item = A::Response;
@ -86,21 +85,20 @@ pub struct FromErrNewService<A, E> {
e: PhantomData<E>, e: PhantomData<E>,
} }
impl<A, E> FromErrNewService<A, E> impl<A, E> FromErrNewService<A, E> {
where
A: NewService,
E: From<A::Error>,
{
/// Create new `FromErr` new service instance /// Create new `FromErr` new service instance
pub fn new(a: A) -> Self { pub fn new<Request>(a: A) -> Self
where
A: NewService<Request>,
E: From<A::Error>,
{
Self { a, e: PhantomData } Self { a, e: PhantomData }
} }
} }
impl<A, E> Clone for FromErrNewService<A, E> impl<A, E> Clone for FromErrNewService<A, E>
where where
A: NewService + Clone, A: Clone,
E: From<A::Error>,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -110,18 +108,17 @@ where
} }
} }
impl<A, E> NewService for FromErrNewService<A, E> impl<A, E, Request> NewService<Request> for FromErrNewService<A, E>
where where
A: NewService, A: NewService<Request>,
E: From<A::Error>, E: From<A::Error>,
{ {
type Request = A::Request;
type Response = A::Response; type Response = A::Response;
type Error = E; type Error = E;
type Service = FromErr<A::Service, E>; type Service = FromErr<A::Service, E>;
type InitError = A::InitError; type InitError = A::InitError;
type Future = FromErrNewServiceFuture<A, E>; type Future = FromErrNewServiceFuture<A, E, Request>;
fn new_service(&self) -> Self::Future { fn new_service(&self) -> Self::Future {
FromErrNewServiceFuture { FromErrNewServiceFuture {
@ -131,18 +128,18 @@ where
} }
} }
pub struct FromErrNewServiceFuture<A, E> pub struct FromErrNewServiceFuture<A, E, Request>
where where
A: NewService, A: NewService<Request>,
E: From<A::Error>, E: From<A::Error>,
{ {
fut: A::Future, fut: A::Future,
e: PhantomData<E>, e: PhantomData<E>,
} }
impl<A, E> Future for FromErrNewServiceFuture<A, E> impl<A, E, Request> Future for FromErrNewServiceFuture<A, E, Request>
where where
A: NewService, A: NewService<Request>,
E: From<A::Error>, E: From<A::Error>,
{ {
type Item = FromErr<A::Service, E>; type Item = FromErr<A::Service, E>;
@ -162,11 +159,10 @@ mod tests {
use futures::future::{err, FutureResult}; use futures::future::{err, FutureResult};
use super::*; use super::*;
use service::{IntoNewService, NewServiceExt, Service, ServiceExt}; use crate::{IntoNewService, NewService, Service};
struct Srv; struct Srv;
impl Service for Srv { impl Service<()> for Srv {
type Request = ();
type Response = (); type Response = ();
type Error = (); type Error = ();
type Future = FutureResult<(), ()>; type Future = FutureResult<(), ()>;

View File

@ -1,10 +1,7 @@
use futures::{Future, IntoFuture}; use futures::{Future, IntoFuture, Poll};
/// re-export for convinience
pub use tower_service::{NewService, Service};
mod and_then; mod and_then;
mod apply; mod apply;
mod cell;
mod fn_service; mod fn_service;
mod from_err; mod from_err;
mod map; mod map;
@ -21,23 +18,52 @@ pub use self::map_err::{MapErr, MapErrNewService};
pub use self::map_init_err::MapInitErr; pub use self::map_init_err::MapInitErr;
pub use self::then::{Then, ThenNewService}; pub use self::then::{Then, ThenNewService};
/// An extension trait for `Service`s that provides a variety of convenient /// An asynchronous function from `Request` to a `Response`.
/// adapters pub trait Service<Request> {
pub trait ServiceExt: Service { /// Responses given by the service.
type Response;
/// Errors produced by the service.
type Error;
/// The future response value.
type Future: Future<Item = Self::Response, Error = Self::Error>;
/// Returns `Ready` when the service is able to process requests.
///
/// 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: Request) -> Self::Future;
/// Apply function to specified service and use it as a next service in /// Apply function to specified service and use it as a next service in
/// chain. /// chain.
fn apply<S, I, F, R>( fn apply<T, I, F, Out, Req>(
self, self,
service: I, service: I,
f: F, f: F,
) -> AndThen<Self, Apply<S, F, R, Self::Response>> ) -> AndThen<Self, Apply<T, F, Self::Response, Out, Req>>
where where
Self: Sized, Self: Sized,
S: Service, T: Service<Req, Error = Self::Error>,
S::Error: Into<<R::Future as Future>::Error>, I: IntoService<T, Req>,
I: IntoService<S>, F: Fn(Self::Response, &mut T) -> Out,
F: Fn(Self::Response, &mut S) -> R, Out: IntoFuture<Error = Self::Error>,
R: IntoFuture<Error = Self::Error>,
{ {
self.and_then(Apply::new(service.into_service(), f)) self.and_then(Apply::new(service.into_service(), f))
} }
@ -54,8 +80,8 @@ pub trait ServiceExt: Service {
fn and_then<F, B>(self, service: F) -> AndThen<Self, B> fn and_then<F, B>(self, service: F) -> AndThen<Self, B>
where where
Self: Sized, Self: Sized,
F: IntoService<B>, F: IntoService<B, Self::Response>,
B: Service<Request = Self::Response, Error = Self::Error>, B: Service<Self::Response, Error = Self::Error>,
{ {
AndThen::new(self, service.into_service()) AndThen::new(self, service.into_service())
} }
@ -76,12 +102,12 @@ pub trait ServiceExt: Service {
/// Chain on a computation for when a call to the service finished, /// Chain on a computation for when a call to the service finished,
/// passing the result of the call to the next service `B`. /// passing the result of the call to the next service `B`.
/// ///
/// Note that this function consumes the receiving future and returns a /// Note that this function consumes the receiving service and returns a
/// wrapped version of it. /// wrapped version of it.
fn then<B>(self, service: B) -> Then<Self, B> fn then<B>(self, service: B) -> Then<Self, B>
where where
Self: Sized, Self: Sized,
B: Service<Request = Result<Self::Response, Self::Error>, Error = Self::Error>, B: Service<Result<Self::Response, Self::Error>, Error = Self::Error>,
{ {
Then::new(self, service) Then::new(self, service)
} }
@ -120,32 +146,57 @@ pub trait ServiceExt: Service {
} }
} }
pub trait NewServiceExt: NewService { /// Creates new `Service` values.
fn apply<S, I, F, R>( ///
/// 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.
///
/// Request - request handled by the service
pub trait NewService<Request> {
/// Responses given by the service
type Response;
/// Errors produced by the service
type Error;
/// The `Service` value created by this factory
type Service: Service<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) -> Self::Future;
/// Apply function to specified service and use it as a next service in
/// chain.
fn apply<T, I, F, Out, Req>(
self, self,
service: I, service: I,
f: F, f: F,
) -> AndThenNewService<Self, ApplyNewService<S, F, R, Self::Response>> ) -> AndThenNewService<Self, ApplyNewService<T, F, Self::Response, Out, Req>>
where where
Self: Sized, Self: Sized,
S: NewService<InitError = Self::InitError>, T: NewService<Req, InitError = Self::InitError, Error = Self::Error>,
S::Error: Into<<R::Future as Future>::Error>, I: IntoNewService<T, Req>,
I: IntoNewService<S>, F: Fn(Self::Response, &mut T::Service) -> Out + Clone,
F: Fn(Self::Response, &mut S::Service) -> R + Clone, Out: IntoFuture<Error = Self::Error>,
R: IntoFuture<Error = Self::Error>,
{ {
self.and_then(ApplyNewService::new(service, f)) self.and_then(ApplyNewService::new(service, f))
} }
/// Call another service after call to this one has resolved successfully.
fn and_then<F, B>(self, new_service: F) -> AndThenNewService<Self, B> fn and_then<F, B>(self, new_service: F) -> AndThenNewService<Self, B>
where where
Self: Sized, Self: Sized,
F: IntoNewService<B>, F: IntoNewService<B, Self::Response>,
B: NewService< B: NewService<Self::Response, Error = Self::Error, InitError = Self::InitError>,
Request = Self::Response,
Error = Self::Error,
InitError = Self::InitError,
>,
{ {
AndThenNewService::new(self, new_service) AndThenNewService::new(self, new_service)
} }
@ -173,9 +224,9 @@ pub trait NewServiceExt: NewService {
fn then<F, B>(self, new_service: F) -> ThenNewService<Self, B> fn then<F, B>(self, new_service: F) -> ThenNewService<Self, B>
where where
Self: Sized, Self: Sized,
F: IntoNewService<B>, F: IntoNewService<B, Result<Self::Response, Self::Error>>,
B: NewService< B: NewService<
Request = Result<Self::Response, Self::Error>, Result<Self::Response, Self::Error>,
Error = Self::Error, Error = Self::Error,
InitError = Self::InitError, InitError = Self::InitError,
>, >,
@ -183,6 +234,8 @@ pub trait NewServiceExt: NewService {
ThenNewService::new(self, new_service) 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> fn map<F, R>(self, f: F) -> MapNewService<Self, F, R>
where where
Self: Sized, Self: Sized,
@ -191,6 +244,7 @@ pub trait NewServiceExt: NewService {
MapNewService::new(self, f) MapNewService::new(self, f)
} }
/// Map this service's error to a different error, returning a new service.
fn map_err<F, E>(self, f: F) -> MapErrNewService<Self, F, E> fn map_err<F, E>(self, f: F) -> MapErrNewService<Self, F, E>
where where
Self: Sized, Self: Sized,
@ -199,6 +253,7 @@ pub trait NewServiceExt: NewService {
MapErrNewService::new(self, f) MapErrNewService::new(self, f)
} }
/// Map this service's init error to a different error, returning a new service.
fn map_init_err<F, E>(self, f: F) -> MapInitErr<Self, F, E> fn map_init_err<F, E>(self, f: F) -> MapInitErr<Self, F, E>
where where
Self: Sized, Self: Sized,
@ -208,39 +263,87 @@ pub trait NewServiceExt: NewService {
} }
} }
impl<T: ?Sized> ServiceExt for T where T: Service {} impl<'a, S, Request> Service<Request> for &'a mut S
impl<T: ?Sized> NewServiceExt for T where T: NewService {} where
S: Service<Request> + 'a,
{
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: Request) -> S::Future {
(**self).call(request)
}
}
impl<S, Request> Service<Request> for Box<S>
where
S: Service<Request> + ?Sized,
{
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: Request) -> S::Future {
(**self).call(request)
}
}
impl<F, R, E, S, Request> NewService<Request> for F
where
F: Fn() -> R,
R: IntoFuture<Item = S, Error = E>,
S: Service<Request>,
{
type Response = S::Response;
type Error = S::Error;
type Service = S;
type InitError = E;
type Future = R::Future;
fn new_service(&self) -> Self::Future {
(*self)().into_future()
}
}
/// Trait for types that can be converted to a `Service` /// Trait for types that can be converted to a `Service`
pub trait IntoService<T> pub trait IntoService<T, Request>
where where
T: Service, T: Service<Request>,
{ {
/// Convert to a `Service` /// Convert to a `Service`
fn into_service(self) -> T; fn into_service(self) -> T;
} }
/// Trait for types that can be converted to a Service /// Trait for types that can be converted to a Service
pub trait IntoNewService<T> pub trait IntoNewService<T, Request>
where where
T: NewService, T: NewService<Request>,
{ {
/// Convert to an `NewService` /// Convert to an `NewService`
fn into_new_service(self) -> T; fn into_new_service(self) -> T;
} }
impl<T> IntoService<T> for T impl<T, Request> IntoService<T, Request> for T
where where
T: Service, T: Service<Request>,
{ {
fn into_service(self) -> T { fn into_service(self) -> T {
self self
} }
} }
impl<T> IntoNewService<T> for T impl<T, Request> IntoNewService<T, Request> for T
where where
T: NewService, T: NewService<Request>,
{ {
fn into_new_service(self) -> T { fn into_new_service(self) -> T {
self self

View File

@ -1,4 +1,4 @@
use std::marker; use std::marker::PhantomData;
use futures::{Async, Future, Poll}; use futures::{Async, Future, Poll};
@ -7,83 +7,84 @@ use super::{NewService, Service};
/// Service for the `map` combinator, changing the type of a service's response. /// Service for the `map` combinator, changing the type of a service's response.
/// ///
/// This is created by the `ServiceExt::map` method. /// This is created by the `ServiceExt::map` method.
pub struct Map<A, F, R> pub struct Map<A, F, Response> {
where
A: Service,
F: Fn(A::Response) -> R,
{
service: A, service: A,
f: F, f: F,
_t: PhantomData<Response>,
} }
impl<A, F, R> Map<A, F, R> impl<A, F, Response> Map<A, F, Response> {
where
A: Service,
F: Fn(A::Response) -> R,
{
/// Create new `Map` combinator /// Create new `Map` combinator
pub fn new(service: A, f: F) -> Self { pub fn new<Request>(service: A, f: F) -> Self
Self { service, f } where
A: Service<Request>,
F: Fn(A::Response) -> Response,
{
Self {
service,
f,
_t: PhantomData,
}
} }
} }
impl<A, F, R> Clone for Map<A, F, R> impl<A, F, Response> Clone for Map<A, F, Response>
where where
A: Service + Clone, A: Clone,
F: Fn(A::Response) -> R + Clone, F: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Map { Map {
service: self.service.clone(), service: self.service.clone(),
f: self.f.clone(), f: self.f.clone(),
_t: PhantomData,
} }
} }
} }
impl<A, F, R> Service for Map<A, F, R> impl<A, F, Request, Response> Service<Request> for Map<A, F, Response>
where where
A: Service, A: Service<Request>,
F: Fn(A::Response) -> R + Clone, F: Fn(A::Response) -> Response + Clone,
{ {
type Request = A::Request; type Response = Response;
type Response = R;
type Error = A::Error; type Error = A::Error;
type Future = MapFuture<A, F, R>; type Future = MapFuture<A, F, Request, Response>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> { fn poll_ready(&mut self) -> Poll<(), Self::Error> {
self.service.poll_ready() self.service.poll_ready()
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: Request) -> Self::Future {
MapFuture::new(self.service.call(req), self.f.clone()) MapFuture::new(self.service.call(req), self.f.clone())
} }
} }
pub struct MapFuture<A, F, R> pub struct MapFuture<A, F, Request, Response>
where where
A: Service, A: Service<Request>,
F: Fn(A::Response) -> R, F: Fn(A::Response) -> Response,
{ {
f: F, f: F,
fut: A::Future, fut: A::Future,
} }
impl<A, F, R> MapFuture<A, F, R> impl<A, F, Request, Response> MapFuture<A, F, Request, Response>
where where
A: Service, A: Service<Request>,
F: Fn(A::Response) -> R, F: Fn(A::Response) -> Response,
{ {
fn new(fut: A::Future, f: F) -> Self { fn new(fut: A::Future, f: F) -> Self {
MapFuture { f, fut } MapFuture { f, fut }
} }
} }
impl<A, F, R> Future for MapFuture<A, F, R> impl<A, F, Request, Response> Future for MapFuture<A, F, Request, Response>
where where
A: Service, A: Service<Request>,
F: Fn(A::Response) -> R, F: Fn(A::Response) -> Response,
{ {
type Item = R; type Item = Response;
type Error = A::Error; type Error = A::Error;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> { fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@ -95,84 +96,83 @@ where
} }
/// `MapNewService` new service combinator /// `MapNewService` new service combinator
pub struct MapNewService<A, F, R> { pub struct MapNewService<A, F, Response> {
a: A, a: A,
f: F, f: F,
r: marker::PhantomData<R>, r: PhantomData<Response>,
} }
impl<A, F, R> MapNewService<A, F, R> impl<A, F, Response> MapNewService<A, F, Response> {
where
A: NewService,
F: Fn(A::Response) -> R,
{
/// Create new `Map` new service instance /// Create new `Map` new service instance
pub fn new(a: A, f: F) -> Self { pub fn new<Request>(a: A, f: F) -> Self
where
A: NewService<Request>,
F: Fn(A::Response) -> Response,
{
Self { Self {
a, a,
f, f,
r: marker::PhantomData, r: PhantomData,
} }
} }
} }
impl<A, F, R> Clone for MapNewService<A, F, R> impl<A, F, Response> Clone for MapNewService<A, F, Response>
where where
A: NewService + Clone, A: Clone,
F: Fn(A::Response) -> R + Clone, F: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
a: self.a.clone(), a: self.a.clone(),
f: self.f.clone(), f: self.f.clone(),
r: marker::PhantomData, r: PhantomData,
} }
} }
} }
impl<A, F, R> NewService for MapNewService<A, F, R> impl<A, F, Request, Response> NewService<Request> for MapNewService<A, F, Response>
where where
A: NewService, A: NewService<Request>,
F: Fn(A::Response) -> R + Clone, F: Fn(A::Response) -> Response + Clone,
{ {
type Request = A::Request; type Response = Response;
type Response = R;
type Error = A::Error; type Error = A::Error;
type Service = Map<A::Service, F, R>; type Service = Map<A::Service, F, Response>;
type InitError = A::InitError; type InitError = A::InitError;
type Future = MapNewServiceFuture<A, F, R>; type Future = MapNewServiceFuture<A, F, Request, Response>;
fn new_service(&self) -> Self::Future { fn new_service(&self) -> Self::Future {
MapNewServiceFuture::new(self.a.new_service(), self.f.clone()) MapNewServiceFuture::new(self.a.new_service(), self.f.clone())
} }
} }
pub struct MapNewServiceFuture<A, F, R> pub struct MapNewServiceFuture<A, F, Request, Response>
where where
A: NewService, A: NewService<Request>,
F: Fn(A::Response) -> R, F: Fn(A::Response) -> Response,
{ {
fut: A::Future, fut: A::Future,
f: Option<F>, f: Option<F>,
} }
impl<A, F, R> MapNewServiceFuture<A, F, R> impl<A, F, Request, Response> MapNewServiceFuture<A, F, Request, Response>
where where
A: NewService, A: NewService<Request>,
F: Fn(A::Response) -> R, F: Fn(A::Response) -> Response,
{ {
fn new(fut: A::Future, f: F) -> Self { fn new(fut: A::Future, f: F) -> Self {
MapNewServiceFuture { f: Some(f), fut } MapNewServiceFuture { f: Some(f), fut }
} }
} }
impl<A, F, R> Future for MapNewServiceFuture<A, F, R> impl<A, F, Request, Response> Future for MapNewServiceFuture<A, F, Request, Response>
where where
A: NewService, A: NewService<Request>,
F: Fn(A::Response) -> R, F: Fn(A::Response) -> Response,
{ {
type Item = Map<A::Service, F, R>; type Item = Map<A::Service, F, Response>;
type Error = A::InitError; type Error = A::InitError;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> { fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@ -189,11 +189,10 @@ mod tests {
use futures::future::{ok, FutureResult}; use futures::future::{ok, FutureResult};
use super::*; use super::*;
use service::{IntoNewService, NewServiceExt, Service, ServiceExt}; use crate::{IntoNewService, Service};
struct Srv; struct Srv;
impl Service for Srv { impl Service<()> for Srv {
type Request = ();
type Response = (); type Response = ();
type Error = (); type Error = ();
type Future = FutureResult<(), ()>; type Future = FutureResult<(), ()>;

View File

@ -1,4 +1,4 @@
use std::marker; use std::marker::PhantomData;
use futures::{Async, Future, Poll}; use futures::{Async, Future, Poll};
@ -8,71 +8,71 @@ use super::{NewService, Service};
/// error. /// error.
/// ///
/// This is created by the `ServiceExt::map_err` method. /// This is created by the `ServiceExt::map_err` method.
pub struct MapErr<A, F, E> pub struct MapErr<A, F, E> {
where
A: Service,
F: Fn(A::Error) -> E,
{
service: A, service: A,
f: F, f: F,
_t: PhantomData<E>,
} }
impl<A, F, E> MapErr<A, F, E> impl<A, F, E> MapErr<A, F, E> {
where
A: Service,
F: Fn(A::Error) -> E,
{
/// Create new `MapErr` combinator /// Create new `MapErr` combinator
pub fn new(service: A, f: F) -> Self { pub fn new<Request>(service: A, f: F) -> Self
Self { service, f } where
A: Service<Request>,
F: Fn(A::Error) -> E,
{
Self {
service,
f,
_t: PhantomData,
}
} }
} }
impl<A, F, E> Clone for MapErr<A, F, E> impl<A, F, E> Clone for MapErr<A, F, E>
where where
A: Service + Clone, A: Clone,
F: Fn(A::Error) -> E + Clone, F: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
MapErr { MapErr {
service: self.service.clone(), service: self.service.clone(),
f: self.f.clone(), f: self.f.clone(),
_t: PhantomData,
} }
} }
} }
impl<A, F, E> Service for MapErr<A, F, E> impl<A, F, E, Request> Service<Request> for MapErr<A, F, E>
where where
A: Service, A: Service<Request>,
F: Fn(A::Error) -> E, F: Fn(A::Error) -> E + Clone,
F: Clone,
{ {
type Request = A::Request;
type Response = A::Response; type Response = A::Response;
type Error = E; type Error = E;
type Future = MapErrFuture<A, F, E>; type Future = MapErrFuture<A, F, E, Request>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> { fn poll_ready(&mut self) -> Poll<(), Self::Error> {
self.service.poll_ready().map_err(&self.f) self.service.poll_ready().map_err(&self.f)
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: Request) -> Self::Future {
MapErrFuture::new(self.service.call(req), self.f.clone()) MapErrFuture::new(self.service.call(req), self.f.clone())
} }
} }
pub struct MapErrFuture<A, F, E> pub struct MapErrFuture<A, F, E, Request>
where where
A: Service, A: Service<Request>,
F: Fn(A::Error) -> E, F: Fn(A::Error) -> E,
{ {
f: F, f: F,
fut: A::Future, fut: A::Future,
} }
impl<A, F, E> MapErrFuture<A, F, E> impl<A, F, E, Request> MapErrFuture<A, F, E, Request>
where where
A: Service, A: Service<Request>,
F: Fn(A::Error) -> E, F: Fn(A::Error) -> E,
{ {
fn new(fut: A::Future, f: F) -> Self { fn new(fut: A::Future, f: F) -> Self {
@ -80,9 +80,9 @@ where
} }
} }
impl<A, F, E> Future for MapErrFuture<A, F, E> impl<A, F, E, Request> Future for MapErrFuture<A, F, E, Request>
where where
A: Service, A: Service<Request>,
F: Fn(A::Error) -> E, F: Fn(A::Error) -> E,
{ {
type Item = A::Response; type Item = A::Response;
@ -100,68 +100,67 @@ where
pub struct MapErrNewService<A, F, E> { pub struct MapErrNewService<A, F, E> {
a: A, a: A,
f: F, f: F,
e: marker::PhantomData<E>, e: PhantomData<E>,
} }
impl<A, F, E> MapErrNewService<A, F, E> impl<A, F, E> MapErrNewService<A, F, E> {
where
A: NewService,
F: Fn(A::Error) -> E,
{
/// Create new `MapErr` new service instance /// Create new `MapErr` new service instance
pub fn new(a: A, f: F) -> Self { pub fn new<Request>(a: A, f: F) -> Self
where
A: NewService<Request>,
F: Fn(A::Error) -> E,
{
Self { Self {
a, a,
f, f,
e: marker::PhantomData, e: PhantomData,
} }
} }
} }
impl<A, F, E> Clone for MapErrNewService<A, F, E> impl<A, F, E> Clone for MapErrNewService<A, F, E>
where where
A: NewService + Clone, A: Clone,
F: Fn(A::Error) -> E + Clone, F: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
a: self.a.clone(), a: self.a.clone(),
f: self.f.clone(), f: self.f.clone(),
e: marker::PhantomData, e: PhantomData,
} }
} }
} }
impl<A, F, E> NewService for MapErrNewService<A, F, E> impl<A, F, E, Request> NewService<Request> for MapErrNewService<A, F, E>
where where
A: NewService, A: NewService<Request>,
F: Fn(A::Error) -> E + Clone, F: Fn(A::Error) -> E + Clone,
{ {
type Request = A::Request;
type Response = A::Response; type Response = A::Response;
type Error = E; type Error = E;
type Service = MapErr<A::Service, F, E>; type Service = MapErr<A::Service, F, E>;
type InitError = A::InitError; type InitError = A::InitError;
type Future = MapErrNewServiceFuture<A, F, E>; type Future = MapErrNewServiceFuture<A, F, E, Request>;
fn new_service(&self) -> Self::Future { fn new_service(&self) -> Self::Future {
MapErrNewServiceFuture::new(self.a.new_service(), self.f.clone()) MapErrNewServiceFuture::new(self.a.new_service(), self.f.clone())
} }
} }
pub struct MapErrNewServiceFuture<A, F, E> pub struct MapErrNewServiceFuture<A, F, E, Request>
where where
A: NewService, A: NewService<Request>,
F: Fn(A::Error) -> E, F: Fn(A::Error) -> E,
{ {
fut: A::Future, fut: A::Future,
f: F, f: F,
} }
impl<A, F, E> MapErrNewServiceFuture<A, F, E> impl<A, F, E, Request> MapErrNewServiceFuture<A, F, E, Request>
where where
A: NewService, A: NewService<Request>,
F: Fn(A::Error) -> E, F: Fn(A::Error) -> E,
{ {
fn new(fut: A::Future, f: F) -> Self { fn new(fut: A::Future, f: F) -> Self {
@ -169,9 +168,9 @@ where
} }
} }
impl<A, F, E> Future for MapErrNewServiceFuture<A, F, E> impl<A, F, E, Request> Future for MapErrNewServiceFuture<A, F, E, Request>
where where
A: NewService, A: NewService<Request>,
F: Fn(A::Error) -> E + Clone, F: Fn(A::Error) -> E + Clone,
{ {
type Item = MapErr<A::Service, F, E>; type Item = MapErr<A::Service, F, E>;
@ -191,12 +190,11 @@ mod tests {
use futures::future::{err, FutureResult}; use futures::future::{err, FutureResult};
use super::*; use super::*;
use service::{IntoNewService, NewServiceExt, Service, ServiceExt}; use crate::{IntoNewService, NewService, Service};
struct Srv; struct Srv;
impl Service for Srv { impl Service<()> for Srv {
type Request = ();
type Response = (); type Response = ();
type Error = (); type Error = ();
type Future = FutureResult<(), ()>; type Future = FutureResult<(), ()>;

View File

@ -1,4 +1,4 @@
use std::marker; use std::marker::PhantomData;
use futures::{Future, Poll}; use futures::{Future, Poll};
@ -8,68 +8,67 @@ use super::NewService;
pub struct MapInitErr<A, F, E> { pub struct MapInitErr<A, F, E> {
a: A, a: A,
f: F, f: F,
e: marker::PhantomData<E>, e: PhantomData<E>,
} }
impl<A, F, E> MapInitErr<A, F, E> impl<A, F, E> MapInitErr<A, F, E> {
where
A: NewService,
F: Fn(A::InitError) -> E,
{
/// Create new `MapInitErr` combinator /// Create new `MapInitErr` combinator
pub fn new(a: A, f: F) -> Self { pub fn new<Request>(a: A, f: F) -> Self
where
A: NewService<Request>,
F: Fn(A::InitError) -> E,
{
Self { Self {
a, a,
f, f,
e: marker::PhantomData, e: PhantomData,
} }
} }
} }
impl<A, F, E> Clone for MapInitErr<A, F, E> impl<A, F, E> Clone for MapInitErr<A, F, E>
where where
A: NewService + Clone, A: Clone,
F: Fn(A::InitError) -> E + Clone, F: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
a: self.a.clone(), a: self.a.clone(),
f: self.f.clone(), f: self.f.clone(),
e: marker::PhantomData, e: PhantomData,
} }
} }
} }
impl<A, F, E> NewService for MapInitErr<A, F, E> impl<A, F, E, Request> NewService<Request> for MapInitErr<A, F, E>
where where
A: NewService, A: NewService<Request>,
F: Fn(A::InitError) -> E + Clone, F: Fn(A::InitError) -> E + Clone,
{ {
type Request = A::Request;
type Response = A::Response; type Response = A::Response;
type Error = A::Error; type Error = A::Error;
type Service = A::Service; type Service = A::Service;
type InitError = E; type InitError = E;
type Future = MapInitErrFuture<A, F, E>; type Future = MapInitErrFuture<A, F, E, Request>;
fn new_service(&self) -> Self::Future { fn new_service(&self) -> Self::Future {
MapInitErrFuture::new(self.a.new_service(), self.f.clone()) MapInitErrFuture::new(self.a.new_service(), self.f.clone())
} }
} }
pub struct MapInitErrFuture<A, F, E> pub struct MapInitErrFuture<A, F, E, Request>
where where
A: NewService, A: NewService<Request>,
F: Fn(A::InitError) -> E, F: Fn(A::InitError) -> E,
{ {
f: F, f: F,
fut: A::Future, fut: A::Future,
} }
impl<A, F, E> MapInitErrFuture<A, F, E> impl<A, F, E, Request> MapInitErrFuture<A, F, E, Request>
where where
A: NewService, A: NewService<Request>,
F: Fn(A::InitError) -> E, F: Fn(A::InitError) -> E,
{ {
fn new(fut: A::Future, f: F) -> Self { fn new(fut: A::Future, f: F) -> Self {
@ -77,9 +76,9 @@ where
} }
} }
impl<A, F, E> Future for MapInitErrFuture<A, F, E> impl<A, F, E, Request> Future for MapInitErrFuture<A, F, E, Request>
where where
A: NewService, A: NewService<Request>,
F: Fn(A::InitError) -> E, F: Fn(A::InitError) -> E,
{ {
type Item = A::Service; type Item = A::Service;

View File

@ -1,7 +1,7 @@
use futures::{Async, Future, Poll}; use futures::{try_ready, Async, Future, Poll};
use super::{IntoNewService, NewService, Service}; use super::{IntoNewService, NewService, Service};
use cell::Cell; use crate::cell::Cell;
/// Service for the `then` combinator, chaining a computation onto the end of /// Service for the `then` combinator, chaining a computation onto the end of
/// another service. /// another service.
@ -12,21 +12,20 @@ pub struct Then<A, B> {
b: Cell<B>, b: Cell<B>,
} }
impl<A, B> Then<A, B> impl<A, B> Then<A, B> {
where
A: Service,
B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
{
/// Create new `Then` combinator /// Create new `Then` combinator
pub fn new(a: A, b: B) -> Then<A, B> { pub fn new<Request>(a: A, b: B) -> Then<A, B>
where
A: Service<Request>,
B: Service<Result<A::Response, A::Error>, Error = A::Error>,
{
Then { a, b: Cell::new(b) } Then { a, b: Cell::new(b) }
} }
} }
impl<A, B> Clone for Then<A, B> impl<A, B> Clone for Then<A, B>
where where
A: Service + Clone, A: Clone,
B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Then { Then {
@ -36,40 +35,39 @@ where
} }
} }
impl<A, B> Service for Then<A, B> impl<A, B, Request> Service<Request> for Then<A, B>
where where
A: Service, A: Service<Request>,
B: Service<Request = Result<A::Response, A::Error>, Error = A::Error>, B: Service<Result<A::Response, A::Error>, Error = A::Error>,
{ {
type Request = A::Request;
type Response = B::Response; type Response = B::Response;
type Error = B::Error; type Error = B::Error;
type Future = ThenFuture<A, B>; type Future = ThenFuture<A, B, Request>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> { fn poll_ready(&mut self) -> Poll<(), Self::Error> {
let _ = try_ready!(self.a.poll_ready()); try_ready!(self.a.poll_ready());
self.b.borrow_mut().poll_ready() self.b.get_mut().poll_ready()
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: Request) -> Self::Future {
ThenFuture::new(self.a.call(req), self.b.clone()) ThenFuture::new(self.a.call(req), self.b.clone())
} }
} }
pub struct ThenFuture<A, B> pub struct ThenFuture<A, B, Request>
where where
A: Service, A: Service<Request>,
B: Service<Request = Result<A::Response, A::Error>>, B: Service<Result<A::Response, A::Error>>,
{ {
b: Cell<B>, b: Cell<B>,
fut_b: Option<B::Future>, fut_b: Option<B::Future>,
fut_a: A::Future, fut_a: A::Future,
} }
impl<A, B> ThenFuture<A, B> impl<A, B, Request> ThenFuture<A, B, Request>
where where
A: Service, A: Service<Request>,
B: Service<Request = Result<A::Response, A::Error>>, B: Service<Result<A::Response, A::Error>>,
{ {
fn new(fut_a: A::Future, b: Cell<B>) -> Self { fn new(fut_a: A::Future, b: Cell<B>) -> Self {
ThenFuture { ThenFuture {
@ -80,10 +78,10 @@ where
} }
} }
impl<A, B> Future for ThenFuture<A, B> impl<A, B, Request> Future for ThenFuture<A, B, Request>
where where
A: Service, A: Service<Request>,
B: Service<Request = Result<A::Response, A::Error>>, B: Service<Result<A::Response, A::Error>>,
{ {
type Item = B::Response; type Item = B::Response;
type Error = B::Error; type Error = B::Error;
@ -95,11 +93,11 @@ where
match self.fut_a.poll() { match self.fut_a.poll() {
Ok(Async::Ready(resp)) => { Ok(Async::Ready(resp)) => {
self.fut_b = Some(self.b.borrow_mut().call(Ok(resp))); self.fut_b = Some(self.b.get_mut().call(Ok(resp)));
self.poll() self.poll()
} }
Err(err) => { Err(err) => {
self.fut_b = Some(self.b.borrow_mut().call(Err(err))); self.fut_b = Some(self.b.get_mut().call(Err(err)));
self.poll() self.poll()
} }
Ok(Async::NotReady) => Ok(Async::NotReady), Ok(Async::NotReady) => Ok(Async::NotReady),
@ -113,13 +111,18 @@ pub struct ThenNewService<A, B> {
b: B, b: B,
} }
impl<A, B> ThenNewService<A, B> impl<A, B> ThenNewService<A, B> {
where
A: NewService,
B: NewService,
{
/// Create new `AndThen` combinator /// Create new `AndThen` combinator
pub fn new<F: IntoNewService<B>>(a: A, f: F) -> Self { pub fn new<F, Request>(a: A, f: F) -> Self
where
A: NewService<Request>,
B: NewService<
Result<A::Response, A::Error>,
Error = A::Error,
InitError = A::InitError,
>,
F: IntoNewService<B, Result<A::Response, A::Error>>,
{
Self { Self {
a, a,
b: f.into_new_service(), b: f.into_new_service(),
@ -127,22 +130,17 @@ where
} }
} }
impl<A, B> NewService for ThenNewService<A, B> impl<A, B, Request> NewService<Request> for ThenNewService<A, B>
where where
A: NewService, A: NewService<Request>,
B: NewService< B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
Request = Result<A::Response, A::Error>,
Error = A::Error,
InitError = A::InitError,
>,
{ {
type Request = A::Request;
type Response = B::Response; type Response = B::Response;
type Error = A::Error; type Error = A::Error;
type Service = Then<A::Service, B::Service>; type Service = Then<A::Service, B::Service>;
type InitError = A::InitError; type InitError = A::InitError;
type Future = ThenNewServiceFuture<A, B>; type Future = ThenNewServiceFuture<A, B, Request>;
fn new_service(&self) -> Self::Future { fn new_service(&self) -> Self::Future {
ThenNewServiceFuture::new(self.a.new_service(), self.b.new_service()) ThenNewServiceFuture::new(self.a.new_service(), self.b.new_service())
@ -151,12 +149,8 @@ where
impl<A, B> Clone for ThenNewService<A, B> impl<A, B> Clone for ThenNewService<A, B>
where where
A: NewService + Clone, A: Clone,
B: NewService< B: Clone,
Request = Result<A::Response, A::Error>,
Error = A::Error,
InitError = A::InitError,
> + Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
@ -166,10 +160,10 @@ where
} }
} }
pub struct ThenNewServiceFuture<A, B> pub struct ThenNewServiceFuture<A, B, Request>
where where
A: NewService, A: NewService<Request>,
B: NewService, B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
{ {
fut_b: B::Future, fut_b: B::Future,
fut_a: A::Future, fut_a: A::Future,
@ -177,10 +171,10 @@ where
b: Option<B::Service>, b: Option<B::Service>,
} }
impl<A, B> ThenNewServiceFuture<A, B> impl<A, B, Request> ThenNewServiceFuture<A, B, Request>
where where
A: NewService, A: NewService<Request>,
B: NewService, B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
{ {
fn new(fut_a: A::Future, fut_b: B::Future) -> Self { fn new(fut_a: A::Future, fut_b: B::Future) -> Self {
ThenNewServiceFuture { ThenNewServiceFuture {
@ -192,14 +186,10 @@ where
} }
} }
impl<A, B> Future for ThenNewServiceFuture<A, B> impl<A, B, Request> Future for ThenNewServiceFuture<A, B, Request>
where where
A: NewService, A: NewService<Request>,
B: NewService< B: NewService<Result<A::Response, A::Error>, Error = A::Error, InitError = A::InitError>,
Request = Result<A::Response, A::Error>,
Error = A::Error,
InitError = A::InitError,
>,
{ {
type Item = Then<A::Service, B::Service>; type Item = Then<A::Service, B::Service>;
type Error = A::InitError; type Error = A::InitError;
@ -236,12 +226,10 @@ mod tests {
use std::rc::Rc; use std::rc::Rc;
use super::*; use super::*;
use service::{NewServiceExt, ServiceExt};
#[derive(Clone)] #[derive(Clone)]
struct Srv1(Rc<Cell<usize>>); struct Srv1(Rc<Cell<usize>>);
impl Service for Srv1 { impl Service<Result<&'static str, &'static str>> for Srv1 {
type Request = Result<&'static str, &'static str>;
type Response = &'static str; type Response = &'static str;
type Error = (); type Error = ();
type Future = FutureResult<Self::Response, Self::Error>; type Future = FutureResult<Self::Response, Self::Error>;
@ -251,7 +239,7 @@ mod tests {
Ok(Async::Ready(())) Ok(Async::Ready(()))
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: Result<&'static str, &'static str>) -> Self::Future {
match req { match req {
Ok(msg) => ok(msg), Ok(msg) => ok(msg),
Err(_) => err(()), Err(_) => err(()),
@ -261,8 +249,7 @@ mod tests {
struct Srv2(Rc<Cell<usize>>); struct Srv2(Rc<Cell<usize>>);
impl Service for Srv2 { impl Service<Result<&'static str, ()>> for Srv2 {
type Request = Result<&'static str, ()>;
type Response = (&'static str, &'static str); type Response = (&'static str, &'static str);
type Error = (); type Error = ();
type Future = FutureResult<Self::Response, ()>; type Future = FutureResult<Self::Response, ()>;
@ -272,7 +259,7 @@ mod tests {
Ok(Async::Ready(())) Ok(Async::Ready(()))
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: Result<&'static str, ()>) -> Self::Future {
match req { match req {
Ok(msg) => ok((msg, "ok")), Ok(msg) => ok((msg, "ok")),
Err(()) => ok(("srv2", "err")), Err(()) => ok(("srv2", "err")),

5
actix-utils/CHANGES.md Normal file
View File

@ -0,0 +1,5 @@
# Changes
## [0.1.0] - 2018-12-09
* Move utils services to separate crate

28
actix-utils/Cargo.toml Normal file
View File

@ -0,0 +1,28 @@
[package]
name = "actix-utils"
version = "0.1.0"
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.1.1"
actix-codec = "0.1.0"
actix-rt = "0.1.0"
# io
bytes = "0.4"
futures = "0.1"
tokio-timer = "0.2.8"

View File

@ -30,33 +30,34 @@ impl<T: fmt::Debug> fmt::Debug for Cell<T> {
#[cfg(feature = "cell")] #[cfg(feature = "cell")]
impl<T> Cell<T> { impl<T> Cell<T> {
pub(crate) fn new(inner: T) -> Self { pub fn new(inner: T) -> Self {
Self { Self {
inner: Rc::new(UnsafeCell::new(inner)), inner: Rc::new(UnsafeCell::new(inner)),
} }
} }
pub(crate) fn borrow(&self) -> &T { pub fn borrow(&self) -> &T {
unsafe { &*self.inner.as_ref().get() } unsafe { &*self.inner.as_ref().get() }
} }
pub(crate) fn borrow_mut(&self) -> &mut T { pub fn borrow_mut(&self) -> &mut T {
unsafe { &mut *self.inner.as_ref().get() } unsafe { &mut *self.inner.as_ref().get() }
} }
} }
#[cfg(not(feature = "cell"))] #[cfg(not(feature = "cell"))]
impl<T> Cell<T> { impl<T> Cell<T> {
pub(crate) fn new(inner: T) -> Self { pub fn new(inner: T) -> Self {
Self { Self {
inner: Rc::new(RefCell::new(inner)), inner: Rc::new(RefCell::new(inner)),
} }
} }
pub(crate) fn borrow(&self) -> Ref<T> { pub fn borrow(&self) -> Ref<T> {
self.inner.borrow() self.inner.borrow()
} }
pub(crate) fn borrow_mut(&self) -> RefMut<T> {
pub fn borrow_mut(&self) -> RefMut<T> {
self.inner.borrow_mut() self.inner.borrow_mut()
} }
} }

View File

@ -0,0 +1,51 @@
use std::marker::PhantomData;
use std::rc::Rc;
use actix_service::Service;
use futures::Poll;
use super::cell::Cell;
/// Service that allows to turn non-clone service to a service with `Clone` impl
pub struct CloneableService<T: 'static> {
service: Cell<T>,
_t: PhantomData<Rc<()>>,
}
impl<T: 'static> CloneableService<T> {
pub fn new<Request>(service: T) -> Self
where
T: Service<Request>,
{
Self {
service: Cell::new(service),
_t: PhantomData,
}
}
}
impl<T: 'static> Clone for CloneableService<T> {
fn clone(&self) -> Self {
Self {
service: self.service.clone(),
_t: PhantomData,
}
}
}
impl<T: 'static, Request> Service<Request> for CloneableService<T>
where
T: Service<Request>,
{
type Response = T::Response;
type Error = T::Error;
type Future = T::Future;
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
self.service.borrow_mut().poll_ready()
}
fn call(&mut self, req: Request) -> Self::Future {
self.service.borrow_mut().call(req)
}
}

View File

@ -0,0 +1,78 @@
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
}
}

View File

@ -1,7 +1,6 @@
//! Contains `Either` service and related types and functions. //! Contains `Either` service and related types and functions.
use futures::{future, Async, Future, Poll}; use actix_service::{NewService, Service};
use futures::{future, try_ready, Async, Future, Poll};
use super::service::{NewService, Service};
/// Combine two different service types into a single type. /// Combine two different service types into a single type.
/// ///
@ -13,12 +12,11 @@ pub enum EitherService<A, B> {
B(B), B(B),
} }
impl<A, B> Service for EitherService<A, B> impl<A, B, Request> Service<Request> for EitherService<A, B>
where where
A: Service, A: Service<Request>,
B: Service<Request = A::Request, Response = A::Response, Error = A::Error>, B: Service<Request, Response = A::Response, Error = A::Error>,
{ {
type Request = A::Request;
type Response = A::Response; type Response = A::Response;
type Error = A::Error; type Error = A::Error;
type Future = future::Either<A::Future, B::Future>; type Future = future::Either<A::Future, B::Future>;
@ -30,7 +28,7 @@ where
} }
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: Request) -> Self::Future {
match self { match self {
EitherService::A(ref mut inner) => future::Either::A(inner.call(req)), EitherService::A(ref mut inner) => future::Either::A(inner.call(req)),
EitherService::B(ref mut inner) => future::Either::B(inner.call(req)), EitherService::B(ref mut inner) => future::Either::B(inner.call(req)),
@ -44,22 +42,16 @@ pub enum Either<A, B> {
B(B), B(B),
} }
impl<A, B> NewService for Either<A, B> impl<A, B, Request> NewService<Request> for Either<A, B>
where where
A: NewService, A: NewService<Request>,
B: NewService< B: NewService<Request, Response = A::Response, Error = A::Error, InitError = A::InitError>,
Request = A::Request,
Response = A::Response,
Error = A::Error,
InitError = A::InitError,
>,
{ {
type Request = A::Request;
type Response = A::Response; type Response = A::Response;
type Error = A::Error; type Error = A::Error;
type InitError = A::InitError; type InitError = A::InitError;
type Service = EitherService<A::Service, B::Service>; type Service = EitherService<A::Service, B::Service>;
type Future = EitherNewService<A, B>; type Future = EitherNewService<A, B, Request>;
fn new_service(&self) -> Self::Future { fn new_service(&self) -> Self::Future {
match self { match self {
@ -70,20 +62,15 @@ where
} }
#[doc(hidden)] #[doc(hidden)]
pub enum EitherNewService<A: NewService, B: NewService> { pub enum EitherNewService<A: NewService<R>, B: NewService<R>, R> {
A(A::Future), A(A::Future),
B(B::Future), B(B::Future),
} }
impl<A, B> Future for EitherNewService<A, B> impl<A, B, Request> Future for EitherNewService<A, B, Request>
where where
A: NewService, A: NewService<Request>,
B: NewService< B: NewService<Request, Response = A::Response, Error = A::Error, InitError = A::InitError>,
Request = A::Request,
Response = A::Response,
Error = A::Error,
InitError = A::InitError,
>,
{ {
type Item = EitherService<A::Service, B::Service>; type Item = EitherService<A::Service, B::Service>;
type Error = A::InitError; type Error = A::InitError;

View File

@ -2,15 +2,12 @@
use std::marker::PhantomData; use std::marker::PhantomData;
use std::mem; use std::mem;
use actix; use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
use actix_rt::Arbiter;
use actix_service::{IntoNewService, IntoService, NewService, Service};
use futures::future::{ok, FutureResult}; use futures::future::{ok, FutureResult};
use futures::unsync::mpsc; use futures::unsync::mpsc;
use futures::{Async, AsyncSink, Future, Poll, Sink, Stream}; use futures::{Async, AsyncSink, Future, Poll, Sink, Stream};
use tokio_codec::{Decoder, Encoder};
use tokio_io::{AsyncRead, AsyncWrite};
use codec::Framed;
use service::{IntoNewService, IntoService, NewService, Service};
type Request<U> = <U as Decoder>::Item; type Request<U> = <U as Decoder>::Item;
type Response<U> = <U as Encoder>::Item; type Response<U> = <U as Encoder>::Item;
@ -24,13 +21,13 @@ impl<S, T, U> FramedNewService<S, T, U>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
U: Decoder + Encoder, U: Decoder + Encoder,
S: NewService<Request = Request<U>, Response = Response<U>> + Clone, S: NewService<Request<U>, Response = Response<U>>,
<<S as NewService>::Service as Service>::Future: 'static, <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
<<S as NewService>::Service as Service>::Error: 'static, <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
<U as Encoder>::Item: 'static, <U as Encoder>::Item: 'static,
<U as Encoder>::Error: 'static, <U as Encoder>::Error: 'static,
{ {
pub fn new<F1: IntoNewService<S>>(factory: F1) -> Self { pub fn new<F1: IntoNewService<S, Request<U>>>(factory: F1) -> Self {
Self { Self {
factory: factory.into_new_service(), factory: factory.into_new_service(),
_t: PhantomData, _t: PhantomData,
@ -50,17 +47,16 @@ where
} }
} }
impl<S, T, U> NewService for FramedNewService<S, T, U> impl<S, T, U> NewService<Framed<T, U>> for FramedNewService<S, T, U>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
U: Decoder + Encoder, U: Decoder + Encoder,
S: NewService<Request = Request<U>, Response = Response<U>> + Clone, S: NewService<Request<U>, Response = Response<U>> + Clone,
<<S as NewService>::Service as Service>::Future: 'static, <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
<<S as NewService>::Service as Service>::Error: 'static, <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
<U as Encoder>::Item: 'static, <U as Encoder>::Item: 'static,
<U as Encoder>::Error: 'static, <U as Encoder>::Error: 'static,
{ {
type Request = Framed<T, U>;
type Response = FramedTransport<S::Service, T, U>; type Response = FramedTransport<S::Service, T, U>;
type Error = S::InitError; type Error = S::InitError;
type InitError = S::InitError; type InitError = S::InitError;
@ -92,17 +88,16 @@ where
} }
} }
impl<S, T, U> Service for FramedService<S, T, U> impl<S, T, U> Service<Framed<T, U>> for FramedService<S, T, U>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
U: Decoder + Encoder, U: Decoder + Encoder,
S: NewService<Request = Request<U>, Response = Response<U>>, S: NewService<Request<U>, Response = Response<U>>,
<<S as NewService>::Service as Service>::Future: 'static, <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
<<S as NewService>::Service as Service>::Error: 'static, <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
<U as Encoder>::Item: 'static, <U as Encoder>::Item: 'static,
<U as Encoder>::Error: 'static, <U as Encoder>::Error: 'static,
{ {
type Request = Framed<T, U>;
type Response = FramedTransport<S::Service, T, U>; type Response = FramedTransport<S::Service, T, U>;
type Error = S::InitError; type Error = S::InitError;
type Future = FramedServiceResponseFuture<S, T, U>; type Future = FramedServiceResponseFuture<S, T, U>;
@ -111,7 +106,7 @@ where
Ok(Async::Ready(())) Ok(Async::Ready(()))
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: Framed<T, U>) -> Self::Future {
FramedServiceResponseFuture { FramedServiceResponseFuture {
fut: self.factory.new_service(), fut: self.factory.new_service(),
@ -125,9 +120,9 @@ pub struct FramedServiceResponseFuture<S, T, U>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
U: Decoder + Encoder, U: Decoder + Encoder,
S: NewService<Request = Request<U>, Response = Response<U>>, S: NewService<Request<U>, Response = Response<U>>,
<<S as NewService>::Service as Service>::Future: 'static, <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
<<S as NewService>::Service as Service>::Error: 'static, <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
<U as Encoder>::Item: 'static, <U as Encoder>::Item: 'static,
<U as Encoder>::Error: 'static, <U as Encoder>::Error: 'static,
{ {
@ -139,9 +134,9 @@ impl<S, T, U> Future for FramedServiceResponseFuture<S, T, U>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
U: Decoder + Encoder, U: Decoder + Encoder,
S: NewService<Request = Request<U>, Response = Response<U>>, S: NewService<Request<U>, Response = Response<U>>,
<<S as NewService>::Service as Service>::Future: 'static, <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Future: 'static,
<<S as NewService>::Service as Service>::Error: 'static, <<S as NewService<Request<U>>>::Service as Service<Request<U>>>::Error: 'static,
<U as Encoder>::Item: 'static, <U as Encoder>::Item: 'static,
<U as Encoder>::Error: 'static, <U as Encoder>::Error: 'static,
{ {
@ -176,7 +171,7 @@ impl<E, U: Encoder + Decoder> From<E> for FramedTransportError<E, U> {
/// and pass then to the service. /// and pass then to the service.
pub struct FramedTransport<S, T, U> pub struct FramedTransport<S, T, U>
where where
S: Service, S: Service<Request<U>, Response = Response<U>>,
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
U: Encoder + Decoder, U: Encoder + Decoder,
{ {
@ -190,7 +185,7 @@ where
flushed: bool, flushed: bool,
} }
enum TransportState<S: Service, U: Encoder + Decoder> { enum TransportState<S: Service<Request<U>>, U: Encoder + Decoder> {
Processing, Processing,
Error(FramedTransportError<S::Error, U>), Error(FramedTransportError<S::Error, U>),
EncoderError(FramedTransportError<S::Error, U>), EncoderError(FramedTransportError<S::Error, U>),
@ -201,12 +196,12 @@ impl<S, T, U> FramedTransport<S, T, U>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
U: Decoder + Encoder, U: Decoder + Encoder,
S: Service<Request = Request<U>, Response = Response<U>>, S: Service<Request<U>, Response = Response<U>>,
S::Future: 'static, S::Future: 'static,
S::Error: 'static, S::Error: 'static,
<U as Encoder>::Error: 'static, <U as Encoder>::Error: 'static,
{ {
pub fn new<F: IntoService<S>>(framed: Framed<T, U>, service: F) -> Self { pub fn new<F: IntoService<S, Request<U>>>(framed: Framed<T, U>, service: F) -> Self {
let (write_tx, write_rx) = mpsc::channel(16); let (write_tx, write_rx) = mpsc::channel(16);
FramedTransport { FramedTransport {
framed, framed,
@ -248,7 +243,7 @@ impl<S, T, U> FramedTransport<S, T, U>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
U: Decoder + Encoder, U: Decoder + Encoder,
S: Service<Request = Request<U>, Response = Response<U>>, S: Service<Request<U>, Response = Response<U>>,
S::Future: 'static, S::Future: 'static,
S::Error: 'static, S::Error: 'static,
<U as Encoder>::Item: 'static, <U as Encoder>::Item: 'static,
@ -259,7 +254,7 @@ where
Ok(Async::Ready(_)) => { Ok(Async::Ready(_)) => {
if let Some(item) = self.request.take() { if let Some(item) = self.request.take() {
let sender = self.write_tx.clone(); let sender = self.write_tx.clone();
actix::Arbiter::spawn( Arbiter::spawn(
self.service self.service
.call(item) .call(item)
.then(|item| sender.send(item).map(|_| ()).map_err(|_| ())), .then(|item| sender.send(item).map(|_| ()).map_err(|_| ())),
@ -284,7 +279,7 @@ where
match self.service.poll_ready() { match self.service.poll_ready() {
Ok(Async::Ready(_)) => { Ok(Async::Ready(_)) => {
let sender = self.write_tx.clone(); let sender = self.write_tx.clone();
actix::Arbiter::spawn( Arbiter::spawn(
self.service self.service
.call(item) .call(item)
.then(|item| sender.send(item).map(|_| ()).map_err(|_| ())), .then(|item| sender.send(item).map(|_| ()).map_err(|_| ())),
@ -302,10 +297,10 @@ where
} }
} }
} }
Ok(Async::NotReady) => return false, Ok(Async::NotReady) => false,
Err(err) => { Err(err) => {
self.state = TransportState::Error(FramedTransportError::Service(err)); self.state = TransportState::Error(FramedTransportError::Service(err));
return true; true
} }
} }
} }
@ -377,7 +372,7 @@ impl<S, T, U> Future for FramedTransport<S, T, U>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
U: Decoder + Encoder, U: Decoder + Encoder,
S: Service<Request = Request<U>, Response = Response<U>>, S: Service<Request<U>, Response = Response<U>>,
S::Future: 'static, S::Future: 'static,
S::Error: 'static, S::Error: 'static,
<U as Encoder>::Item: 'static, <U as Encoder>::Item: 'static,
@ -389,26 +384,22 @@ where
fn poll(&mut self) -> Poll<Self::Item, Self::Error> { fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
match mem::replace(&mut self.state, TransportState::Processing) { match mem::replace(&mut self.state, TransportState::Processing) {
TransportState::Processing => { TransportState::Processing => {
if self.poll_service() { if self.poll_service() || self.poll_response() {
return self.poll(); self.poll()
} else {
Ok(Async::NotReady)
} }
if self.poll_response() {
return self.poll();
}
return Ok(Async::NotReady);
} }
TransportState::Error(err) => { TransportState::Error(err) => {
if self.poll_response() { if self.poll_response() || self.flushed {
return Err(err); Err(err)
} else {
self.state = TransportState::Error(err);
Ok(Async::NotReady)
} }
if self.flushed {
return Err(err);
}
self.state = TransportState::Error(err);
return Ok(Async::NotReady);
} }
TransportState::EncoderError(err) => return Err(err), TransportState::EncoderError(err) => Err(err),
TransportState::Stopping => return Ok(Async::Ready(())), TransportState::Stopping => Ok(Async::Ready(())),
} }
} }
} }
@ -437,13 +428,12 @@ where
} }
} }
impl<T, U, F> NewService for IntoFramed<T, U, F> impl<T, U, F> NewService<T> for IntoFramed<T, U, F>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
F: Fn() -> U + Send + Clone + 'static, F: Fn() -> U + Send + Clone + 'static,
U: Encoder + Decoder, U: Encoder + Decoder,
{ {
type Request = T;
type Response = Framed<T, U>; type Response = Framed<T, U>;
type Error = (); type Error = ();
type InitError = (); type InitError = ();
@ -468,13 +458,12 @@ where
_t: PhantomData<(T,)>, _t: PhantomData<(T,)>,
} }
impl<T, U, F> Service for IntoFramedService<T, U, F> impl<T, U, F> Service<T> for IntoFramedService<T, U, F>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
F: Fn() -> U + Send + Clone + 'static, F: Fn() -> U + Send + Clone + 'static,
U: Encoder + Decoder, U: Encoder + Decoder,
{ {
type Request = T;
type Response = Framed<T, U>; type Response = Framed<T, U>;
type Error = (); type Error = ();
type Future = FutureResult<Self::Response, Self::Error>; type Future = FutureResult<Self::Response, Self::Error>;
@ -483,7 +472,7 @@ where
Ok(Async::Ready(())) Ok(Async::Ready(()))
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: T) -> Self::Future {
ok(Framed::new(req, (self.factory)())) ok(Framed::new(req, (self.factory)()))
} }
} }

View File

@ -1,7 +1,7 @@
use futures::{Async, Future, Poll}; use actix_service::{IntoNewService, IntoService, NewService, Service};
use futures::{try_ready, Async, Future, Poll};
use super::counter::{Counter, CounterGuard}; use super::counter::{Counter, CounterGuard};
use super::service::{IntoNewService, IntoService, NewService, Service};
/// InFlight - new service for service that can limit number of in-flight /// InFlight - new service for service that can limit number of in-flight
/// async requests. /// async requests.
@ -12,11 +12,12 @@ pub struct InFlight<T> {
max_inflight: usize, max_inflight: usize,
} }
impl<T> InFlight<T> impl<T> InFlight<T> {
where pub fn new<F, Request>(factory: F) -> Self
T: NewService, where
{ T: NewService<Request>,
pub fn new<F: IntoNewService<T>>(factory: F) -> Self { F: IntoNewService<T, Request>,
{
Self { Self {
factory: factory.into_new_service(), factory: factory.into_new_service(),
max_inflight: 15, max_inflight: 15,
@ -32,16 +33,15 @@ where
} }
} }
impl<T> NewService for InFlight<T> impl<T, Request> NewService<Request> for InFlight<T>
where where
T: NewService, T: NewService<Request>,
{ {
type Request = T::Request;
type Response = T::Response; type Response = T::Response;
type Error = T::Error; type Error = T::Error;
type InitError = T::InitError; type InitError = T::InitError;
type Service = InFlightService<T::Service>; type Service = InFlightService<T::Service>;
type Future = InFlightResponseFuture<T>; type Future = InFlightResponseFuture<T, Request>;
fn new_service(&self) -> Self::Future { fn new_service(&self) -> Self::Future {
InFlightResponseFuture { InFlightResponseFuture {
@ -51,12 +51,12 @@ where
} }
} }
pub struct InFlightResponseFuture<T: NewService> { pub struct InFlightResponseFuture<T: NewService<Request>, Request> {
fut: T::Future, fut: T::Future,
max_inflight: usize, max_inflight: usize,
} }
impl<T: NewService> Future for InFlightResponseFuture<T> { impl<T: NewService<Request>, Request> Future for InFlightResponseFuture<T, Request> {
type Item = InFlightService<T::Service>; type Item = InFlightService<T::Service>;
type Error = T::InitError; type Error = T::InitError;
@ -73,15 +73,23 @@ pub struct InFlightService<T> {
count: Counter, count: Counter,
} }
impl<T: Service> InFlightService<T> { impl<T> InFlightService<T> {
pub fn new<F: IntoService<T>>(service: F) -> Self { pub fn new<F, Request>(service: F) -> Self
where
T: Service<Request>,
F: IntoService<T, Request>,
{
Self { Self {
service: service.into_service(), service: service.into_service(),
count: Counter::new(15), count: Counter::new(15),
} }
} }
pub fn with_max_inflight<F: IntoService<T>>(max: usize, service: F) -> Self { pub fn with_max_inflight<F, Request>(max: usize, service: F) -> Self
where
T: Service<Request>,
F: IntoService<T, Request>,
{
Self { Self {
service: service.into_service(), service: service.into_service(),
count: Counter::new(max), count: Counter::new(max),
@ -89,11 +97,13 @@ impl<T: Service> InFlightService<T> {
} }
} }
impl<T: Service> Service for InFlightService<T> { impl<T, Request> Service<Request> for InFlightService<T>
type Request = T::Request; where
T: Service<Request>,
{
type Response = T::Response; type Response = T::Response;
type Error = T::Error; type Error = T::Error;
type Future = InFlightServiceResponse<T>; type Future = InFlightServiceResponse<T, Request>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> { fn poll_ready(&mut self) -> Poll<(), Self::Error> {
let res = self.service.poll_ready(); let res = self.service.poll_ready();
@ -103,22 +113,21 @@ impl<T: Service> Service for InFlightService<T> {
res res
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: Request) -> Self::Future {
InFlightServiceResponse { InFlightServiceResponse {
fut: self.service.call(req), fut: self.service.call(req),
guard: self.count.get(), _guard: self.count.get(),
} }
} }
} }
#[doc(hidden)] #[doc(hidden)]
pub struct InFlightServiceResponse<T: Service> { pub struct InFlightServiceResponse<T: Service<Request>, Request> {
fut: T::Future, fut: T::Future,
#[allow(dead_code)] _guard: CounterGuard,
guard: CounterGuard,
} }
impl<T: Service> Future for InFlightServiceResponse<T> { impl<T: Service<Request>, Request> Future for InFlightServiceResponse<T, Request> {
type Item = T::Response; type Item = T::Response;
type Error = T::Error; type Error = T::Error;

View File

@ -1,11 +1,11 @@
use std::marker::PhantomData; use std::marker::PhantomData;
use std::time::{Duration, Instant}; use std::time::{Duration, Instant};
use actix_service::{NewService, Service};
use futures::future::{ok, FutureResult}; use futures::future::{ok, FutureResult};
use futures::{Async, Future, Poll}; use futures::{Async, Future, Poll};
use tokio_timer::Delay; use tokio_timer::Delay;
use super::service::{NewService, Service};
use super::time::{LowResTime, LowResTimeService}; use super::time::{LowResTime, LowResTimeService};
use super::Never; use super::Never;
@ -32,7 +32,7 @@ where
impl<R, E, F> Clone for KeepAlive<R, E, F> impl<R, E, F> Clone for KeepAlive<R, E, F>
where where
F: Fn() -> E + Clone, F: Clone,
{ {
fn clone(&self) -> Self { fn clone(&self) -> Self {
KeepAlive { KeepAlive {
@ -44,11 +44,10 @@ where
} }
} }
impl<R, E, F> NewService for KeepAlive<R, E, F> impl<R, E, F> NewService<R> for KeepAlive<R, E, F>
where where
F: Fn() -> E + Clone, F: Fn() -> E + Clone,
{ {
type Request = R;
type Response = R; type Response = R;
type Error = E; type Error = E;
type InitError = Never; type InitError = Never;
@ -90,11 +89,10 @@ where
} }
} }
impl<R, E, F> Service for KeepAliveService<R, E, F> impl<R, E, F> Service<R> for KeepAliveService<R, E, F>
where where
F: Fn() -> E, F: Fn() -> E,
{ {
type Request = R;
type Response = R; type Response = R;
type Error = E; type Error = E;
type Future = FutureResult<R, E>; type Future = FutureResult<R, E>;
@ -116,7 +114,7 @@ where
} }
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: R) -> Self::Future {
self.expire = self.time.now() + self.ka; self.expire = self.time.now() + self.ka;
ok(req) ok(req)
} }

14
actix-utils/src/lib.rs Normal file
View File

@ -0,0 +1,14 @@
//! Actix utils - various helper services
mod cell;
pub mod cloneable;
pub mod counter;
pub mod either;
pub mod framed;
pub mod inflight;
pub mod keepalive;
pub mod stream;
pub mod time;
pub mod timeout;
#[derive(Copy, Clone, Debug)]
pub enum Never {}

View File

@ -1,10 +1,9 @@
use std::marker::PhantomData; use std::marker::PhantomData;
use actix_rt::spawn;
use actix_service::{IntoService, NewService, Service};
use futures::unsync::mpsc; use futures::unsync::mpsc;
use futures::{future, Async, Future, Poll, Stream}; use futures::{future, Async, Future, Poll, Stream};
use tokio_current_thread::spawn;
use super::service::{IntoService, NewService, Service};
pub struct StreamDispatcher<S: Stream, T> { pub struct StreamDispatcher<S: Stream, T> {
stream: S, stream: S,
@ -17,10 +16,13 @@ pub struct StreamDispatcher<S: Stream, T> {
impl<S, T> StreamDispatcher<S, T> impl<S, T> StreamDispatcher<S, T>
where where
S: Stream, S: Stream,
T: Service<Request = Result<S::Item, S::Error>, Response = (), Error = ()>, T: Service<Result<S::Item, S::Error>, Response = (), Error = ()>,
T::Future: 'static, T::Future: 'static,
{ {
pub fn new<F: IntoService<T>>(stream: S, service: F) -> Self { pub fn new<F>(stream: S, service: F) -> Self
where
F: IntoService<T, Result<S::Item, S::Error>>,
{
let (stop_tx, stop_rx) = mpsc::unbounded(); let (stop_tx, stop_rx) = mpsc::unbounded();
StreamDispatcher { StreamDispatcher {
stream, stream,
@ -35,7 +37,7 @@ where
impl<S, T> Future for StreamDispatcher<S, T> impl<S, T> Future for StreamDispatcher<S, T>
where where
S: Stream, S: Stream,
T: Service<Request = Result<S::Item, S::Error>, Response = (), Error = ()>, T: Service<Result<S::Item, S::Error>, Response = (), Error = ()>,
T::Future: 'static, T::Future: 'static,
{ {
type Item = (); type Item = ();
@ -103,14 +105,19 @@ impl<T> TakeItem<T> {
} }
} }
impl<T> Default for TakeItem<T> {
fn default() -> Self {
TakeItem { _t: PhantomData }
}
}
impl<T> Clone for TakeItem<T> { impl<T> Clone for TakeItem<T> {
fn clone(&self) -> TakeItem<T> { fn clone(&self) -> TakeItem<T> {
TakeItem { _t: PhantomData } TakeItem { _t: PhantomData }
} }
} }
impl<T: Stream> NewService for TakeItem<T> { impl<T: Stream> NewService<T> for TakeItem<T> {
type Request = T;
type Response = (Option<T::Item>, T); type Response = (Option<T::Item>, T);
type Error = T::Error; type Error = T::Error;
type InitError = (); type InitError = ();
@ -133,8 +140,7 @@ impl<T> Clone for TakeItemService<T> {
} }
} }
impl<T: Stream> Service for TakeItemService<T> { impl<T: Stream> Service<T> for TakeItemService<T> {
type Request = T;
type Response = (Option<T::Item>, T); type Response = (Option<T::Item>, T);
type Error = T::Error; type Error = T::Error;
type Future = TakeItemServiceResponse<T>; type Future = TakeItemServiceResponse<T>;
@ -143,7 +149,7 @@ impl<T: Stream> Service for TakeItemService<T> {
Ok(Async::Ready(())) Ok(Async::Ready(()))
} }
fn call(&mut self, req: Self::Request) -> Self::Future { fn call(&mut self, req: T) -> Self::Future {
TakeItemServiceResponse { stream: Some(req) } TakeItemServiceResponse { stream: Some(req) }
} }
} }

View File

@ -1,12 +1,12 @@
use std::time::{Duration, Instant}; use std::time::{Duration, Instant};
use actix_rt::spawn;
use actix_service::{NewService, Service};
use futures::future::{ok, FutureResult}; use futures::future::{ok, FutureResult};
use futures::{Async, Future, Poll}; use futures::{Async, Future, Poll};
use tokio_current_thread::spawn;
use tokio_timer::sleep; use tokio_timer::sleep;
use super::cell::Cell; use super::cell::Cell;
use super::service::{NewService, Service};
use super::Never; use super::Never;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
@ -43,8 +43,7 @@ impl Default for LowResTime {
} }
} }
impl NewService for LowResTime { impl NewService<()> for LowResTime {
type Request = ();
type Response = Instant; type Response = Instant;
type Error = Never; type Error = Never;
type InitError = Never; type InitError = Never;
@ -67,7 +66,7 @@ impl LowResTimeService {
/// Get current time. This function has to be called from /// Get current time. This function has to be called from
/// future's poll method, otherwise it panics. /// future's poll method, otherwise it panics.
pub fn now(&self) -> Instant { pub fn now(&self) -> Instant {
let cur = self.0.borrow().current.clone(); let cur = self.0.borrow().current;
if let Some(cur) = cur { if let Some(cur) = cur {
cur cur
} else { } else {
@ -88,8 +87,7 @@ impl LowResTimeService {
} }
} }
impl Service for LowResTimeService { impl Service<()> for LowResTimeService {
type Request = ();
type Response = Instant; type Response = Instant;
type Error = Never; type Error = Never;
type Future = FutureResult<Self::Response, Self::Error>; type Future = FutureResult<Self::Response, Self::Error>;

View File

@ -5,14 +5,14 @@
use std::fmt; use std::fmt;
use std::time::Duration; use std::time::Duration;
use actix_service::{NewService, Service};
use futures::try_ready;
use futures::{Async, Future, Poll}; use futures::{Async, Future, Poll};
use tokio_timer::{clock, Delay}; use tokio_timer::{clock, Delay};
use service::{NewService, Service};
/// Applies a timeout to requests. /// Applies a timeout to requests.
#[derive(Debug)] #[derive(Debug)]
pub struct Timeout<T: NewService + Clone> { pub struct Timeout<T> {
inner: T, inner: T,
timeout: Duration, timeout: Duration,
} }
@ -34,44 +34,43 @@ impl<E: fmt::Debug> fmt::Debug for TimeoutError<E> {
} }
} }
impl<T> Timeout<T> impl<T> Timeout<T> {
where pub fn new<Request>(timeout: Duration, inner: T) -> Self
T: NewService + Clone, where
{ T: NewService<Request> + Clone,
pub fn new(timeout: Duration, inner: T) -> Self { {
Timeout { inner, timeout } Timeout { inner, timeout }
} }
} }
impl<T> NewService for Timeout<T> impl<T, Request> NewService<Request> for Timeout<T>
where where
T: NewService + Clone, T: NewService<Request> + Clone,
{ {
type Request = T::Request;
type Response = T::Response; type Response = T::Response;
type Error = TimeoutError<T::Error>; type Error = TimeoutError<T::Error>;
type InitError = T::InitError; type InitError = T::InitError;
type Service = TimeoutService<T::Service>; type Service = TimeoutService<T::Service>;
type Future = TimeoutFut<T>; type Future = TimeoutFut<T, Request>;
fn new_service(&self) -> Self::Future { fn new_service(&self) -> Self::Future {
TimeoutFut { TimeoutFut {
fut: self.inner.new_service(), fut: self.inner.new_service(),
timeout: self.timeout.clone(), timeout: self.timeout,
} }
} }
} }
/// `Timeout` response future /// `Timeout` response future
#[derive(Debug)] #[derive(Debug)]
pub struct TimeoutFut<T: NewService> { pub struct TimeoutFut<T: NewService<Request>, Request> {
fut: T::Future, fut: T::Future,
timeout: Duration, timeout: Duration,
} }
impl<T> Future for TimeoutFut<T> impl<T, Request> Future for TimeoutFut<T, Request>
where where
T: NewService, T: NewService<Request>,
{ {
type Item = TimeoutService<T::Service>; type Item = TimeoutService<T::Service>;
type Error = T::InitError; type Error = T::InitError;
@ -90,15 +89,15 @@ pub struct TimeoutService<T> {
} }
impl<T> TimeoutService<T> { impl<T> TimeoutService<T> {
pub fn new(timeout: Duration, inner: T) -> Self { pub fn new<Request>(timeout: Duration, inner: T) -> Self
where
T: Service<Request>,
{
TimeoutService { inner, timeout } TimeoutService { inner, timeout }
} }
} }
impl<T> Clone for TimeoutService<T> impl<T: Clone> Clone for TimeoutService<T> {
where
T: Clone,
{
fn clone(&self) -> Self { fn clone(&self) -> Self {
TimeoutService { TimeoutService {
inner: self.inner.clone(), inner: self.inner.clone(),
@ -107,22 +106,19 @@ where
} }
} }
impl<T> Service for TimeoutService<T> impl<T, Request> Service<Request> for TimeoutService<T>
where where
T: Service, T: Service<Request>,
{ {
type Request = T::Request;
type Response = T::Response; type Response = T::Response;
type Error = TimeoutError<T::Error>; type Error = TimeoutError<T::Error>;
type Future = TimeoutServiceResponse<T>; type Future = TimeoutServiceResponse<T, Request>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> { fn poll_ready(&mut self) -> Poll<(), Self::Error> {
self.inner self.inner.poll_ready().map_err(TimeoutError::Service)
.poll_ready()
.map_err(|e| TimeoutError::Service(e))
} }
fn call(&mut self, request: Self::Request) -> Self::Future { fn call(&mut self, request: Request) -> Self::Future {
TimeoutServiceResponse { TimeoutServiceResponse {
fut: self.inner.call(request), fut: self.inner.call(request),
sleep: Delay::new(clock::now() + self.timeout), sleep: Delay::new(clock::now() + self.timeout),
@ -132,14 +128,14 @@ where
/// `TimeoutService` response future /// `TimeoutService` response future
#[derive(Debug)] #[derive(Debug)]
pub struct TimeoutServiceResponse<T: Service> { pub struct TimeoutServiceResponse<T: Service<Request>, Request> {
fut: T::Future, fut: T::Future,
sleep: Delay, sleep: Delay,
} }
impl<T> Future for TimeoutServiceResponse<T> impl<T, Request> Future for TimeoutServiceResponse<T, Request>
where where
T: Service, T: Service<Request>,
{ {
type Item = T::Response; type Item = T::Response;
type Error = TimeoutError<T::Error>; type Error = TimeoutError<T::Error>;

View File

@ -1,29 +1,20 @@
//! simple composite service //! simple composite service
//! build: cargo run --example basic --features "ssl" //! build: cargo run --example basic --features "ssl"
//! to test: curl https://127.0.0.1:8443/ -k //! to test: curl https://127.0.0.1:8443/ -k
extern crate actix;
extern crate actix_net;
extern crate env_logger;
extern crate futures;
extern crate openssl;
extern crate tokio_io;
extern crate tokio_openssl;
extern crate tokio_tcp;
use std::sync::{ use std::sync::{
atomic::{AtomicUsize, Ordering}, atomic::{AtomicUsize, Ordering},
Arc, Arc,
}; };
use std::{env, fmt}; use std::{env, fmt};
use actix_codec::{AsyncRead, AsyncWrite};
use actix_rt::System;
use actix_server::Server;
use actix_service::{IntoNewService, NewService};
use futures::{future, Future}; use futures::{future, Future};
use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod}; use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
use tokio_io::{AsyncRead, AsyncWrite};
use tokio_openssl::SslAcceptorExt; use tokio_openssl::SslAcceptorExt;
use actix_net::server::Server;
use actix_net::service::{IntoNewService, NewServiceExt};
/// Simple logger service, it just prints fact of the new connections /// Simple logger service, it just prints fact of the new connections
fn logger<T: AsyncRead + AsyncWrite + fmt::Debug>( fn logger<T: AsyncRead + AsyncWrite + fmt::Debug>(
stream: T, stream: T,
@ -36,7 +27,7 @@ fn main() {
env::set_var("RUST_LOG", "actix_net=trace"); env::set_var("RUST_LOG", "actix_net=trace");
env_logger::init(); env_logger::init();
let sys = actix::System::new("test"); let sys = System::new("test");
// load ssl keys // load ssl keys
let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap(); let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
@ -53,7 +44,7 @@ fn main() {
// bind socket address and start workers. By default server uses number of // bind socket address and start workers. By default server uses number of
// available logical cpu as threads count. actix net start separate // available logical cpu as threads count. actix net start separate
// instances of service pipeline in each worker. // instances of service pipeline in each worker.
Server::default() Server::build()
.bind( .bind(
// configure service pipeline // configure service pipeline
"basic", "basic",
@ -80,7 +71,8 @@ fn main() {
future::ok(()) future::ok(())
}) })
}, },
).unwrap() )
.unwrap()
.start(); .start();
sys.run(); sys.run();

View File

@ -1,22 +1,14 @@
extern crate actix;
extern crate actix_net;
extern crate futures;
extern crate openssl;
extern crate tokio_io;
extern crate tokio_tcp;
use std::sync::{ use std::sync::{
atomic::{AtomicUsize, Ordering}, atomic::{AtomicUsize, Ordering},
Arc, Arc,
}; };
use actix_codec::{AsyncRead, AsyncWrite};
use actix_rt::System;
use actix_server::{ssl, Server};
use actix_service::NewService;
use futures::{future, Future}; use futures::{future, Future};
use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod}; use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
use tokio_io::{AsyncRead, AsyncWrite};
use actix_net::server::Server;
use actix_net::service::NewServiceExt;
use actix_net::ssl;
#[derive(Debug)] #[derive(Debug)]
struct ServiceState { struct ServiceState {
@ -33,7 +25,7 @@ fn service<T: AsyncRead + AsyncWrite>(
} }
fn main() { fn main() {
let sys = actix::System::new("test"); let sys = System::new("test");
// load ssl keys // load ssl keys
let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap(); let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
@ -48,7 +40,7 @@ fn main() {
let openssl = ssl::OpensslAcceptor::new(builder.build()); let openssl = ssl::OpensslAcceptor::new(builder.build());
// server start mutiple workers, it runs supplied `Fn` in each worker. // server start mutiple workers, it runs supplied `Fn` in each worker.
Server::default() Server::build()
.bind("test-ssl", "0.0.0.0:8443", move || { .bind("test-ssl", "0.0.0.0:8443", move || {
let num = num.clone(); let num = num.clone();
@ -61,7 +53,8 @@ fn main() {
println!("got ssl connection {:?}", num); println!("got ssl connection {:?}", num);
future::ok(()) future::ok(())
}) })
}).unwrap() })
.unwrap()
.start(); .start();
sys.run(); sys.run();

View File

@ -1,5 +1,5 @@
max_width = 96 max_width = 96
reorder_imports = true reorder_imports = true
wrap_comments = true #wrap_comments = true
fn_args_density = "Compressed" #fn_args_density = "Compressed"
#use_small_heuristics = false #use_small_heuristics = false

View File

@ -1,40 +0,0 @@
use futures::Poll;
use super::cell::Cell;
use super::service::Service;
/// Service that allows to turn non-clone service to a service with `Clone` impl
pub struct CloneableService<S: Service + 'static> {
service: Cell<S>,
}
impl<S: Service + 'static> CloneableService<S> {
pub fn new(service: S) -> Self {
Self {
service: Cell::new(service),
}
}
}
impl<S: Service + 'static> Clone for CloneableService<S> {
fn clone(&self) -> Self {
Self {
service: self.service.clone(),
}
}
}
impl<S: Service + 'static> Service for CloneableService<S> {
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Future = S::Future;
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
self.service.borrow_mut().poll_ready()
}
fn call(&mut self, req: Self::Request) -> Self::Future {
self.service.borrow_mut().call(req)
}
}

View File

@ -1,313 +0,0 @@
#![allow(deprecated)]
use std::fmt;
use std::io::{self, Read, Write};
use bytes::BytesMut;
use futures::{Poll, Sink, StartSend, Stream};
use tokio_codec::{Decoder, Encoder};
use tokio_io::{AsyncRead, AsyncWrite};
use super::framed_read::{framed_read2, framed_read2_with_buffer, FramedRead2};
use super::framed_write::{framed_write2, framed_write2_with_buffer, FramedWrite2};
/// A unified `Stream` and `Sink` interface to an underlying I/O object, using
/// the `Encoder` and `Decoder` traits to encode and decode frames.
///
/// You can create a `Framed` instance by using the `AsyncRead::framed` adapter.
pub struct Framed2<T, D, E> {
inner: FramedRead2<FramedWrite2<Fuse2<T, D, E>>>,
}
pub struct Fuse2<T, D, E>(pub T, pub D, pub E);
impl<T, D, E> Framed2<T, D, E>
where
T: AsyncRead + AsyncWrite,
D: Decoder,
E: Encoder,
{
/// Provides a `Stream` and `Sink` interface for reading and writing to this
/// `Io` object, using `Decode` and `Encode` to read and write the raw data.
///
/// Raw I/O objects work with byte sequences, but higher-level code usually
/// wants to batch these into meaningful chunks, called "frames". This
/// method layers framing on top of an I/O object, by using the `Codec`
/// traits to handle encoding and decoding of messages frames. Note that
/// the incoming and outgoing frame types may be distinct.
///
/// This function returns a *single* object that is both `Stream` and
/// `Sink`; grouping this into a single object is often useful for layering
/// things like gzip or TLS, which require both read and write access to the
/// underlying object.
///
/// If you want to work more directly with the streams and sink, consider
/// calling `split` on the `Framed` returned by this method, which will
/// break them into separate objects, allowing them to interact more easily.
pub fn new(inner: T, decoder: D, encoder: E) -> Framed2<T, D, E> {
Framed2 {
inner: framed_read2(framed_write2(Fuse2(inner, decoder, encoder))),
}
}
}
impl<T, D, E> Framed2<T, D, E> {
/// Provides a `Stream` and `Sink` interface for reading and writing to this
/// `Io` object, using `Decode` and `Encode` to read and write the raw data.
///
/// Raw I/O objects work with byte sequences, but higher-level code usually
/// wants to batch these into meaningful chunks, called "frames". This
/// method layers framing on top of an I/O object, by using the `Codec`
/// traits to handle encoding and decoding of messages frames. Note that
/// the incoming and outgoing frame types may be distinct.
///
/// This function returns a *single* object that is both `Stream` and
/// `Sink`; grouping this into a single object is often useful for layering
/// things like gzip or TLS, which require both read and write access to the
/// underlying object.
///
/// This objects takes a stream and a readbuffer and a writebuffer. These
/// field can be obtained from an existing `Framed` with the
/// `into_parts` method.
///
/// If you want to work more directly with the streams and sink, consider
/// calling `split` on the `Framed` returned by this method, which will
/// break them into separate objects, allowing them to interact more easily.
pub fn from_parts(parts: FramedParts2<T, D, E>) -> Framed2<T, D, E> {
Framed2 {
inner: framed_read2_with_buffer(
framed_write2_with_buffer(
Fuse2(parts.io, parts.decoder, parts.encoder),
parts.write_buf,
),
parts.read_buf,
),
}
}
/// Returns a reference to the underlying I/O stream wrapped by
/// `Frame`.
///
/// Note that care should be taken to not tamper with the underlying stream
/// of data coming in as it may corrupt the stream of frames otherwise
/// being worked with.
pub fn get_ref(&self) -> &T {
&self.inner.get_ref().get_ref().0
}
/// Returns a mutable reference to the underlying I/O stream wrapped by
/// `Frame`.
///
/// Note that care should be taken to not tamper with the underlying stream
/// of data coming in as it may corrupt the stream of frames otherwise
/// being worked with.
pub fn get_mut(&mut self) -> &mut T {
&mut self.inner.get_mut().get_mut().0
}
/// Returns a reference to the underlying decoder.
pub fn decocer(&self) -> &D {
&self.inner.get_ref().get_ref().1
}
/// Returns a mutable reference to the underlying decoder.
pub fn decoder_mut(&mut self) -> &mut D {
&mut self.inner.get_mut().get_mut().1
}
/// Returns a reference to the underlying encoder.
pub fn encoder(&self) -> &E {
&self.inner.get_ref().get_ref().2
}
/// Returns a mutable reference to the underlying codec.
pub fn encoder_mut(&mut self) -> &mut E {
&mut self.inner.get_mut().get_mut().2
}
/// Consumes the `Frame`, returning its underlying I/O stream.
///
/// Note that care should be taken to not tamper with the underlying stream
/// of data coming in as it may corrupt the stream of frames otherwise
/// being worked with.
pub fn into_inner(self) -> T {
self.inner.into_inner().into_inner().0
}
/// Consume the `Frame`, returning `Frame` with different codec.
pub fn switch_encoder<E2>(self, encoder: E2) -> Framed2<T, D, E2> {
let (inner, read_buf) = self.inner.into_parts();
let (inner, write_buf) = inner.into_parts();
Framed2 {
inner: framed_read2_with_buffer(
framed_write2_with_buffer(Fuse2(inner.0, inner.1, encoder), write_buf),
read_buf,
),
}
}
/// Consumes the `Frame`, returning its underlying I/O stream, the buffer
/// with unprocessed data, and the codec.
///
/// Note that care should be taken to not tamper with the underlying stream
/// of data coming in as it may corrupt the stream of frames otherwise
/// being worked with.
pub fn into_parts(self) -> FramedParts2<T, D, E> {
let (inner, read_buf) = self.inner.into_parts();
let (inner, write_buf) = inner.into_parts();
FramedParts2 {
io: inner.0,
decoder: inner.1,
encoder: inner.2,
read_buf: read_buf,
write_buf: write_buf,
_priv: (),
}
}
}
impl<T, D, E> Stream for Framed2<T, D, E>
where
T: AsyncRead,
D: Decoder,
{
type Item = D::Item;
type Error = D::Error;
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
self.inner.poll()
}
}
impl<T, D, E> Sink for Framed2<T, D, E>
where
T: AsyncWrite,
E: Encoder,
E::Error: From<io::Error>,
{
type SinkItem = E::Item;
type SinkError = E::Error;
fn start_send(
&mut self,
item: Self::SinkItem,
) -> StartSend<Self::SinkItem, Self::SinkError> {
self.inner.get_mut().start_send(item)
}
fn poll_complete(&mut self) -> Poll<(), Self::SinkError> {
self.inner.get_mut().poll_complete()
}
fn close(&mut self) -> Poll<(), Self::SinkError> {
self.inner.get_mut().close()
}
}
impl<T, D, E> fmt::Debug for Framed2<T, D, E>
where
T: fmt::Debug,
D: fmt::Debug,
E: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Framed2")
.field("io", &self.inner.get_ref().get_ref().0)
.field("decoder", &self.inner.get_ref().get_ref().1)
.field("encoder", &self.inner.get_ref().get_ref().2)
.finish()
}
}
// ===== impl Fuse2 =====
impl<T: Read, D, E> Read for Fuse2<T, D, E> {
fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
self.0.read(dst)
}
}
impl<T: AsyncRead, D, E> AsyncRead for Fuse2<T, D, E> {
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
self.0.prepare_uninitialized_buffer(buf)
}
}
impl<T: Write, D, E> Write for Fuse2<T, D, E> {
fn write(&mut self, src: &[u8]) -> io::Result<usize> {
self.0.write(src)
}
fn flush(&mut self) -> io::Result<()> {
self.0.flush()
}
}
impl<T: AsyncWrite, D, E> AsyncWrite for Fuse2<T, D, E> {
fn shutdown(&mut self) -> Poll<(), io::Error> {
self.0.shutdown()
}
}
impl<T, D: Decoder, E> Decoder for Fuse2<T, D, E> {
type Item = D::Item;
type Error = D::Error;
fn decode(&mut self, buffer: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
self.1.decode(buffer)
}
fn decode_eof(&mut self, buffer: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
self.1.decode_eof(buffer)
}
}
impl<T, D, E: Encoder> Encoder for Fuse2<T, D, E> {
type Item = E::Item;
type Error = E::Error;
fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> Result<(), Self::Error> {
self.2.encode(item, dst)
}
}
/// `FramedParts` contains an export of the data of a Framed transport.
/// It can be used to construct a new `Framed` with a different codec.
/// It contains all current buffers and the inner transport.
#[derive(Debug)]
pub struct FramedParts2<T, D, E> {
/// The inner transport used to read bytes to and write bytes to
pub io: T,
/// The decoder
pub decoder: D,
/// The encoder
pub encoder: E,
/// The buffer with read but unprocessed data.
pub read_buf: BytesMut,
/// A buffer with unprocessed data which are not written yet.
pub write_buf: BytesMut,
/// This private field allows us to add additional fields in the future in a
/// backwards compatible way.
_priv: (),
}
impl<T, D, E> FramedParts2<T, D, E> {
/// Create a new, default, `FramedParts`
pub fn new(io: T, decoder: D, encoder: E) -> FramedParts2<T, D, E> {
FramedParts2 {
io,
decoder,
encoder,
read_buf: BytesMut::new(),
write_buf: BytesMut::new(),
_priv: (),
}
}
}

View File

@ -1,76 +0,0 @@
//! Actix net - framework for the compisible network services for Rust.
//!
//! ## Package feature
//!
//! * `tls` - enables ssl support via `native-tls` crate
//! * `ssl` - enables ssl support via `openssl` crate
//! * `rust-tls` - enables ssl support via `rustls` crate
// #![warn(missing_docs)]
#![cfg_attr(
feature = "cargo-clippy",
allow(
declare_interior_mutable_const,
borrow_interior_mutable_const
)
)]
#[macro_use]
extern crate log;
extern crate bytes;
#[macro_use]
extern crate futures;
extern crate mio;
extern crate net2;
extern crate num_cpus;
extern crate slab;
extern crate tokio;
extern crate tokio_codec;
extern crate tokio_current_thread;
extern crate tokio_io;
extern crate tokio_reactor;
extern crate tokio_tcp;
extern crate tokio_timer;
extern crate tower_service;
extern crate trust_dns_resolver;
#[allow(unused_imports)]
#[macro_use]
extern crate actix;
#[cfg(feature = "tls")]
extern crate native_tls;
#[cfg(feature = "ssl")]
extern crate openssl;
#[cfg(feature = "ssl")]
extern crate tokio_openssl;
#[cfg(feature = "rust-tls")]
extern crate rustls;
#[cfg(feature = "rust-tls")]
extern crate tokio_rustls;
#[cfg(feature = "rust-tls")]
extern crate webpki;
#[cfg(feature = "rust-tls")]
extern crate webpki_roots;
mod cell;
pub mod cloneable;
pub mod codec;
pub mod connector;
pub mod counter;
pub mod either;
pub mod framed;
pub mod inflight;
pub mod keepalive;
pub mod resolver;
pub mod server;
pub mod service;
pub mod ssl;
pub mod stream;
pub mod time;
pub mod timeout;
#[derive(Copy, Clone, Debug)]
pub enum Never {}

View File

@ -1,48 +0,0 @@
//! General purpose networking server
use actix::Message;
mod accept;
mod config;
mod server;
mod services;
mod worker;
pub use self::config::{ServiceConfig, ServiceRuntime};
pub use self::server::Server;
pub use self::services::{ServerMessage, ServiceFactory, StreamServiceFactory};
/// Pause accepting incoming connections
///
/// If socket contains some pending connection, they might be dropped.
/// All opened connection remains active.
#[derive(Message)]
pub struct PauseServer;
/// Resume accepting incoming connections
#[derive(Message)]
pub struct ResumeServer;
/// Stop incoming connection processing, stop all workers and exit.
///
/// If server starts with `spawn()` method, then spawned thread get terminated.
pub struct StopServer {
/// Whether to try and shut down gracefully
pub graceful: bool,
}
impl Message for StopServer {
type Result = Result<(), ()>;
}
/// 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
}
}

View File

@ -1,197 +0,0 @@
use std::marker::PhantomData;
use futures::{future::ok, future::FutureResult, Async, Future, Poll};
use openssl::ssl::{Error, SslAcceptor, SslConnector};
use tokio_io::{AsyncRead, AsyncWrite};
use tokio_openssl::{AcceptAsync, ConnectAsync, SslAcceptorExt, SslConnectorExt, SslStream};
use super::MAX_CONN_COUNTER;
use counter::{Counter, CounterGuard};
use resolver::RequestHost;
use service::{NewService, Service};
/// Support `SSL` connections via openssl package
///
/// `ssl` feature enables `OpensslAcceptor` type
pub struct OpensslAcceptor<T> {
acceptor: SslAcceptor,
io: PhantomData<T>,
}
impl<T> OpensslAcceptor<T> {
/// Create default `OpensslAcceptor`
pub fn new(acceptor: SslAcceptor) -> Self {
OpensslAcceptor {
acceptor,
io: PhantomData,
}
}
}
impl<T: AsyncRead + AsyncWrite> Clone for OpensslAcceptor<T> {
fn clone(&self) -> Self {
Self {
acceptor: self.acceptor.clone(),
io: PhantomData,
}
}
}
impl<T: AsyncRead + AsyncWrite> NewService for OpensslAcceptor<T> {
type Request = T;
type Response = SslStream<T>;
type Error = Error;
type Service = OpensslAcceptorService<T>;
type InitError = ();
type Future = FutureResult<Self::Service, Self::InitError>;
fn new_service(&self) -> Self::Future {
MAX_CONN_COUNTER.with(|conns| {
ok(OpensslAcceptorService {
acceptor: self.acceptor.clone(),
conns: conns.clone(),
io: PhantomData,
})
})
}
}
pub struct OpensslAcceptorService<T> {
acceptor: SslAcceptor,
io: PhantomData<T>,
conns: Counter,
}
impl<T: AsyncRead + AsyncWrite> Service for OpensslAcceptorService<T> {
type Request = T;
type Response = SslStream<T>;
type Error = Error;
type Future = OpensslAcceptorServiceFut<T>;
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 {
OpensslAcceptorServiceFut {
_guard: self.conns.get(),
fut: SslAcceptorExt::accept_async(&self.acceptor, req),
}
}
}
pub struct OpensslAcceptorServiceFut<T>
where
T: AsyncRead + AsyncWrite,
{
fut: AcceptAsync<T>,
_guard: CounterGuard,
}
impl<T: AsyncRead + AsyncWrite> Future for OpensslAcceptorServiceFut<T> {
type Item = SslStream<T>;
type Error = Error;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
self.fut.poll()
}
}
/// Openssl connector factory
pub struct OpensslConnector<R, T, E> {
connector: SslConnector,
_t: PhantomData<(R, T, E)>,
}
impl<R, T, E> OpensslConnector<R, T, E> {
pub fn new(connector: SslConnector) -> Self {
OpensslConnector {
connector,
_t: PhantomData,
}
}
}
impl<R: RequestHost, T: AsyncRead + AsyncWrite> OpensslConnector<R, T, ()> {
pub fn service(
connector: SslConnector,
) -> impl Service<Request = (R, T), Response = (R, SslStream<T>), Error = Error> {
OpensslConnectorService {
connector: connector,
_t: PhantomData,
}
}
}
impl<R, T, E> Clone for OpensslConnector<R, T, E> {
fn clone(&self) -> Self {
Self {
connector: self.connector.clone(),
_t: PhantomData,
}
}
}
impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService for OpensslConnector<R, T, E> {
type Request = (R, T);
type Response = (R, SslStream<T>);
type Error = Error;
type Service = OpensslConnectorService<R, T>;
type InitError = E;
type Future = FutureResult<Self::Service, Self::InitError>;
fn new_service(&self) -> Self::Future {
ok(OpensslConnectorService {
connector: self.connector.clone(),
_t: PhantomData,
})
}
}
pub struct OpensslConnectorService<R, T> {
connector: SslConnector,
_t: PhantomData<(R, T)>,
}
impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service for OpensslConnectorService<R, T> {
type Request = (R, T);
type Response = (R, SslStream<T>);
type Error = Error;
type Future = ConnectAsyncExt<R, T>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
Ok(Async::Ready(()))
}
fn call(&mut self, (req, stream): Self::Request) -> Self::Future {
ConnectAsyncExt {
fut: SslConnectorExt::connect_async(&self.connector, req.host(), stream),
req: Some(req),
}
}
}
pub struct ConnectAsyncExt<R, T> {
req: Option<R>,
fut: ConnectAsync<T>,
}
impl<R, T> Future for ConnectAsyncExt<R, T>
where
R: RequestHost,
T: AsyncRead + AsyncWrite,
{
type Item = (R, SslStream<T>);
type Error = Error;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
match self.fut.poll()? {
Async::Ready(stream) => Ok(Async::Ready((self.req.take().unwrap(), stream))),
Async::NotReady => Ok(Async::NotReady),
}
}
}