mirrors/ntex
1
0
Fork 0
mirror of https://github.com/ntex-rs/ntex.git synced 2025-04-03 21:07:39 +03:00
Code Issues Projects Releases Packages Wiki Activity

move service to ntex-service

Browse source
This commit is contained in:
Nikolay Kim 2020-02-26 10:45:29 -08:00
parent e8d60d728a
commit c910e595a2
66 changed files with 825 additions and 494 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Cargo.toml
View file

@ -1,6 +1,7 @@
[workspace]
members = [
"ntex",
"ntex-service",
"ntex-web-macros",
"actix-net/actix-server",
@ -9,6 +10,9 @@ members = [
]
[patch.crates-io]
ntex = { path = "ntex" }
ntex-service = { path = "ntex-service" }
actix-server = { path = "actix-net/actix-server" }
actix-service = { path = "actix-net/actix-service" }
actix-router = { path = "actix-net/router" }

10
actix-net/actix-server/tests/test_server.rs
View file

@ -82,12 +82,10 @@ fn test_start() {
.backlog(100)
.disable_signals()
.bind("test", addr, move || {
fn_service(|io: TcpStream| {
async move {
let mut f = Framed::new(io, BytesCodec);
f.send(Bytes::from_static(b"test")).await.unwrap();
Ok::<_, ()>(())
}
fn_service(|io: TcpStream| async move {
let mut f = Framed::new(io, BytesCodec);
f.send(Bytes::from_static(b"test")).await.unwrap();
Ok::<_, ()>(())
})
})
.unwrap()

6
actix-net/actix-service/Cargo.toml
View file

@ -20,8 +20,4 @@ name = "actix_service"
path = "src/lib.rs"
[dependencies]
futures-util = "0.3.1"
pin-project = "0.4.6"
[dev-dependencies]
actix-rt = "1.0.0"
ntex-service = "1.0.5"

387
actix-net/actix-service/src/lib.rs
View file

@ -1,386 +1 @@
#![deny(rust_2018_idioms, warnings)]
#![allow(clippy::type_complexity)]
use std::cell::RefCell;
use std::future::Future;
use std::rc::Rc;
use std::sync::Arc;
use std::task::{self, Context, Poll};
mod and_then;
mod and_then_apply_fn;
mod apply;
mod apply_cfg;
pub mod boxed;
mod cell;
mod fn_service;
mod map;
mod map_config;
mod map_err;
mod map_init_err;
mod pipeline;
mod then;
mod transform;
mod transform_err;
pub use self::apply::{apply_fn, apply_fn_factory};
pub use self::apply_cfg::{apply_cfg, apply_cfg_factory};
pub use self::fn_service::{fn_factory, fn_factory_with_config, fn_service};
pub use self::map_config::{map_config, unit_config};
pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory};
pub use self::transform::{apply, Transform};
/// An asynchronous function from `Request` to a `Response`.
///
/// `Service` represents a service that represanting interation, taking requests and giving back
/// replies. You can think about service as a function with one argument and result as a return
/// type. In general form it looks like `async fn(Req) -> Result<Res, Err>`. `Service`
/// trait just generalizing form of this function. Each parameter described as an assotiated type.
///
/// Services provides a symmetric and uniform API, same abstractions represents
/// clients and servers. Services describe only `transforamtion` operation
/// which encorouge to simplify api surface and phrases `value transformation`.
/// That leads to simplier design of each service. That also allows better testability
/// and better composition.
///
/// Services could be represented in several different forms. In general,
/// Service is a type that implements `Service` trait.
///
/// ```rust,ignore
/// struct MyService;
///
/// impl Service for MyService {
/// type Request = u8;
/// type Response = u64;
/// type Error = MyError;
/// type Future = Pin<Box<Future<Output=Result<Self::Response, Self::Error>>>;
///
/// fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { ... }
///
/// fn call(&mut self, req: Self::Request) -> Self::Future { ... }
/// }
/// ```
///
/// Service can have mutable state that influence computation.
/// This service could be rewritten as a simple function:
///
/// ```rust,ignore
/// async fn my_service(req: u8) -> Result<u64, MyError>;
/// ```
pub trait Service {
/// Requests handled by the service.
type Request;
/// Responses given by the service.
type Response;
/// Errors produced by the service.
type Error;
/// The future response value.
type Future: Future<Output = Result<Self::Response, Self::Error>>;
/// Returns `Ready` when the service is able to process requests.
///
/// If the service is at capacity, then `Pending` 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.
///
/// There are several notes to consider:
///
/// 1. `.poll_ready()` might be called on different task from actual service call.
///
/// 2. In case of chained services, `.poll_ready()` get called for all services at once.
fn poll_ready(&mut self, ctx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>>;
#[inline]
#[allow(unused_variables)]
/// Shutdown service.
///
/// Returns `Ready` when the service is properly shutdowned. This method might be called
/// after it returns `Ready`.
fn poll_shutdown(&mut self, ctx: &mut task::Context<'_>, is_error: bool) -> Poll<()> {
Poll::Ready(())
}
/// Process the request and return the response asynchronously.
///
/// This function is expected to be callable off task. As such,
/// implementations should take care to not call `poll_ready`. If the
/// service is at capacity and the request is unable to be handled, the
/// returned `Future` should resolve to an error.
///
/// Calling `call` without calling `poll_ready` is permitted. The
/// implementation must be resilient to this fact.
fn call(&mut self, req: Self::Request) -> Self::Future;
#[inline]
/// Map this service's output to a different type, returning a new service
/// of the resulting type.
///
/// This function is similar to the `Option::map` or `Iterator::map` where
/// it will change the type of the underlying service.
///
/// Note that this function consumes the receiving service and returns a
/// wrapped version of it, similar to the existing `map` methods in the
/// standard library.
fn map<F, R>(self, f: F) -> crate::dev::Map<Self, F, R>
where
Self: Sized,
F: FnMut(Self::Response) -> R,
{
crate::dev::Map::new(self, f)
}
#[inline]
/// Map this service's error to a different error, returning a new service.
///
/// This function is similar to the `Result::map_err` where it will change
/// the error type of the underlying service. This is useful for example to
/// ensure that services have the same error type.
///
/// Note that this function consumes the receiving service and returns a
/// wrapped version of it.
fn map_err<F, E>(self, f: F) -> crate::dev::MapErr<Self, F, E>
where
Self: Sized,
F: Fn(Self::Error) -> E,
{
crate::dev::MapErr::new(self, f)
}
}
/// Creates new `Service` values.
///
/// Acts as a service factory. This is useful for cases where new `Service`
/// values must be produced. One case is a TCP server listener. The listener
/// accepts new TCP streams, obtains a new `Service` value using the
/// `ServiceFactory` trait, and uses that new `Service` value to process inbound
/// requests on that new TCP stream.
///
/// `Config` is a service factory configuration type.
pub trait ServiceFactory {
/// Requests handled by the service.
type Request;
/// Responses given by the service
type Response;
/// Errors produced by the service
type Error;
/// Service factory configuration
type Config;
/// The `Service` value created by this factory
type Service: Service<
Request = Self::Request,
Response = Self::Response,
Error = Self::Error,
>;
/// Errors produced while building a service.
type InitError;
/// The future of the `Service` instance.
type Future: Future<Output = Result<Self::Service, Self::InitError>>;
/// Create and return a new service value asynchronously.
fn new_service(&self, cfg: Self::Config) -> Self::Future;
/// Map this service's output to a different type, returning a new service
/// of the resulting type.
fn map<F, R>(self, f: F) -> crate::map::MapServiceFactory<Self, F, R>
where
Self: Sized,
F: FnMut(Self::Response) -> R + Clone,
{
crate::map::MapServiceFactory::new(self, f)
}
/// Map this service's error to a different error, returning a new service.
fn map_err<F, E>(self, f: F) -> crate::map_err::MapErrServiceFactory<Self, F, E>
where
Self: Sized,
F: Fn(Self::Error) -> E + Clone,
{
crate::map_err::MapErrServiceFactory::new(self, f)
}
/// Map this factory's init error to a different error, returning a new service.
fn map_init_err<F, E>(self, f: F) -> crate::map_init_err::MapInitErr<Self, F, E>
where
Self: Sized,
F: Fn(Self::InitError) -> E + Clone,
{
crate::map_init_err::MapInitErr::new(self, f)
}
}
impl<'a, S> Service for &'a mut S
where
S: Service + 'a,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Future = S::Future;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
(**self).poll_ready(ctx)
}
fn call(&mut self, request: Self::Request) -> S::Future {
(**self).call(request)
}
}
impl<S> Service for Box<S>
where
S: Service + ?Sized,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Future = S::Future;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
(**self).poll_ready(ctx)
}
fn call(&mut self, request: Self::Request) -> S::Future {
(**self).call(request)
}
}
impl<S> Service for RefCell<S>
where
S: Service,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Future = S::Future;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.borrow_mut().poll_ready(ctx)
}
fn call(&mut self, request: Self::Request) -> S::Future {
self.borrow_mut().call(request)
}
}
impl<S> Service for Rc<RefCell<S>>
where
S: Service,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Future = S::Future;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.borrow_mut().poll_ready(ctx)
}
fn call(&mut self, request: Self::Request) -> S::Future {
(&mut (**self).borrow_mut()).call(request)
}
}
impl<S> ServiceFactory for Rc<S>
where
S: ServiceFactory,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Config = S::Config;
type Service = S::Service;
type InitError = S::InitError;
type Future = S::Future;
fn new_service(&self, cfg: S::Config) -> S::Future {
self.as_ref().new_service(cfg)
}
}
impl<S> ServiceFactory for Arc<S>
where
S: ServiceFactory,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Config = S::Config;
type Service = S::Service;
type InitError = S::InitError;
type Future = S::Future;
fn new_service(&self, cfg: S::Config) -> S::Future {
self.as_ref().new_service(cfg)
}
}
/// Trait for types that can be converted to a `Service`
pub trait IntoService<T>
where
T: Service,
{
/// Convert to a `Service`
fn into_service(self) -> T;
}
/// Trait for types that can be converted to a `ServiceFactory`
pub trait IntoServiceFactory<T>
where
T: ServiceFactory,
{
/// Convert `Self` to a `ServiceFactory`
fn into_factory(self) -> T;
}
impl<T> IntoService<T> for T
where
T: Service,
{
fn into_service(self) -> T {
self
}
}
impl<T> IntoServiceFactory<T> for T
where
T: ServiceFactory,
{
fn into_factory(self) -> T {
self
}
}
/// Convert object of type `T` to a service `S`
pub fn into_service<T, S>(tp: T) -> S
where
S: Service,
T: IntoService<S>,
{
tp.into_service()
}
pub mod dev {
pub use crate::apply::{Apply, ApplyServiceFactory};
pub use crate::fn_service::{
FnService, FnServiceConfig, FnServiceFactory, FnServiceNoConfig,
};
pub use crate::map::{Map, MapServiceFactory};
pub use crate::map_config::{MapConfig, UnitConfig};
pub use crate::map_err::{MapErr, MapErrServiceFactory};
pub use crate::map_init_err::MapInitErr;
pub use crate::transform::ApplyTransform;
pub use crate::transform_err::TransformMapInitErr;
}
pub use ntex_service::*;

273
ntex-service/CHANGES.md Normal file
View file

@ -0,0 +1,273 @@
# Changes
## [1.0.5] - 2020-01-16
### Fixed
* Fixed unsoundness in .and_then()/.then() service combinators
## [1.0.4] - 2020-01-15
### Fixed
* Revert 1.0.3 change
## [1.0.3] - 2020-01-15
### Fixed
* Fixed unsoundness in `AndThenService` impl
## [1.0.2] - 2020-01-08
### Added
* Add `into_service` helper function
## [1.0.1] - 2019-12-22
### Changed
* `map_config()` and `unit_config()` accepts `IntoServiceFactory` type
## [1.0.0] - 2019-12-11
### Added
* Add Clone impl for Apply service
## [1.0.0-alpha.4] - 2019-12-08
### Changed
* Renamed `service_fn` to `fn_service`
* Renamed `factory_fn` to `fn_factory`
* Renamed `factory_fn_cfg` to `fn_factory_with_config`
## [1.0.0-alpha.3] - 2019-12-06
### Changed
* Add missing Clone impls
* Restore `Transform::map_init_err()` combinator
* Restore `Service/Factory::apply_fn()` in form of `Pipeline/Factory::and_then_apply_fn()`
* Optimize service combinators and futures memory layout
## [1.0.0-alpha.2] - 2019-12-02
### Changed
* Use owned config value for service factory
* Renamed BoxedNewService/BoxedService to BoxServiceFactory/BoxService
## [1.0.0-alpha.1] - 2019-11-25
### Changed
* Migraded to `std::future`
* `NewService` renamed to `ServiceFactory`
* Added `pipeline` and `pipeline_factory` function
## [0.4.2] - 2019-08-27
### Fixed
* Check service readiness for `new_apply_cfg` combinator
## [0.4.1] - 2019-06-06
### Added
* Add `new_apply_cfg` function
## [0.4.0] - 2019-05-12
### Changed
* Use associated type for `NewService` config
* Change `apply_cfg` function
* Renamed helper functions
### Added
* Add `NewService::map_config` and `NewService::unit_config` combinators
## [0.3.6] - 2019-04-07
### Changed
* Poll boxed service call result immediately
## [0.3.5] - 2019-03-29
### Added
* Add `impl<S: Service> Service for Rc<RefCell<S>>`
## [0.3.4] - 2019-03-12
### Added
* Add `Transform::from_err()` combinator
* Add `apply_fn` helper
* Add `apply_fn_factory` helper
* Add `apply_transform` helper
* Add `apply_cfg` helper
## [0.3.3] - 2019-03-09
### Added
* Add `ApplyTransform` new service for transform and new service.
* Add `NewService::apply_cfg()` combinator, allows to use
nested `NewService` with different config parameter.
### Changed
* Revert IntoFuture change
## [0.3.2] - 2019-03-04
### Changed
* Change `NewService::Future` and `Transform::Future` to the `IntoFuture` trait.
* Export `AndThenTransform` type
## [0.3.1] - 2019-03-04
### Changed
* Simplify Transform trait
## [0.3.0] - 2019-03-02
## Added
* Added boxed NewService and Service.
## Changed
* Added `Config` parameter to `NewService` trait.
* Added `Config` parameter to `NewTransform` trait.
## [0.2.2] - 2019-02-19
### Added
* Added `NewService` impl for `Rc<S> where S: NewService`
* Added `NewService` impl for `Arc<S> where S: NewService`
## [0.2.1] - 2019-02-03
### Changed
* Generalize `.apply` combinator with Transform trait
## [0.2.0] - 2019-02-01
### Changed
* Use associated type instead of generic for Service definition.
* Before:
```rust
impl Service<Request> for Client {
type Response = Response;
// ...
}
```
* After:
```rust
impl Service for Client {
type Request = Request;
type Response = Response;
// ...
}
```
## [0.1.6] - 2019-01-24
### Changed
* Use `FnMut` instead of `Fn` for .apply() and .map() combinators and `FnService` type
* Change `.apply()` error semantic, new service's error is `From<Self::Error>`
## [0.1.5] - 2019-01-13
### Changed
* Make `Out::Error` convertable from `T::Error` for apply combinator
## [0.1.4] - 2019-01-11
### Changed
* Use `FnMut` instead of `Fn` for `FnService`
## [0.1.3] - 2018-12-12
### Changed
* Split service combinators to separate trait
## [0.1.2] - 2018-12-12
### Fixed
* Release future early for `.and_then()` and `.then()` combinators
## [0.1.1] - 2018-12-09
### Added
* Added Service impl for Box<S: Service>
## [0.1.0] - 2018-12-09
* Initial import

23
ntex-service/Cargo.toml Normal file
View file

@ -0,0 +1,23 @@
[package]
name = "ntex-service"
version = "1.0.5"
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"
edition = "2018"
[lib]
name = "ntex_service"
path = "src/lib.rs"
[dependencies]
futures-util = "0.3.1"
pin-project = "0.4.6"
[dev-dependencies]
actix-rt = "1.0.0"

4
actix-net/actix-service/src/and_then.rs → ntex-service/src/and_then.rs
View file

@ -117,7 +117,9 @@ where
this.state.set(State::Empty);
r
}),
State::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
State::Empty => {
panic!("future must not be polled after it returned `Poll::Ready`")
}
}
}
}

21
actix-net/actix-service/src/and_then_apply_fn.rs → ntex-service/src/and_then_apply_fn.rs
View file

@ -156,7 +156,9 @@ where
this.state.set(State::Empty);
r
}),
State::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
State::Empty => {
panic!("future must not be polled after it returned `Poll::Ready`")
}
}
}
}
@ -193,7 +195,8 @@ impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFnFactory<A, B, F, Fut, Res,
}
}
impl<A, B, F, Fut, Res, Err> ServiceFactory for AndThenApplyFnFactory<A, B, F, Fut, Res, Err>
impl<A, B, F, Fut, Res, Err> ServiceFactory
for AndThenApplyFnFactory<A, B, F, Fut, Res, Err>
where
A: ServiceFactory,
A::Config: Clone,
@ -241,7 +244,8 @@ where
b: Option<B::Service>,
}
impl<A, B, F, Fut, Res, Err> Future for AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>
impl<A, B, F, Fut, Res, Err> Future
for AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>
where
A: ServiceFactory,
B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
@ -323,11 +327,12 @@ mod tests {
#[actix_rt::test]
async fn test_service_factory() {
let new_srv = pipeline_factory(|| ok::<_, ()>(fn_service(|r: &'static str| ok(r))))
.and_then_apply_fn(
|| ok(Srv),
|req: &'static str, s| s.call(()).map_ok(move |res| (req, res)),
);
let new_srv =
pipeline_factory(|| ok::<_, ()>(fn_service(|r: &'static str| ok(r))))
.and_then_apply_fn(
|| ok(Srv),
|req: &'static str, s| s.call(()).map_ok(move |res| (req, res)),
);
let mut srv = new_srv.new_service(()).await.unwrap();
let res = lazy(|cx| srv.poll_ready(cx)).await;
assert_eq!(res, Poll::Ready(Ok(())));

5
actix-net/actix-service/src/apply.rs → ntex-service/src/apply.rs
View file

@ -6,7 +6,10 @@ use std::task::{Context, Poll};
use super::{IntoService, IntoServiceFactory, Service, ServiceFactory};
/// Apply tranform function to a service.
pub fn apply_fn<T, F, R, In, Out, Err, U>(service: U, f: F) -> Apply<T, F, R, In, Out, Err>
pub fn apply_fn<T, F, R, In, Out, Err, U>(
service: U,
f: F,
) -> Apply<T, F, R, In, Out, Err>
where
T: Service<Error = Err>,
F: FnMut(In, &mut T) -> R,

0
actix-net/actix-service/src/apply_cfg.rs → ntex-service/src/apply_cfg.rs
View file

17
actix-net/actix-service/src/boxed.rs → ntex-service/src/boxed.rs
View file

@ -8,10 +8,18 @@ use crate::{Service, ServiceFactory};
pub type BoxFuture<I, E> = Pin<Box<dyn Future<Output = Result<I, E>>>>;
pub type BoxService<Req, Res, Err> =
Box<dyn Service<Request = Req, Response = Res, Error = Err, Future = BoxFuture<Res, Err>>>;
pub type BoxService<Req, Res, Err> = Box<
dyn Service<
Request = Req,
Response = Res,
Error = Err,
Future = BoxFuture<Res, Err>,
>,
>;
pub struct BoxServiceFactory<C, Req, Res, Err, InitErr>(Inner<C, Req, Res, Err, InitErr>);
pub struct BoxServiceFactory<C, Req, Res, Err, InitErr>(
Inner<C, Req, Res, Err, InitErr>,
);
/// Create boxed service factory
pub fn factory<T>(
@ -53,7 +61,8 @@ type Inner<C, Req, Res, Err, InitErr> = Box<
>,
>;
impl<C, Req, Res, Err, InitErr> ServiceFactory for BoxServiceFactory<C, Req, Res, Err, InitErr>
impl<C, Req, Res, Err, InitErr> ServiceFactory
for BoxServiceFactory<C, Req, Res, Err, InitErr>
where
Req: 'static,
Res: 'static,

0
actix-net/actix-service/src/cell.rs → ntex-service/src/cell.rs
View file

7
actix-net/actix-service/src/fn_service.rs → ntex-service/src/fn_service.rs
View file

@ -53,7 +53,9 @@ where
/// Ok(())
/// }
/// ```
pub fn fn_factory<F, Cfg, Srv, Fut, Err>(f: F) -> FnServiceNoConfig<F, Cfg, Srv, Fut, Err>
pub fn fn_factory<F, Cfg, Srv, Fut, Err>(
f: F,
) -> FnServiceNoConfig<F, Cfg, Srv, Fut, Err>
where
Srv: Service,
F: Fn() -> Fut,
@ -209,7 +211,8 @@ where
}
}
impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
impl<F, Fut, Req, Res, Err, Cfg> ServiceFactory
for FnServiceFactory<F, Fut, Req, Res, Err, Cfg>
where
F: FnMut(Req) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>,

393
ntex-service/src/lib.rs Normal file
View file

@ -0,0 +1,393 @@
#![deny(rust_2018_idioms, warnings)]
#![allow(clippy::type_complexity)]
use std::cell::RefCell;
use std::future::Future;
use std::rc::Rc;
use std::sync::Arc;
use std::task::{self, Context, Poll};
mod and_then;
mod and_then_apply_fn;
mod apply;
mod apply_cfg;
pub mod boxed;
mod cell;
mod fn_service;
mod map;
mod map_config;
mod map_err;
mod map_init_err;
mod pipeline;
mod then;
mod transform;
mod transform_err;
pub use self::apply::{apply_fn, apply_fn_factory};
pub use self::apply_cfg::{apply_cfg, apply_cfg_factory};
pub use self::fn_service::{fn_factory, fn_factory_with_config, fn_service};
pub use self::map_config::{map_config, unit_config};
pub use self::pipeline::{pipeline, pipeline_factory, Pipeline, PipelineFactory};
pub use self::transform::{apply, Transform};
/// An asynchronous function from `Request` to a `Response`.
///
/// `Service` represents a service that represanting interation, taking requests and giving back
/// replies. You can think about service as a function with one argument and result as a return
/// type. In general form it looks like `async fn(Req) -> Result<Res, Err>`. `Service`
/// trait just generalizing form of this function. Each parameter described as an assotiated type.
///
/// Services provides a symmetric and uniform API, same abstractions represents
/// clients and servers. Services describe only `transforamtion` operation
/// which encorouge to simplify api surface and phrases `value transformation`.
/// That leads to simplier design of each service. That also allows better testability
/// and better composition.
///
/// Services could be represented in several different forms. In general,
/// Service is a type that implements `Service` trait.
///
/// ```rust,ignore
/// struct MyService;
///
/// impl Service for MyService {
/// type Request = u8;
/// type Response = u64;
/// type Error = MyError;
/// type Future = Pin<Box<Future<Output=Result<Self::Response, Self::Error>>>;
///
/// fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { ... }
///
/// fn call(&mut self, req: Self::Request) -> Self::Future { ... }
/// }
/// ```
///
/// Service can have mutable state that influence computation.
/// This service could be rewritten as a simple function:
///
/// ```rust,ignore
/// async fn my_service(req: u8) -> Result<u64, MyError>;
/// ```
pub trait Service {
/// Requests handled by the service.
type Request;
/// Responses given by the service.
type Response;
/// Errors produced by the service.
type Error;
/// The future response value.
type Future: Future<Output = Result<Self::Response, Self::Error>>;
/// Returns `Ready` when the service is able to process requests.
///
/// If the service is at capacity, then `Pending` 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.
///
/// There are several notes to consider:
///
/// 1. `.poll_ready()` might be called on different task from actual service call.
///
/// 2. In case of chained services, `.poll_ready()` get called for all services at once.
fn poll_ready(
&mut self,
ctx: &mut task::Context<'_>,
) -> Poll<Result<(), Self::Error>>;
#[inline]
#[allow(unused_variables)]
/// Shutdown service.
///
/// Returns `Ready` when the service is properly shutdowned. This method might be called
/// after it returns `Ready`.
fn poll_shutdown(
&mut self,
ctx: &mut task::Context<'_>,
is_error: bool,
) -> Poll<()> {
Poll::Ready(())
}
/// Process the request and return the response asynchronously.
///
/// This function is expected to be callable off task. As such,
/// implementations should take care to not call `poll_ready`. If the
/// service is at capacity and the request is unable to be handled, the
/// returned `Future` should resolve to an error.
///
/// Calling `call` without calling `poll_ready` is permitted. The
/// implementation must be resilient to this fact.
fn call(&mut self, req: Self::Request) -> Self::Future;
#[inline]
/// Map this service's output to a different type, returning a new service
/// of the resulting type.
///
/// This function is similar to the `Option::map` or `Iterator::map` where
/// it will change the type of the underlying service.
///
/// Note that this function consumes the receiving service and returns a
/// wrapped version of it, similar to the existing `map` methods in the
/// standard library.
fn map<F, R>(self, f: F) -> crate::dev::Map<Self, F, R>
where
Self: Sized,
F: FnMut(Self::Response) -> R,
{
crate::dev::Map::new(self, f)
}
#[inline]
/// Map this service's error to a different error, returning a new service.
///
/// This function is similar to the `Result::map_err` where it will change
/// the error type of the underlying service. This is useful for example to
/// ensure that services have the same error type.
///
/// Note that this function consumes the receiving service and returns a
/// wrapped version of it.
fn map_err<F, E>(self, f: F) -> crate::dev::MapErr<Self, F, E>
where
Self: Sized,
F: Fn(Self::Error) -> E,
{
crate::dev::MapErr::new(self, f)
}
}
/// Creates new `Service` values.
///
/// Acts as a service factory. This is useful for cases where new `Service`
/// values must be produced. One case is a TCP server listener. The listener
/// accepts new TCP streams, obtains a new `Service` value using the
/// `ServiceFactory` trait, and uses that new `Service` value to process inbound
/// requests on that new TCP stream.
///
/// `Config` is a service factory configuration type.
pub trait ServiceFactory {
/// Requests handled by the service.
type Request;
/// Responses given by the service
type Response;
/// Errors produced by the service
type Error;
/// Service factory configuration
type Config;
/// The `Service` value created by this factory
type Service: Service<
Request = Self::Request,
Response = Self::Response,
Error = Self::Error,
>;
/// Errors produced while building a service.
type InitError;
/// The future of the `Service` instance.
type Future: Future<Output = Result<Self::Service, Self::InitError>>;
/// Create and return a new service value asynchronously.
fn new_service(&self, cfg: Self::Config) -> Self::Future;
/// Map this service's output to a different type, returning a new service
/// of the resulting type.
fn map<F, R>(self, f: F) -> crate::map::MapServiceFactory<Self, F, R>
where
Self: Sized,
F: FnMut(Self::Response) -> R + Clone,
{
crate::map::MapServiceFactory::new(self, f)
}
/// Map this service's error to a different error, returning a new service.
fn map_err<F, E>(self, f: F) -> crate::map_err::MapErrServiceFactory<Self, F, E>
where
Self: Sized,
F: Fn(Self::Error) -> E + Clone,
{
crate::map_err::MapErrServiceFactory::new(self, f)
}
/// Map this factory's init error to a different error, returning a new service.
fn map_init_err<F, E>(self, f: F) -> crate::map_init_err::MapInitErr<Self, F, E>
where
Self: Sized,
F: Fn(Self::InitError) -> E + Clone,
{
crate::map_init_err::MapInitErr::new(self, f)
}
}
impl<'a, S> Service for &'a mut S
where
S: Service + 'a,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Future = S::Future;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
(**self).poll_ready(ctx)
}
fn call(&mut self, request: Self::Request) -> S::Future {
(**self).call(request)
}
}
impl<S> Service for Box<S>
where
S: Service + ?Sized,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Future = S::Future;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), S::Error>> {
(**self).poll_ready(ctx)
}
fn call(&mut self, request: Self::Request) -> S::Future {
(**self).call(request)
}
}
impl<S> Service for RefCell<S>
where
S: Service,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Future = S::Future;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.borrow_mut().poll_ready(ctx)
}
fn call(&mut self, request: Self::Request) -> S::Future {
self.borrow_mut().call(request)
}
}
impl<S> Service for Rc<RefCell<S>>
where
S: Service,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Future = S::Future;
fn poll_ready(&mut self, ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.borrow_mut().poll_ready(ctx)
}
fn call(&mut self, request: Self::Request) -> S::Future {
(&mut (**self).borrow_mut()).call(request)
}
}
impl<S> ServiceFactory for Rc<S>
where
S: ServiceFactory,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Config = S::Config;
type Service = S::Service;
type InitError = S::InitError;
type Future = S::Future;
fn new_service(&self, cfg: S::Config) -> S::Future {
self.as_ref().new_service(cfg)
}
}
impl<S> ServiceFactory for Arc<S>
where
S: ServiceFactory,
{
type Request = S::Request;
type Response = S::Response;
type Error = S::Error;
type Config = S::Config;
type Service = S::Service;
type InitError = S::InitError;
type Future = S::Future;
fn new_service(&self, cfg: S::Config) -> S::Future {
self.as_ref().new_service(cfg)
}
}
/// Trait for types that can be converted to a `Service`
pub trait IntoService<T>
where
T: Service,
{
/// Convert to a `Service`
fn into_service(self) -> T;
}
/// Trait for types that can be converted to a `ServiceFactory`
pub trait IntoServiceFactory<T>
where
T: ServiceFactory,
{
/// Convert `Self` to a `ServiceFactory`
fn into_factory(self) -> T;
}
impl<T> IntoService<T> for T
where
T: Service,
{
fn into_service(self) -> T {
self
}
}
impl<T> IntoServiceFactory<T> for T
where
T: ServiceFactory,
{
fn into_factory(self) -> T {
self
}
}
/// Convert object of type `T` to a service `S`
pub fn into_service<T, S>(tp: T) -> S
where
S: Service,
T: IntoService<S>,
{
tp.into_service()
}
pub mod dev {
pub use crate::apply::{Apply, ApplyServiceFactory};
pub use crate::fn_service::{
FnService, FnServiceConfig, FnServiceFactory, FnServiceNoConfig,
};
pub use crate::map::{Map, MapServiceFactory};
pub use crate::map_config::{MapConfig, UnitConfig};
pub use crate::map_err::{MapErr, MapErrServiceFactory};
pub use crate::map_init_err::MapInitErr;
pub use crate::transform::ApplyTransform;
pub use crate::transform_err::TransformMapInitErr;
}

0
actix-net/actix-service/src/map.rs → ntex-service/src/map.rs
View file

0
actix-net/actix-service/src/map_config.rs → ntex-service/src/map_config.rs
View file

0
actix-net/actix-service/src/map_err.rs → ntex-service/src/map_err.rs
View file

0
actix-net/actix-service/src/map_init_err.rs → ntex-service/src/map_init_err.rs
View file

3
actix-net/actix-service/src/pipeline.rs → ntex-service/src/pipeline.rs
View file

@ -231,7 +231,8 @@ impl<T: ServiceFactory> PipelineFactory<T> {
Error = Err,
Config = T::Config,
InitError = T::InitError,
Service = impl Service<Request = T::Request, Response = Res, Error = Err> + Clone,
Service = impl Service<Request = T::Request, Response = Res, Error = Err>
+ Clone,
> + Clone,
>
where

9
actix-net/actix-service/src/then.rs → ntex-service/src/then.rs
View file

@ -116,7 +116,9 @@ where
this.state.set(State::Empty);
r
}),
State::Empty => panic!("future must not be polled after it returned `Poll::Ready`"),
State::Empty => {
panic!("future must not be polled after it returned `Poll::Ready`")
}
}
}
}
@ -163,7 +165,10 @@ where
fn new_service(&self, cfg: A::Config) -> Self::Future {
let srv = &*self.0;
ThenServiceFactoryResponse::new(srv.0.new_service(cfg.clone()), srv.1.new_service(cfg))
ThenServiceFactoryResponse::new(
srv.0.new_service(cfg.clone()),
srv.1.new_service(cfg),
)
}
}

0
actix-net/actix-service/src/transform.rs → ntex-service/src/transform.rs
View file

0
actix-net/actix-service/src/transform_err.rs → ntex-service/src/transform_err.rs
View file

2
ntex/Cargo.toml
View file

@ -36,9 +36,9 @@ compress = ["flate2", "brotli2"]
cookie = ["coo-kie", "coo-kie/percent-encode"]
[dependencies]
ntex-service = { path = "../ntex-service" }
ntex-web-macros = { path = "../ntex-web-macros" }
actix-service = "1.0.1"
actix-codec = "0.2.0"
actix-connect = "1.0.1"
actix-macros = "0.1.0"

5
ntex/src/framed/dispatcher.rs
View file

@ -3,12 +3,13 @@ use std::pin::Pin;
use std::task::{Context, Poll};
use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
use actix_service::Service;
use futures::Stream;
use log::debug;
use super::error::ServiceError;
use crate::channel::mpsc;
use crate::service::Service;
use super::error::ServiceError;
type Request<U> = <U as Decoder>::Item;
type Response<U> = <U as Encoder>::Item;

2
ntex/src/framed/framed.rs
View file

@ -5,12 +5,12 @@ use std::pin::Pin;
use std::task::{Context, Poll};
use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
use actix_service::{IntoService, Service};
use futures::{Future, FutureExt, Stream};
use log::debug;
use super::error::ServiceError;
use crate::channel::mpsc;
use crate::service::{IntoService, Service};
type Request<U> = <U as Decoder>::Item;
type Response<U> = <U as Encoder>::Item;

3
ntex/src/framed/service.rs
View file

@ -5,11 +5,12 @@ use std::rc::Rc;
use std::task::{Context, Poll};
use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed};
use actix_service::{IntoService, IntoServiceFactory, Service, ServiceFactory};
use either::Either;
use futures::{ready, Stream};
use pin_project::project;
use crate::service::{IntoService, IntoServiceFactory, Service, ServiceFactory};
use super::connect::{Connect, ConnectResult};
use super::dispatcher::Dispatcher;
use super::error::ServiceError;

2
ntex/src/http/builder.rs
View file

@ -3,7 +3,6 @@ use std::rc::Rc;
use std::{fmt, net};
use actix_codec::Framed;
use actix_service::{IntoServiceFactory, Service, ServiceFactory};
use crate::http::body::MessageBody;
use crate::http::config::{KeepAlive, ServiceConfig};
@ -14,6 +13,7 @@ use crate::http::helpers::{Data, DataFactory};
use crate::http::request::Request;
use crate::http::response::Response;
use crate::http::service::HttpService;
use crate::service::{IntoServiceFactory, Service, ServiceFactory};
/// A http service builder
///

3
ntex/src/http/client/builder.rs
View file

@ -4,10 +4,9 @@ use std::fmt;
use std::rc::Rc;
use std::time::Duration;
use actix_service::Service;
use crate::http::error::HttpError;
use crate::http::header::{self, HeaderMap, HeaderName};
use crate::Service;
use super::connect::ConnectorWrapper;
use super::error::ConnectError;

2
ntex/src/http/client/connect.rs
View file

@ -5,11 +5,11 @@ use std::task::{Context, Poll};
use std::{fmt, io, mem, net};
use actix_codec::{AsyncRead, AsyncWrite, Framed};
use actix_service::Service;
use crate::http::body::Body;
use crate::http::h1::ClientCodec;
use crate::http::{HeaderMap, RequestHead, RequestHeadType, ResponseHead};
use crate::Service;
use super::error::{ConnectError, SendRequestError};
use super::response::ClientResponse;

4
ntex/src/http/client/connector.rs
View file

@ -7,10 +7,10 @@ use actix_connect::{
default_connector, Connect as TcpConnect, Connection as TcpConnection,
};
use actix_rt::net::TcpStream;
use actix_service::{apply_fn, Service};
use crate::http::{Protocol, Uri};
use crate::util::timeout::{TimeoutError, TimeoutService};
use crate::{apply_fn, Service};
use super::connection::Connection;
use super::error::ConnectError;
@ -243,11 +243,11 @@ where
#[cfg(any(feature = "openssl", feature = "rustls"))]
{
const H2: &[u8] = b"h2";
use crate::{boxed::service, pipeline};
#[cfg(feature = "openssl")]
use actix_connect::ssl::openssl::OpensslConnector;
#[cfg(feature = "rustls")]
use actix_connect::ssl::rustls::{RustlsConnector, Session};
use actix_service::{boxed::service, pipeline};
let ssl_service = TimeoutService::new(
self.timeout,

2
ntex/src/http/client/pool.rs
View file

@ -8,7 +8,6 @@ use std::time::{Duration, Instant};
use actix_codec::{AsyncRead, AsyncWrite};
use actix_rt::time::{delay_for, Delay};
use actix_service::Service;
use bytes::Bytes;
use futures::future::{poll_fn, FutureExt, LocalBoxFuture};
use fxhash::FxHashMap;
@ -19,6 +18,7 @@ use slab::Slab;
use crate::channel::oneshot;
use crate::http::Protocol;
use crate::service::Service;
use crate::task::LocalWaker;
use super::connection::{ConnectionType, IoConnection};

2
ntex/src/http/cloneable.rs
View file

@ -2,7 +2,7 @@ use std::cell::RefCell;
use std::rc::Rc;
use std::task::{Context, Poll};
use actix_service::Service;
use crate::service::Service;
#[doc(hidden)]
/// Service that allows to turn non-clone service to a service with `Clone` impl

4
ntex/src/http/h1/dispatcher.rs
View file

@ -6,7 +6,6 @@ use std::{fmt, io, net};
use actix_codec::{AsyncRead, AsyncWrite, Decoder, Encoder, Framed, FramedParts};
use actix_rt::time::{delay_until, Delay, Instant};
use actix_service::Service;
use bitflags::bitflags;
use bytes::{Buf, BytesMut};
use log::{error, trace};
@ -20,6 +19,7 @@ use crate::http::helpers::DataFactory;
use crate::http::httpmessage::HttpMessage;
use crate::http::request::Request;
use crate::http::response::Response;
use crate::Service;
use super::codec::Codec;
use super::payload::{Payload, PayloadSender, PayloadStatus};
@ -889,13 +889,13 @@ where
#[cfg(test)]
mod tests {
use actix_service::IntoService;
use futures::future::{lazy, ok};
use super::*;
use crate::http::error::Error;
use crate::http::h1::{ExpectHandler, UpgradeHandler};
use crate::http::test::TestBuffer;
use crate::IntoService;
#[actix_rt::test]
async fn test_req_parse_err() {

2
ntex/src/http/h1/expect.rs
View file

@ -1,10 +1,10 @@
use std::task::{Context, Poll};
use actix_service::{Service, ServiceFactory};
use futures::future::{ok, Ready};
use crate::http::error::Error;
use crate::http::request::Request;
use crate::{Service, ServiceFactory};
pub struct ExpectHandler;

2
ntex/src/http/h1/service.rs
View file

@ -7,7 +7,6 @@ use std::{fmt, net};
use actix_codec::{AsyncRead, AsyncWrite, Framed};
use actix_rt::net::TcpStream;
use actix_service::{pipeline_factory, IntoServiceFactory, Service, ServiceFactory};
use futures::future::{ok, Ready};
use futures::ready;
@ -18,6 +17,7 @@ use crate::http::error::{DispatchError, Error, ParseError};
use crate::http::helpers::DataFactory;
use crate::http::request::Request;
use crate::http::response::Response;
use crate::{pipeline_factory, IntoServiceFactory, Service, ServiceFactory};
use super::codec::Codec;
use super::dispatcher::Dispatcher;

2
ntex/src/http/h1/upgrade.rs
View file

@ -2,12 +2,12 @@ use std::marker::PhantomData;
use std::task::{Context, Poll};
use actix_codec::Framed;
use actix_service::{Service, ServiceFactory};
use futures::future::Ready;
use crate::http::error::Error;
use crate::http::h1::Codec;
use crate::http::request::Request;
use crate::{Service, ServiceFactory};
pub struct UpgradeHandler<T>(PhantomData<T>);

2
ntex/src/http/h2/dispatcher.rs
View file

@ -7,7 +7,6 @@ use std::task::{Context, Poll};
use actix_codec::{AsyncRead, AsyncWrite};
use actix_rt::time::{Delay, Instant};
use actix_service::Service;
use bytes::{Bytes, BytesMut};
use h2::server::{Connection, SendResponse};
use h2::SendStream;
@ -24,6 +23,7 @@ use crate::http::message::ResponseHead;
use crate::http::payload::Payload;
use crate::http::request::Request;
use crate::http::response::Response;
use crate::Service;
const CHUNK_SIZE: usize = 16_384;

10
ntex/src/http/h2/service.rs
View file

@ -6,10 +6,6 @@ use std::{net, rc};
use actix_codec::{AsyncRead, AsyncWrite};
use actix_rt::net::TcpStream;
use actix_service::{
fn_factory, fn_service, pipeline_factory, IntoServiceFactory, Service,
ServiceFactory,
};
use bytes::Bytes;
use futures::future::ok;
use futures::ready;
@ -23,6 +19,10 @@ use crate::http::error::{DispatchError, Error};
use crate::http::helpers::DataFactory;
use crate::http::request::Request;
use crate::http::response::Response;
use crate::{
fn_factory, fn_service, pipeline_factory, IntoServiceFactory, Service,
ServiceFactory,
};
use super::dispatcher::Dispatcher;
@ -95,11 +95,11 @@ where
#[cfg(feature = "openssl")]
mod openssl {
use actix_service::{fn_factory, fn_service};
use actix_tls::openssl::{Acceptor, SslAcceptor, SslStream};
use actix_tls::{openssl::HandshakeError, SslError};
use super::*;
use crate::{fn_factory, fn_service};
impl<S, B> H2Service<SslStream<TcpStream>, S, B>
where

3
ntex/src/http/service.rs
View file

@ -5,13 +5,14 @@ use std::{fmt, net, rc};
use actix_codec::{AsyncRead, AsyncWrite, Framed};
use actix_rt::net::TcpStream;
use actix_service::{pipeline_factory, IntoServiceFactory, Service, ServiceFactory};
use bytes::Bytes;
use futures::future::ok;
use futures::{ready, Future};
use h2::server::{self, Handshake};
use pin_project::{pin_project, project};
use crate::service::{pipeline_factory, IntoServiceFactory, Service, ServiceFactory};
use super::body::MessageBody;
use super::builder::HttpServiceBuilder;
use super::cloneable::CloneableService;

5
ntex/src/lib.rs
View file

@ -19,11 +19,10 @@ pub mod channel;
pub mod framed;
pub mod http;
pub mod server;
pub mod service;
pub mod task;
pub mod util;
pub mod web;
pub mod ws;
pub mod service {
pub use actix_service::*;
}
pub use self::service::*;

1
ntex/src/service/mod.rs Normal file
View file

@ -0,0 +1 @@
pub use ntex_service::*;

3
ntex/src/util/either.rs
View file

@ -2,9 +2,10 @@
use std::pin::Pin;
use std::task::{Context, Poll};
use actix_service::{Service, ServiceFactory};
use futures::{future, ready, Future};
use crate::service::{Service, ServiceFactory};
/// Combine two different service types into a single type.
///
/// Both services must be of the same request, response, and error types.

5
ntex/src/util/inflight.rs
View file

@ -3,10 +3,10 @@ use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use actix_service::{IntoService, Service, Transform};
use futures::future::{ok, Ready};
use super::counter::{Counter, CounterGuard};
use crate::service::{IntoService, Service, Transform};
/// InFlight - new service for service that can limit number of in-flight
/// async requests.
@ -114,12 +114,11 @@ impl<T: Service> Future for InFlightServiceResponse<T> {
#[cfg(test)]
mod tests {
use std::task::{Context, Poll};
use std::time::Duration;
use super::*;
use actix_service::{apply, fn_factory, Service, ServiceFactory};
use crate::service::{apply, fn_factory, Service, ServiceFactory};
use futures::future::{lazy, ok, FutureExt, LocalBoxFuture};
struct SleepService(Duration);

2
ntex/src/util/keepalive.rs
View file

@ -6,10 +6,10 @@ use std::task::{Context, Poll};
use std::time::Duration;
use actix_rt::time::{delay_until, Delay, Instant};
use actix_service::{Service, ServiceFactory};
use futures::future::{ok, Ready};
use super::time::{LowResTime, LowResTimeService};
use crate::{Service, ServiceFactory};
pub struct KeepAlive<R, E, F> {
f: F,

8
ntex/src/util/order.rs
View file

@ -7,10 +7,10 @@ use std::pin::Pin;
use std::rc::Rc;
use std::task::{Context, Poll};
use actix_service::{IntoService, Service, Transform};
use futures::future::{ok, Ready};
use crate::channel::oneshot;
use crate::service::{IntoService, Service, Transform};
use crate::task::LocalWaker;
struct Record<I, E> {
@ -210,15 +210,15 @@ impl<S: Service> Future for InOrderServiceResponse<S> {
#[cfg(test)]
mod tests {
use std::task::{Context, Poll};
use std::time::Duration;
use super::*;
use actix_service::Service;
use futures::channel::oneshot;
use futures::future::{lazy, poll_fn, FutureExt, LocalBoxFuture};
use super::*;
use crate::service::Service;
struct Srv;
impl Service for Srv {

2
ntex/src/util/stream.rs
View file

@ -2,10 +2,10 @@ use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use actix_service::{IntoService, Service};
use futures::{FutureExt, Stream};
use crate::channel::mpsc;
use crate::service::{IntoService, Service};
#[pin_project::pin_project]
pub struct Dispatcher<S, T>

2
ntex/src/util/time.rs
View file

@ -3,10 +3,10 @@ use std::task::{Context, Poll};
use std::time::{self, Duration, Instant};
use actix_rt::time::delay_for;
use actix_service::{Service, ServiceFactory};
use futures::future::{ok, ready, FutureExt, Ready};
use super::cell::Cell;
use crate::service::{Service, ServiceFactory};
#[derive(Clone, Debug)]
pub struct LowResTime(Cell<Inner>);

7
ntex/src/util/timeout.rs
View file

@ -9,9 +9,10 @@ use std::task::{Context, Poll};
use std::{fmt, time};
use actix_rt::time::{delay_for, Delay};
use actix_service::{IntoService, Service, Transform};
use futures::future::{ok, Ready};
use crate::service::{IntoService, Service, Transform};
/// Applies a timeout to requests.
#[derive(Debug)]
pub struct Timeout<E = ()> {
@ -182,12 +183,12 @@ where
#[cfg(test)]
mod tests {
use futures::future::{ok, FutureExt, LocalBoxFuture};
use std::task::{Context, Poll};
use std::time::Duration;
use super::*;
use actix_service::{apply, fn_factory, Service, ServiceFactory};
use futures::future::{ok, FutureExt, LocalBoxFuture};
use crate::service::{apply, fn_factory, Service, ServiceFactory};
struct SleepService(Duration);

10
ntex/src/web/app.rs
View file

@ -4,14 +4,14 @@ use std::future::Future;
use std::marker::PhantomData;
use std::rc::Rc;
use actix_service::boxed::{self, BoxServiceFactory};
use actix_service::{
apply, apply_fn_factory, IntoServiceFactory, ServiceFactory, Transform,
};
use futures::future::{FutureExt, LocalBoxFuture};
use crate::http::body::{Body, MessageBody};
use crate::http::{Error, Extensions};
use crate::service::boxed::{self, BoxServiceFactory};
use crate::service::{
apply, apply_fn_factory, IntoServiceFactory, ServiceFactory, Transform,
};
use super::app_service::{AppEntry, AppInit, AppRoutingFactory};
use super::config::ServiceConfig;
@ -473,7 +473,6 @@ where
#[cfg(test)]
mod tests {
use actix_service::Service;
use bytes::Bytes;
use futures::future::ok;
@ -484,6 +483,7 @@ mod tests {
use crate::web::service::ServiceRequest;
use crate::web::test::{call_service, init_service, read_body, TestRequest};
use crate::web::{self, HttpRequest, HttpResponse};
use crate::Service;
#[actix_rt::test]
async fn test_default_resource() {

4
ntex/src/web/app_service.rs
View file

@ -6,11 +6,11 @@ use std::rc::Rc;
use std::task::{Context, Poll};
use actix_router::{Path, ResourceDef, ResourceInfo, Router, Url};
use actix_service::boxed::{self, BoxService, BoxServiceFactory};
use actix_service::{fn_service, Service, ServiceFactory};
use futures::future::{ok, FutureExt, LocalBoxFuture};
use crate::http::{Error, Extensions, Request, Response};
use crate::service::boxed::{self, BoxService, BoxServiceFactory};
use crate::{fn_service, Service, ServiceFactory};
use super::config::{AppConfig, AppService};
use super::data::DataFactory;

4
ntex/src/web/config.rs
View file

@ -2,9 +2,9 @@ use std::net::SocketAddr;
use std::rc::Rc;
use actix_router::ResourceDef;
use actix_service::{boxed, IntoServiceFactory, ServiceFactory};
use crate::http::{Error, Extensions};
use crate::service::{boxed, IntoServiceFactory, ServiceFactory};
use super::data::{Data, DataFactory};
use super::guard::Guard;
@ -241,13 +241,13 @@ impl ServiceConfig {
#[cfg(test)]
mod tests {
use actix_service::Service;
use bytes::Bytes;
use super::*;
use crate::http::{Method, StatusCode};
use crate::web::test::{call_service, init_service, read_body, TestRequest};
use crate::web::{self, App, HttpRequest, HttpResponse};
use crate::Service;
#[actix_rt::test]
async fn test_data() {

2
ntex/src/web/data.rs
View file

@ -135,13 +135,13 @@ impl<T: 'static> DataFactory for Data<T> {
#[cfg(test)]
mod tests {
use actix_service::Service;
use std::sync::atomic::{AtomicUsize, Ordering};
use super::*;
use crate::http::StatusCode;
use crate::web::test::{self, init_service, TestRequest};
use crate::web::{self, App, HttpResponse};
use crate::Service;
#[actix_rt::test]
async fn test_data_extractor() {

2
ntex/src/web/handler.rs
View file

@ -4,12 +4,12 @@ use std::marker::PhantomData;
use std::pin::Pin;
use std::task::{Context, Poll};
use actix_service::{Service, ServiceFactory};
use futures::future::{ok, Ready};
use futures::ready;
use pin_project::pin_project;
use crate::http::{Error, Response};
use crate::{Service, ServiceFactory};
use super::extract::FromRequest;
use super::request::HttpRequest;

10
ntex/src/web/resource.rs
View file

@ -6,13 +6,13 @@ use std::rc::Rc;
use std::task::{Context, Poll};
use actix_router::IntoPattern;
use actix_service::boxed::{self, BoxService, BoxServiceFactory};
use actix_service::{
apply, apply_fn_factory, IntoServiceFactory, Service, ServiceFactory, Transform,
};
use futures::future::{ok, Either, LocalBoxFuture, Ready};
use crate::http::{Error, Extensions, Response};
use crate::service::boxed::{self, BoxService, BoxServiceFactory};
use crate::service::{
apply, apply_fn_factory, IntoServiceFactory, Service, ServiceFactory, Transform,
};
use crate::web::data::Data;
use crate::web::dev::{insert_slash, AppService, HttpServiceFactory, ResourceDef};
use crate::web::extract::FromRequest;
@ -582,7 +582,6 @@ mod tests {
use std::time::Duration;
use actix_rt::time::delay_for;
use actix_service::Service;
use futures::future::ok;
use crate::http::header::{self, HeaderValue};
@ -591,6 +590,7 @@ mod tests {
use crate::web::service::ServiceRequest;
use crate::web::test::{call_service, init_service, TestRequest};
use crate::web::{self, guard, App, HttpResponse};
use crate::Service;
#[actix_rt::test]
async fn test_middleware() {

2
ntex/src/web/responder.rs
View file

@ -454,7 +454,6 @@ where
#[cfg(test)]
pub(crate) mod tests {
use actix_service::Service;
use bytes::{Bytes, BytesMut};
use super::*;
@ -463,6 +462,7 @@ pub(crate) mod tests {
use crate::http::{error, Response as HttpResponse, StatusCode};
use crate::web;
use crate::web::test::{init_service, TestRequest};
use crate::Service;
#[actix_rt::test]
async fn test_option_responder() {

2
ntex/src/web/route.rs
View file

@ -3,10 +3,10 @@ use std::pin::Pin;
use std::rc::Rc;
use std::task::{Context, Poll};
use actix_service::{Service, ServiceFactory};
use futures::future::{ready, FutureExt, LocalBoxFuture};
use crate::http::{Error, Method};
use crate::{Service, ServiceFactory};
use crate::web::extract::FromRequest;
use crate::web::guard::{self, Guard};

10
ntex/src/web/scope.rs
View file

@ -5,13 +5,13 @@ use std::rc::Rc;
use std::task::{Context, Poll};
use actix_router::{ResourceDef, ResourceInfo, Router};
use actix_service::boxed::{self, BoxService, BoxServiceFactory};
use actix_service::{
apply, apply_fn_factory, IntoServiceFactory, Service, ServiceFactory, Transform,
};
use futures::future::{ok, Either, Future, LocalBoxFuture, Ready};
use crate::http::{Error, Extensions, Response};
use crate::service::boxed::{self, BoxService, BoxServiceFactory};
use crate::service::{
apply, apply_fn_factory, IntoServiceFactory, Service, ServiceFactory, Transform,
};
use crate::web::config::ServiceConfig;
use crate::web::data::Data;
use crate::web::dev::{AppService, HttpServiceFactory};
@ -659,13 +659,13 @@ impl ServiceFactory for ScopeEndpoint {
#[cfg(test)]
mod tests {
use actix_service::Service;
use bytes::Bytes;
use futures::future::ok;
use crate::http::body::{Body, ResponseBody};
use crate::http::header::{HeaderValue, CONTENT_TYPE};
use crate::http::{Method, StatusCode};
use crate::service::Service;
use crate::web::middleware::DefaultHeaders;
use crate::web::service::ServiceRequest;
use crate::web::test::{call_service, init_service, read_body, TestRequest};

6
ntex/src/web/server.rs
View file

@ -3,10 +3,7 @@ use std::sync::{Arc, Mutex};
use std::{fmt, io, net};
use actix_server::{Server, ServerBuilder};
use actix_service::{map_config, IntoServiceFactory, Service, ServiceFactory};
#[cfg(unix)]
use actix_service::pipeline_factory;
#[cfg(feature = "openssl")]
use actix_tls::openssl::{AlpnError, SslAcceptor, SslAcceptorBuilder};
#[cfg(feature = "rustls")]
@ -19,6 +16,9 @@ use net2::TcpBuilder;
#[cfg(unix)]
use crate::http::Protocol;
use crate::http::{body::MessageBody, Error, HttpService, KeepAlive, Request, Response};
#[cfg(unix)]
use crate::pipeline_factory;
use crate::{map_config, IntoServiceFactory, Service, ServiceFactory};
use crate::web::config::AppConfig;

2
ntex/src/web/service.rs
View file

@ -3,13 +3,13 @@ use std::rc::Rc;
use std::{fmt, net};
use actix_router::{IntoPattern, Path, Resource, ResourceDef, Url};
use actix_service::{IntoServiceFactory, ServiceFactory};
use crate::http::body::{Body, MessageBody, ResponseBody};
use crate::http::{
Error, Extensions, HeaderMap, HttpMessage, Method, Payload, PayloadStream,
RequestHead, Response, ResponseHead, StatusCode, Uri, Version,
};
use crate::{IntoServiceFactory, ServiceFactory};
use super::config::{AppConfig, AppService};
use super::data::Data;

4
ntex/src/web/test.rs
View file

@ -9,9 +9,6 @@ use actix_codec::{AsyncRead, AsyncWrite, Framed};
use actix_router::{Path, ResourceDef, Url};
use actix_rt::{time::delay_for, System};
use actix_server::Server;
use actix_service::{
map_config, IntoService, IntoServiceFactory, Service, ServiceFactory,
};
use bytes::{Bytes, BytesMut};
use futures::future::ok;
use futures::stream::{Stream, StreamExt};
@ -32,6 +29,7 @@ use crate::http::test::TestRequest as HttpTestRequest;
use crate::http::{
Extensions, HttpService, Method, Payload, Request, StatusCode, Uri, Version,
};
use crate::{map_config, IntoService, IntoServiceFactory, Service, ServiceFactory};
use crate::web::config::AppConfig;
use crate::web::request::HttpRequestPool;

2
ntex/src/web/util.rs
View file

@ -3,11 +3,11 @@ use std::fmt;
use std::future::Future;
use actix_router::IntoPattern;
use actix_service::{IntoServiceFactory, Service, ServiceFactory};
use crate::http::body::MessageBody;
use crate::http::error::{BlockingError, Error};
use crate::http::{Method, Request, Response};
use crate::{IntoServiceFactory, Service, ServiceFactory};
use super::config::AppConfig;
use super::extract::FromRequest;

2
ntex/src/ws/dispatcher.rs
View file

@ -3,9 +3,9 @@ use std::pin::Pin;
use std::task::{Context, Poll};
use actix_codec::{AsyncRead, AsyncWrite, Framed};
use actix_service::{IntoService, Service};
use crate::framed;
use crate::service::{IntoService, Service};
use super::{Codec, Frame, Message};

2
ntex/tests/framed_server.rs
View file

@ -2,13 +2,13 @@ use std::cell::Cell;
use std::rc::Rc;
use actix_codec::BytesCodec;
use actix_service::{fn_factory_with_config, fn_service, IntoService, Service};
use bytes::{Bytes, BytesMut};
use futures::future::ok;
use ntex::channel::mpsc;
use ntex::framed::{Builder, Connect, FactoryBuilder};
use ntex::server::test_server;
use ntex::{fn_factory_with_config, fn_service, IntoService, Service};
#[derive(Clone)]
struct State(Option<mpsc::Sender<Bytes>>);

2
ntex/tests/http_client.rs
View file

@ -1,9 +1,9 @@
use actix_service::ServiceFactory;
use bytes::Bytes;
use futures::future::{self, ok};
use ntex::http::test::server as test_server;
use ntex::http::{HttpService, Method, Request, Response};
use ntex::service::ServiceFactory;
const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
Hello World Hello World Hello World Hello World Hello World \

2
ntex/tests/http_server.rs
View file

@ -3,7 +3,6 @@ use std::time::Duration;
use std::{net, thread};
use actix_rt::time::delay_for;
use actix_service::fn_service;
use bytes::Bytes;
use futures::future::{self, err, ok, ready, FutureExt};
use futures::stream::{once, StreamExt};
@ -13,6 +12,7 @@ use ntex::http::test::server as test_server;
use ntex::http::{
body, error, header, Error, HttpMessage, HttpService, KeepAlive, Request, Response,
};
use ntex::service::fn_service;
#[ntex::test]
async fn test_h1() {

2
ntex/tests/http_ws.rs
View file

@ -4,7 +4,6 @@ use std::pin::Pin;
use std::sync::{Arc, Mutex};
use actix_codec::{AsyncRead, AsyncWrite, Framed};
use actix_service::{fn_factory, Service};
use bytes::Bytes;
use futures::future;
use futures::task::{Context, Poll};
@ -13,6 +12,7 @@ use futures::{Future, SinkExt, StreamExt};
use ntex::framed::Dispatcher;
use ntex::http::ws::handshake;
use ntex::http::{body, h1, test, Error, HttpService, Request, Response};
use ntex::service::{fn_factory, Service};
use ntex::ws;
struct WsService<T>(Arc<Mutex<(PhantomData<T>, Cell<bool>)>>);