mirror of
https://github.com/fafhrd91/actix-web
synced 2025-07-25 02:05:37 +02:00
Compare commits
11 Commits
v0.2.2
...
service-v0
Author | SHA1 | Date | |
---|---|---|---|
|
5f37d85f9b | ||
|
e8aa73a44b | ||
|
8fe7ce533c | ||
|
42a4679635 | ||
|
36a15efeac | ||
|
5937a06ebe | ||
|
a16ad6b2cd | ||
|
8108f19580 | ||
|
1b1ae01b5a | ||
|
c62567f85f | ||
|
410204a41e |
@@ -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,7 @@ 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-service && cargo test
|
||||||
fi
|
fi
|
||||||
- |
|
- |
|
||||||
if [[ "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
|
if [[ "$TRAVIS_RUST_VERSION" == "nightly" ]]; then
|
||||||
@@ -40,6 +41,7 @@ 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"
|
||||||
|
cd actix-service && cargo tarpaulin --out Xml && bash <(curl -s https://codecov.io/bash)
|
||||||
fi
|
fi
|
||||||
|
|
||||||
# Upload docs
|
# Upload docs
|
||||||
|
18
CHANGES.md
18
CHANGES.md
@@ -1,5 +1,23 @@
|
|||||||
# Changes
|
# Changes
|
||||||
|
|
||||||
|
## [0.3.0] - xxx
|
||||||
|
|
||||||
|
* Use new `Service<Request>` trait
|
||||||
|
|
||||||
|
|
||||||
|
## [0.2.4] - 2018-11-21
|
||||||
|
|
||||||
|
### Added
|
||||||
|
|
||||||
|
* Allow to skip name resolution stage in Connector
|
||||||
|
|
||||||
|
|
||||||
|
## [0.2.3] - 2018-11-17
|
||||||
|
|
||||||
|
### Added
|
||||||
|
|
||||||
|
* Framed::is_write_buf_empty() checks if write buffer is flushed
|
||||||
|
|
||||||
## [0.2.2] - 2018-11-14
|
## [0.2.2] - 2018-11-14
|
||||||
|
|
||||||
### Added
|
### Added
|
||||||
|
13
Cargo.toml
13
Cargo.toml
@@ -1,6 +1,6 @@
|
|||||||
[package]
|
[package]
|
||||||
name = "actix-net"
|
name = "actix-net"
|
||||||
version = "0.2.2"
|
version = "0.3.0"
|
||||||
authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
|
authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
|
||||||
description = "Actix net - framework for the compisible network services for Rust (experimental)"
|
description = "Actix net - framework for the compisible network services for Rust (experimental)"
|
||||||
readme = "README.md"
|
readme = "README.md"
|
||||||
@@ -11,6 +11,13 @@ 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"
|
||||||
|
|
||||||
|
[workspace]
|
||||||
|
members = [
|
||||||
|
"./",
|
||||||
|
"actix-service",
|
||||||
|
]
|
||||||
|
|
||||||
[package.metadata.docs.rs]
|
[package.metadata.docs.rs]
|
||||||
features = ["ssl", "tls", "rust-tls"]
|
features = ["ssl", "tls", "rust-tls"]
|
||||||
@@ -40,6 +47,8 @@ cell = []
|
|||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
actix = "0.7.6"
|
actix = "0.7.6"
|
||||||
|
# actix-service = "0.1"
|
||||||
|
actix-service = { path="./actix-service" }
|
||||||
|
|
||||||
log = "0.4"
|
log = "0.4"
|
||||||
num_cpus = "1.0"
|
num_cpus = "1.0"
|
||||||
@@ -57,7 +66,7 @@ tokio-tcp = "0.1"
|
|||||||
tokio-timer = "0.2"
|
tokio-timer = "0.2"
|
||||||
tokio-reactor = "0.1"
|
tokio-reactor = "0.1"
|
||||||
tokio-current-thread = "0.1"
|
tokio-current-thread = "0.1"
|
||||||
tower-service = "0.1"
|
tower-service = { git = "https://github.com/tower-rs/tower.git" }
|
||||||
trust-dns-proto = "^0.5.0"
|
trust-dns-proto = "^0.5.0"
|
||||||
trust-dns-resolver = "^0.10.0"
|
trust-dns-resolver = "^0.10.0"
|
||||||
|
|
||||||
|
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.0"
|
||||||
|
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,70 @@ 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<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")),
|
@@ -80,7 +80,8 @@ fn main() {
|
|||||||
future::ok(())
|
future::ok(())
|
||||||
})
|
})
|
||||||
},
|
},
|
||||||
).unwrap()
|
)
|
||||||
|
.unwrap()
|
||||||
.start();
|
.start();
|
||||||
|
|
||||||
sys.run();
|
sys.run();
|
||||||
|
@@ -61,7 +61,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
|
||||||
|
13
src/cell.rs
13
src/cell.rs
@@ -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()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@@ -1,40 +1,51 @@
|
|||||||
|
use std::marker::PhantomData;
|
||||||
|
use std::rc::Rc;
|
||||||
|
|
||||||
use futures::Poll;
|
use futures::Poll;
|
||||||
|
|
||||||
use super::cell::Cell;
|
use super::cell::Cell;
|
||||||
use super::service::Service;
|
use super::service::Service;
|
||||||
|
|
||||||
/// Service that allows to turn non-clone service to a service with `Clone` impl
|
/// Service that allows to turn non-clone service to a service with `Clone` impl
|
||||||
pub struct CloneableService<S: Service + 'static> {
|
pub struct CloneableService<T: 'static> {
|
||||||
service: Cell<S>,
|
service: Cell<T>,
|
||||||
|
_t: PhantomData<Rc<()>>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<S: Service + 'static> CloneableService<S> {
|
impl<T: 'static> CloneableService<T> {
|
||||||
pub fn new(service: S) -> Self {
|
pub fn new<Request>(service: T) -> Self
|
||||||
|
where
|
||||||
|
T: Service<Request>,
|
||||||
|
{
|
||||||
Self {
|
Self {
|
||||||
service: Cell::new(service),
|
service: Cell::new(service),
|
||||||
|
_t: PhantomData,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<S: Service + 'static> Clone for CloneableService<S> {
|
impl<T: 'static> Clone for CloneableService<T> {
|
||||||
fn clone(&self) -> Self {
|
fn clone(&self) -> Self {
|
||||||
Self {
|
Self {
|
||||||
service: self.service.clone(),
|
service: self.service.clone(),
|
||||||
|
_t: PhantomData,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<S: Service + 'static> Service for CloneableService<S> {
|
impl<T: 'static, Request> Service<Request> for CloneableService<T>
|
||||||
type Request = S::Request;
|
where
|
||||||
type Response = S::Response;
|
T: Service<Request>,
|
||||||
type Error = S::Error;
|
{
|
||||||
type Future = S::Future;
|
type Response = T::Response;
|
||||||
|
type Error = T::Error;
|
||||||
|
type Future = T::Future;
|
||||||
|
|
||||||
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
|
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
|
||||||
self.service.borrow_mut().poll_ready()
|
self.service.borrow_mut().poll_ready()
|
||||||
}
|
}
|
||||||
|
|
||||||
fn call(&mut self, req: Self::Request) -> Self::Future {
|
fn call(&mut self, req: Request) -> Self::Future {
|
||||||
self.service.borrow_mut().call(req)
|
self.service.borrow_mut().call(req)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@@ -135,6 +135,11 @@ impl<T, U> Framed<T, U> {
|
|||||||
&mut self.inner.get_mut().get_mut().0
|
&mut self.inner.get_mut().get_mut().0
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Check if write buffer is empty.
|
||||||
|
pub fn is_write_buf_empty(&self) -> bool {
|
||||||
|
self.inner.get_ref().is_empty()
|
||||||
|
}
|
||||||
|
|
||||||
/// Check if write buffer is full.
|
/// Check if write buffer is full.
|
||||||
pub fn is_write_buf_full(&self) -> bool {
|
pub fn is_write_buf_full(&self) -> bool {
|
||||||
self.inner.get_ref().is_full()
|
self.inner.get_ref().is_full()
|
||||||
|
@@ -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};
|
||||||
|
|
||||||
@@ -77,6 +78,11 @@ impl<T, E> FramedWrite<T, E> {
|
|||||||
pub fn is_full(&self) -> bool {
|
pub fn is_full(&self) -> bool {
|
||||||
self.inner.is_full()
|
self.inner.is_full()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Check if write buffer is empty.
|
||||||
|
pub fn is_empty(&self) -> bool {
|
||||||
|
self.inner.is_empty()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T, E> FramedWrite<T, E>
|
impl<T, E> FramedWrite<T, E>
|
||||||
@@ -106,7 +112,7 @@ where
|
|||||||
}
|
}
|
||||||
|
|
||||||
fn close(&mut self) -> Poll<(), Self::SinkError> {
|
fn close(&mut self) -> Poll<(), Self::SinkError> {
|
||||||
Ok(try!(self.inner.close()))
|
Ok(self.inner.close()?)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -194,6 +200,10 @@ impl<T> FramedWrite2<T> {
|
|||||||
pub fn is_full(&self) -> bool {
|
pub fn is_full(&self) -> bool {
|
||||||
self.buffer.len() >= self.high_watermark
|
self.buffer.len() >= self.high_watermark
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn is_empty(&self) -> bool {
|
||||||
|
self.buffer.is_empty()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T> FramedWrite2<T>
|
impl<T> FramedWrite2<T>
|
||||||
@@ -245,7 +255,8 @@ where
|
|||||||
io::ErrorKind::WriteZero,
|
io::ErrorKind::WriteZero,
|
||||||
"failed to \
|
"failed to \
|
||||||
write frame to transport",
|
write frame to transport",
|
||||||
).into());
|
)
|
||||||
|
.into());
|
||||||
}
|
}
|
||||||
|
|
||||||
// TODO: Add a way to `bytes` to do this w/o returning the drained
|
// TODO: Add a way to `bytes` to do this w/o returning the drained
|
||||||
@@ -257,12 +268,12 @@ where
|
|||||||
try_ready!(self.inner.poll_flush());
|
try_ready!(self.inner.poll_flush());
|
||||||
|
|
||||||
trace!("framed transport flushed");
|
trace!("framed transport flushed");
|
||||||
return Ok(Async::Ready(()));
|
Ok(Async::Ready(()))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn close(&mut self) -> Poll<(), Self::SinkError> {
|
fn close(&mut self) -> Poll<(), Self::SinkError> {
|
||||||
try_ready!(self.poll_complete());
|
try_ready!(self.poll_complete());
|
||||||
Ok(try!(self.inner.shutdown()))
|
Ok(self.inner.shutdown()?)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@@ -4,10 +4,9 @@ use std::net::{IpAddr, SocketAddr};
|
|||||||
use std::time::Duration;
|
use std::time::Duration;
|
||||||
use std::{fmt, io};
|
use std::{fmt, io};
|
||||||
|
|
||||||
use futures::{
|
use futures::future::{ok, Either, FutureResult};
|
||||||
future::{ok, FutureResult},
|
use futures::{try_ready, Async, Future, Poll};
|
||||||
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;
|
||||||
@@ -58,17 +57,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 +88,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 +118,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 +168,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 +178,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 +195,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 {
|
||||||
|
ConnectKind::Host { .. } => Either::A(ConnectorFuture {
|
||||||
fut: self.resolver.call(req),
|
fut: self.resolver.call(req),
|
||||||
fut2: None,
|
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 +249,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 +272,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 +281,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 +352,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 +361,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 +370,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 {
|
||||||
|
@@ -1,5 +1,5 @@
|
|||||||
//! Contains `Either` service and related types and functions.
|
//! Contains `Either` service and related types and functions.
|
||||||
use futures::{future, Async, Future, Poll};
|
use futures::{future, try_ready, Async, Future, Poll};
|
||||||
|
|
||||||
use super::service::{NewService, Service};
|
use super::service::{NewService, Service};
|
||||||
|
|
||||||
@@ -13,12 +13,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 +29,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 +43,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 +63,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;
|
||||||
|
@@ -9,8 +9,8 @@ use futures::{Async, AsyncSink, Future, Poll, Sink, Stream};
|
|||||||
use tokio_codec::{Decoder, Encoder};
|
use tokio_codec::{Decoder, Encoder};
|
||||||
use tokio_io::{AsyncRead, AsyncWrite};
|
use tokio_io::{AsyncRead, AsyncWrite};
|
||||||
|
|
||||||
use codec::Framed;
|
use crate::codec::Framed;
|
||||||
use service::{IntoNewService, IntoService, NewService, Service};
|
use crate::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 +24,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 +50,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 +91,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 +109,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 +123,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 +137,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 +174,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 +188,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 +199,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 +246,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,
|
||||||
@@ -302,10 +300,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 +375,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 +387,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 {
|
||||||
if self.flushed {
|
|
||||||
return Err(err);
|
|
||||||
}
|
|
||||||
self.state = TransportState::Error(err);
|
self.state = TransportState::Error(err);
|
||||||
return Ok(Async::NotReady);
|
Ok(Async::NotReady)
|
||||||
}
|
}
|
||||||
TransportState::EncoderError(err) => return Err(err),
|
}
|
||||||
TransportState::Stopping => return Ok(Async::Ready(())),
|
TransportState::EncoderError(err) => Err(err),
|
||||||
|
TransportState::Stopping => Ok(Async::Ready(())),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -437,13 +431,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 +461,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 +475,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,4 +1,4 @@
|
|||||||
use futures::{Async, Future, Poll};
|
use futures::{try_ready, Async, Future, Poll};
|
||||||
|
|
||||||
use super::counter::{Counter, CounterGuard};
|
use super::counter::{Counter, CounterGuard};
|
||||||
use super::service::{IntoNewService, IntoService, NewService, Service};
|
use super::service::{IntoNewService, IntoService, NewService, Service};
|
||||||
@@ -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;
|
||||||
|
|
||||||
|
@@ -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)
|
||||||
}
|
}
|
||||||
|
50
src/lib.rs
50
src/lib.rs
@@ -7,54 +7,11 @@
|
|||||||
//! * `rust-tls` - enables ssl support via `rustls` crate
|
//! * `rust-tls` - enables ssl support via `rustls` crate
|
||||||
// #![warn(missing_docs)]
|
// #![warn(missing_docs)]
|
||||||
|
|
||||||
#![cfg_attr(
|
#![allow(
|
||||||
feature = "cargo-clippy",
|
clippy::declare_interior_mutable_const,
|
||||||
allow(
|
clippy::borrow_interior_mutable_const
|
||||||
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;
|
mod cell;
|
||||||
pub mod cloneable;
|
pub mod cloneable;
|
||||||
pub mod codec;
|
pub mod codec;
|
||||||
@@ -66,7 +23,6 @@ pub mod inflight;
|
|||||||
pub mod keepalive;
|
pub mod keepalive;
|
||||||
pub mod resolver;
|
pub mod resolver;
|
||||||
pub mod server;
|
pub mod server;
|
||||||
pub mod service;
|
|
||||||
pub mod ssl;
|
pub mod ssl;
|
||||||
pub mod stream;
|
pub mod stream;
|
||||||
pub mod time;
|
pub mod time;
|
||||||
|
@@ -70,8 +70,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,7 +79,7 @@ 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)
|
ResolverFuture::new(req, &self.resolver)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@@ -3,6 +3,7 @@ use std::time::{Duration, Instant};
|
|||||||
use std::{io, net, thread};
|
use std::{io, net, thread};
|
||||||
|
|
||||||
use futures::{sync::mpsc, Future};
|
use futures::{sync::mpsc, Future};
|
||||||
|
use log::{error, info};
|
||||||
use mio;
|
use mio;
|
||||||
use slab::Slab;
|
use slab::Slab;
|
||||||
use tokio_timer::Delay;
|
use tokio_timer::Delay;
|
||||||
@@ -134,7 +135,7 @@ 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,
|
||||||
|
@@ -2,10 +2,11 @@ use std::collections::HashMap;
|
|||||||
use std::{fmt, io, net};
|
use std::{fmt, io, net};
|
||||||
|
|
||||||
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 crate::service::{IntoNewService, NewService};
|
||||||
|
|
||||||
use super::server::bind_addr;
|
use super::server::bind_addr;
|
||||||
use super::services::{
|
use super::services::{
|
||||||
@@ -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 = ();
|
||||||
|
@@ -3,6 +3,7 @@ use std::{io, mem, net};
|
|||||||
|
|
||||||
use futures::sync::{mpsc, mpsc::unbounded};
|
use futures::sync::{mpsc, mpsc::unbounded};
|
||||||
use futures::{Future, Sink, Stream};
|
use futures::{Future, Sink, Stream};
|
||||||
|
use log::{error, info};
|
||||||
use net2::TcpBuilder;
|
use net2::TcpBuilder;
|
||||||
use num_cpus;
|
use num_cpus;
|
||||||
|
|
||||||
@@ -284,7 +285,7 @@ impl Server {
|
|||||||
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(format!("actix-net-worker-{}", idx)).do_send(Execute::new(move || {
|
||||||
Worker::start(rx1, rx2, services, avail, timeout.clone());
|
Worker::start(rx1, rx2, services, avail, timeout);
|
||||||
Ok::<_, ()>(())
|
Ok::<_, ()>(())
|
||||||
}));
|
}));
|
||||||
|
|
||||||
@@ -376,7 +377,7 @@ impl Handler<StopServer> for Server {
|
|||||||
}
|
}
|
||||||
|
|
||||||
if !self.workers.is_empty() {
|
if !self.workers.is_empty() {
|
||||||
Response::async(rx.into_future().map(|_| ()).map_err(|_| ()))
|
Response::r#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 {
|
||||||
|
@@ -3,13 +3,14 @@ use std::time::Duration;
|
|||||||
|
|
||||||
use futures::future::{err, ok, FutureResult};
|
use futures::future::{err, ok, FutureResult};
|
||||||
use futures::{Future, Poll};
|
use futures::{Future, Poll};
|
||||||
|
use log::error;
|
||||||
use tokio_current_thread::spawn;
|
use tokio_current_thread::spawn;
|
||||||
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};
|
use crate::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;
|
||||||
|
|
||||||
|
@@ -5,6 +5,7 @@ use std::{mem, net, time};
|
|||||||
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 log::{error, info, trace};
|
||||||
use tokio_current_thread::spawn;
|
use tokio_current_thread::spawn;
|
||||||
use tokio_timer::{sleep, Delay};
|
use tokio_timer::{sleep, Delay};
|
||||||
|
|
||||||
@@ -14,7 +15,7 @@ use actix::{Arbiter, Message};
|
|||||||
use super::accept::AcceptNotify;
|
use super::accept::AcceptNotify;
|
||||||
use super::services::{BoxedServerService, InternalServiceFactory, ServerMessage};
|
use super::services::{BoxedServerService, InternalServiceFactory, ServerMessage};
|
||||||
use super::Token;
|
use super::Token;
|
||||||
use counter::Counter;
|
use crate::counter::Counter;
|
||||||
|
|
||||||
pub(crate) struct WorkerCommand(Conn);
|
pub(crate) struct WorkerCommand(Conn);
|
||||||
|
|
||||||
@@ -167,7 +168,8 @@ impl Worker {
|
|||||||
.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().do_send(StopArbiter(0));
|
||||||
}).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 +194,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,8 +251,7 @@ 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();
|
let num = num_connections();
|
||||||
if num == 0 {
|
if num == 0 {
|
||||||
@@ -278,8 +279,6 @@ impl Future for Worker {
|
|||||||
return Ok(Async::Ready(()));
|
return Ok(Async::Ready(()));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
_ => (),
|
|
||||||
}
|
|
||||||
|
|
||||||
let state = mem::replace(&mut self.state, WorkerState::None);
|
let state = mem::replace(&mut self.state, WorkerState::None);
|
||||||
|
|
||||||
|
@@ -6,8 +6,8 @@ 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};
|
use crate::service::{NewService, Service};
|
||||||
|
|
||||||
/// Support `SSL` connections via native-tls package
|
/// Support `SSL` connections via native-tls package
|
||||||
///
|
///
|
||||||
@@ -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)),
|
||||||
|
@@ -6,9 +6,9 @@ use tokio_io::{AsyncRead, AsyncWrite};
|
|||||||
use tokio_openssl::{AcceptAsync, ConnectAsync, SslAcceptorExt, SslConnectorExt, SslStream};
|
use tokio_openssl::{AcceptAsync, ConnectAsync, SslAcceptorExt, SslConnectorExt, SslStream};
|
||||||
|
|
||||||
use super::MAX_CONN_COUNTER;
|
use super::MAX_CONN_COUNTER;
|
||||||
use counter::{Counter, CounterGuard};
|
use crate::counter::{Counter, CounterGuard};
|
||||||
use resolver::RequestHost;
|
use crate::resolver::RequestHost;
|
||||||
use service::{NewService, Service};
|
use crate::service::{NewService, Service};
|
||||||
|
|
||||||
/// Support `SSL` connections via openssl package
|
/// Support `SSL` connections via openssl package
|
||||||
///
|
///
|
||||||
@@ -37,8 +37,7 @@ impl<T: AsyncRead + AsyncWrite> Clone for OpensslAcceptor<T> {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: AsyncRead + AsyncWrite> NewService for OpensslAcceptor<T> {
|
impl<T: AsyncRead + AsyncWrite> NewService<T> for OpensslAcceptor<T> {
|
||||||
type Request = T;
|
|
||||||
type Response = SslStream<T>;
|
type Response = SslStream<T>;
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
type Service = OpensslAcceptorService<T>;
|
type Service = OpensslAcceptorService<T>;
|
||||||
@@ -62,8 +61,7 @@ pub struct OpensslAcceptorService<T> {
|
|||||||
conns: Counter,
|
conns: Counter,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<T: AsyncRead + AsyncWrite> Service for OpensslAcceptorService<T> {
|
impl<T: AsyncRead + AsyncWrite> Service<T> for OpensslAcceptorService<T> {
|
||||||
type Request = T;
|
|
||||||
type Response = SslStream<T>;
|
type Response = SslStream<T>;
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
type Future = OpensslAcceptorServiceFut<T>;
|
type Future = OpensslAcceptorServiceFut<T>;
|
||||||
@@ -76,7 +74,7 @@ impl<T: AsyncRead + AsyncWrite> Service for OpensslAcceptorService<T> {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn call(&mut self, req: Self::Request) -> Self::Future {
|
fn call(&mut self, req: T) -> Self::Future {
|
||||||
OpensslAcceptorServiceFut {
|
OpensslAcceptorServiceFut {
|
||||||
_guard: self.conns.get(),
|
_guard: self.conns.get(),
|
||||||
fut: SslAcceptorExt::accept_async(&self.acceptor, req),
|
fut: SslAcceptorExt::accept_async(&self.acceptor, req),
|
||||||
@@ -119,7 +117,7 @@ impl<R, T, E> OpensslConnector<R, T, E> {
|
|||||||
impl<R: RequestHost, T: AsyncRead + AsyncWrite> OpensslConnector<R, T, ()> {
|
impl<R: RequestHost, T: AsyncRead + AsyncWrite> OpensslConnector<R, T, ()> {
|
||||||
pub fn service(
|
pub fn service(
|
||||||
connector: SslConnector,
|
connector: SslConnector,
|
||||||
) -> impl Service<Request = (R, T), Response = (R, SslStream<T>), Error = Error> {
|
) -> impl Service<(R, T), Response = (R, SslStream<T>), Error = Error> {
|
||||||
OpensslConnectorService {
|
OpensslConnectorService {
|
||||||
connector: connector,
|
connector: connector,
|
||||||
_t: PhantomData,
|
_t: PhantomData,
|
||||||
@@ -136,8 +134,9 @@ impl<R, T, E> Clone for OpensslConnector<R, T, E> {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService for OpensslConnector<R, T, E> {
|
impl<R: RequestHost, T: AsyncRead + AsyncWrite, E> NewService<(R, T)>
|
||||||
type Request = (R, T);
|
for OpensslConnector<R, T, E>
|
||||||
|
{
|
||||||
type Response = (R, SslStream<T>);
|
type Response = (R, SslStream<T>);
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
type Service = OpensslConnectorService<R, T>;
|
type Service = OpensslConnectorService<R, T>;
|
||||||
@@ -157,8 +156,9 @@ pub struct OpensslConnectorService<R, T> {
|
|||||||
_t: PhantomData<(R, T)>,
|
_t: PhantomData<(R, T)>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service for OpensslConnectorService<R, T> {
|
impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service<(R, T)>
|
||||||
type Request = (R, T);
|
for OpensslConnectorService<R, T>
|
||||||
|
{
|
||||||
type Response = (R, SslStream<T>);
|
type Response = (R, SslStream<T>);
|
||||||
type Error = Error;
|
type Error = Error;
|
||||||
type Future = ConnectAsyncExt<R, T>;
|
type Future = ConnectAsyncExt<R, T>;
|
||||||
@@ -167,7 +167,7 @@ impl<R: RequestHost, T: AsyncRead + AsyncWrite> Service for OpensslConnectorServ
|
|||||||
Ok(Async::Ready(()))
|
Ok(Async::Ready(()))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn call(&mut self, (req, stream): Self::Request) -> Self::Future {
|
fn call(&mut self, (req, stream): (R, T)) -> Self::Future {
|
||||||
ConnectAsyncExt {
|
ConnectAsyncExt {
|
||||||
fut: SslConnectorExt::connect_async(&self.connector, req.host(), stream),
|
fut: SslConnectorExt::connect_async(&self.connector, req.host(), stream),
|
||||||
req: Some(req),
|
req: Some(req),
|
||||||
|
@@ -8,8 +8,8 @@ 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};
|
use crate::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),
|
||||||
|
@@ -17,10 +17,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 +38,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 +106,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 +141,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 +150,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) }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@@ -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,15 @@
|
|||||||
use std::fmt;
|
use std::fmt;
|
||||||
use std::time::Duration;
|
use std::time::Duration;
|
||||||
|
|
||||||
|
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};
|
use crate::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 +35,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 +90,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 +107,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 +129,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>;
|
||||||
|
Reference in New Issue
Block a user