mirror of
https://github.com/fafhrd91/actix-web
synced 2025-07-09 12:26:16 +02:00
Compare commits
29 Commits
v0.2.3
...
server-0.1
Author | SHA1 | Date | |
---|---|---|---|
d38eb00793 | |||
3c9d95bd9f | |||
331db2eb47 | |||
de66b5c776 | |||
4adbbad450 | |||
42ec3454d9 | |||
e6daca7995 | |||
d35c87d228 | |||
ba006d95c7 | |||
9577b7bbed | |||
8ad93f4838 | |||
ffb07c8884 | |||
cdd6904aa0 | |||
98a151db4f | |||
227ea15683 | |||
e50be58fdb | |||
3288b7648d | |||
43e14818c4 | |||
a60bf691d5 | |||
5f37d85f9b | |||
e8aa73a44b | |||
8fe7ce533c | |||
42a4679635 | |||
36a15efeac | |||
5937a06ebe | |||
a16ad6b2cd | |||
8108f19580 | |||
1b1ae01b5a | |||
c62567f85f |
25
.travis.yml
25
.travis.yml
@ -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
|
||||||
|
14
CHANGES.md
14
CHANGES.md
@ -1,5 +1,19 @@
|
|||||||
# 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
|
## [0.2.3] - 2018-11-17
|
||||||
|
|
||||||
### Added
|
### Added
|
||||||
|
85
Cargo.toml
85
Cargo.toml
@ -1,6 +1,6 @@
|
|||||||
[package]
|
[package]
|
||||||
name = "actix-net"
|
name = "actix-net"
|
||||||
version = "0.2.3"
|
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
|
|
||||||
|
@ -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
5
actix-codec/CHANGES.md
Normal file
@ -0,0 +1,5 @@
|
|||||||
|
# Changes
|
||||||
|
|
||||||
|
## [0.1.0] - 2018-12-09
|
||||||
|
|
||||||
|
* Move codec to separate crate
|
25
actix-codec/Cargo.toml
Normal file
25
actix-codec/Cargo.toml
Normal 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"
|
@ -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)));
|
||||||
}
|
}
|
@ -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};
|
||||||
|
|
||||||
@ -111,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()?)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -254,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
|
||||||
@ -266,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()?)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -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};
|
5
actix-connector/CHANGES.md
Normal file
5
actix-connector/CHANGES.md
Normal file
@ -0,0 +1,5 @@
|
|||||||
|
# Changes
|
||||||
|
|
||||||
|
## [0.1.0] - 2018-12-09
|
||||||
|
|
||||||
|
* Move server to separate crate
|
40
actix-connector/Cargo.toml
Normal file
40
actix-connector/Cargo.toml
Normal 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 }
|
@ -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 {
|
16
actix-connector/src/lib.rs
Normal file
16
actix-connector/src/lib.rs
Normal 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};
|
@ -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,
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
6
actix-connector/src/ssl/mod.rs
Normal file
6
actix-connector/src/ssl/mod.rs
Normal file
@ -0,0 +1,6 @@
|
|||||||
|
//! SSL Services
|
||||||
|
|
||||||
|
#[cfg(feature = "ssl")]
|
||||||
|
mod openssl;
|
||||||
|
#[cfg(feature = "ssl")]
|
||||||
|
pub use self::openssl::OpensslConnector;
|
106
actix-connector/src/ssl/openssl.rs
Normal file
106
actix-connector/src/ssl/openssl.rs
Normal 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
5
actix-rt/CHANGES.md
Normal file
@ -0,0 +1,5 @@
|
|||||||
|
# Changes
|
||||||
|
|
||||||
|
## [0.1.0] - 2018-12-09
|
||||||
|
|
||||||
|
* Initial release
|
27
actix-rt/Cargo.toml
Normal file
27
actix-rt/Cargo.toml
Normal 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
267
actix-rt/src/arbiter.rs
Normal 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
175
actix-rt/src/builder.rs
Normal 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
27
actix-rt/src/lib.rs
Normal 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
92
actix-rt/src/mod.rs
Normal 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
236
actix-rt/src/runtime.rs
Normal 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
118
actix-rt/src/system.rs
Normal 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
5
actix-server/CHANGES.md
Normal file
@ -0,0 +1,5 @@
|
|||||||
|
# Changes
|
||||||
|
|
||||||
|
## [0.1.0] - 2018-12-09
|
||||||
|
|
||||||
|
* Move server to separate crate
|
68
actix-server/Cargo.toml
Normal file
68
actix-server/Cargo.toml
Normal 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"
|
@ -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;
|
||||||
}
|
}
|
||||||
}
|
}
|
@ -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;
|
@ -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
33
actix-server/src/lib.rs
Normal 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()
|
||||||
|
}
|
69
actix-server/src/server.rs
Normal file
69
actix-server/src/server.rs
Normal 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(|_| ())
|
||||||
|
}
|
||||||
|
}
|
@ -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
116
actix-server/src/signals.rs
Normal 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)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
@ -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));
|
@ -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)),
|
99
actix-server/src/ssl/openssl.rs
Normal file
99
actix-server/src/ssl/openssl.rs
Normal 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()
|
||||||
|
}
|
||||||
|
}
|
@ -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),
|
@ -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
12
actix-service/CHANGES.md
Normal 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
26
actix-service/Cargo.toml
Normal 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"
|
@ -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"))
|
||||||
}
|
}
|
||||||
}
|
}
|
@ -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
32
actix-service/src/cell.rs
Normal 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() }
|
||||||
|
}
|
||||||
|
}
|
@ -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>,
|
@ -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<(), ()>;
|
@ -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
|
@ -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<(), ()>;
|
@ -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<(), ()>;
|
@ -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;
|
@ -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
5
actix-utils/CHANGES.md
Normal 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
28
actix-utils/Cargo.toml
Normal 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"
|
@ -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()
|
||||||
}
|
}
|
||||||
}
|
}
|
51
actix-utils/src/cloneable.rs
Normal file
51
actix-utils/src/cloneable.rs
Normal 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)
|
||||||
|
}
|
||||||
|
}
|
78
actix-utils/src/counter.rs
Normal file
78
actix-utils/src/counter.rs
Normal 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
|
||||||
|
}
|
||||||
|
}
|
@ -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;
|
@ -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)()))
|
||||||
}
|
}
|
||||||
}
|
}
|
@ -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;
|
||||||
|
|
@ -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
14
actix-utils/src/lib.rs
Normal 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 {}
|
@ -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) }
|
||||||
}
|
}
|
||||||
}
|
}
|
@ -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>;
|
@ -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>;
|
@ -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();
|
||||||
|
@ -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();
|
||||||
|
@ -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
|
||||||
|
@ -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)
|
|
||||||
}
|
|
||||||
}
|
|
@ -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: (),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
76
src/lib.rs
76
src/lib.rs
@ -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 {}
|
|
@ -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
|
|
||||||
}
|
|
||||||
}
|
|
@ -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),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
Reference in New Issue
Block a user