actix/actix-net
1
0
Fork 0
mirror of https://github.com/fafhrd91/actix-net synced 2024-11-27 20:12:58 +01:00
Code Issues Releases Wiki Activity

Merge branch 'master' of github.com:actix/actix-net

Browse Source
This commit is contained in:
Nikolay Kim 2019-05-14 17:36:18 -07:00
commit d51b210ae7
1 changed files with 531 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

537
actix-tower/src/lib.rs
View File

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