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

prep release

Browse source
This commit is contained in:
Nikolay Kim 2021-12-24 18:19:41 +06:00
parent 037e195da4
commit 531bafbae2
9 changed files with 19 additions and 363 deletions
Download patch file Download diff file Expand all files Collapse all files

4
ntex-io/CHANGES.md
View file

@ -1,6 +1,8 @@
# Changes
## [0.1.0-b.5] - 2021-12-xx
## [0.1.0-b.5] - 2021-12-24
* Use new ntex-service traits
* Make `IoBoxed` into spearate type

5
ntex-io/Cargo.toml
View file

@ -25,11 +25,12 @@ tokio-traits = ["tok-io/net", "tok-io/rt"]
tokio = ["tok-io/net", "tok-io/rt"]
[dependencies]
bitflags = "1.3"
ntex-codec = "0.6.0"
ntex-bytes = "0.1.8"
ntex-util = "0.1.4"
ntex-service = "0.3.0"
ntex-service = "0.3.0-b.0"
bitflags = "1.3"
fxhash = "0.2.1"
log = "0.4"
pin-project-lite = "0.2"

4
ntex-rt/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex-rt"
version = "0.4.0-b.1"
version = "0.4.0-b.2"
authors = ["ntex contributors <team@ntex.rs>"]
description = "ntex runtime"
keywords = ["network", "framework", "async", "futures"]
@ -23,7 +23,7 @@ tokio = ["tok-io", "ntex-io/tokio"]
[dependencies]
ntex-bytes = "0.1.8"
ntex-io = "0.1.0-b.3"
ntex-io = "0.1.0-b.5"
ntex-util = "0.1.3"
async-oneshot = "0.5.0"
async-channel = "1.6.1"

2
ntex-service/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex-service"
version = "0.3.0"
version = "0.3.0-b.0"
authors = ["ntex contributors <team@ntex.rs>"]
description = "ntex service"
keywords = ["network", "framework", "async", "futures"]

348
ntex-service/src/and_then_apply_fn.rs
View file

@ -1,348 +0,0 @@
use std::{
future::Future, marker::PhantomData, pin::Pin, rc::Rc, task::Context, task::Poll,
};
use crate::{Service, ServiceFactory};
/// `Apply` service combinator
pub(crate) struct AndThenApplyFn<A, B, F, Req1, Req2, Fut, Res, Err>
where
A: Service<Req1>,
B: Service<Req2>,
F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>,
{
srv: Rc<(A, B, F)>,
r: PhantomData<fn(Req1) -> (Fut, Req2, Res, Err)>,
}
impl<A, B, F, Req1, Req2, Fut, Res, Err> AndThenApplyFn<A, B, F, Req1, Req2, Fut, Res, Err>
where
A: Service<Req1>,
B: Service<Req2>,
F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>,
{
/// Create new `Apply` combinator
pub(crate) fn new(a: A, b: B, f: F) -> Self {
Self {
srv: Rc::new((a, b, f)),
r: PhantomData,
}
}
}
impl<A, B, F, Req1, Req2, Fut, Res, Err> Clone for AndThenApplyFn<A, B, F, Req1, Req2, Fut, Res, Err>
where
A: Service<Req1>,
B: Service<Req2>,
F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>,
{
fn clone(&self) -> Self {
AndThenApplyFn {
srv: self.srv.clone(),
r: PhantomData,
}
}
}
impl<A, B, F, Req1, Req2, Fut, Res, Err> Service for AndThenApplyFn<A, B, F, Req1, Req2, Fut, Res, Err>
where
A: Service<Req1>,
B: Service<Req2>,
F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>,
{
type Response = Res;
type Error = Err;
type Future = AndThenApplyFnFuture<A, B, F, Req1, Req2, Fut, Res, Err>;
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let inner = self.srv.as_ref();
let not_ready = inner.0.poll_ready(cx)?.is_pending();
if inner.1.poll_ready(cx)?.is_pending() || not_ready {
Poll::Pending
} else {
Poll::Ready(Ok(()))
}
}
fn shutdown(&self) {
let srv = self.srv.as_ref();
srv.0.shutdown();
srv.1.shutdown();
}
fn call(&self, req: A::Request) -> Self::Future {
let fut = self.srv.as_ref().0.call(req);
AndThenApplyFnFuture {
state: State::A {
fut,
b: Some(self.srv.clone()),
},
}
}
}
pin_project_lite::pin_project! {
pub(crate) struct AndThenApplyFnFuture<A, B, F, Req1, Req2, Fut, Res, Err>
where
A: Service<Req1>,
B: Service<Req2>,
F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error>,
Err: From<B::Error>,
{
#[pin]
state: State<A, B, F, Req1, Req2, Fut, Res, Err>,
}
}
pin_project_lite::pin_project! {
#[project = StateProject]
enum State<A, B, F, Req1, Req2, Fut, Res, Err>
where
A: Service<Req1>,
B: Service<Req2>,
F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error>,
Err: From<B::Error>,
{
A { #[pin] fut: A::Future, b: Option<Rc<(A, B, F)>> },
B { #[pin] fut: Fut },
Empty,
}
}
impl<A, B, F, Req1, Req2, Fut, Res, Err> Future for AndThenApplyFnFuture<A, B, F, Req1, Req2, Fut, Res, Err>
where
A: Service,
B: Service,
F: Fn(A::Response, &B) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>,
{
type Output = Result<Res, Err>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let mut this = self.as_mut().project();
match this.state.as_mut().project() {
StateProject::A { fut, b } => match fut.poll(cx)? {
Poll::Ready(res) => {
let b = b.take().unwrap();
this.state.set(State::Empty);
let b = b.as_ref();
let fut = (&b.2)(res, &b.1);
this.state.set(State::B { fut });
self.poll(cx)
}
Poll::Pending => Poll::Pending,
},
StateProject::B { fut } => fut.poll(cx).map(|r| {
this.state.set(State::Empty);
r
}),
StateProject::Empty => {
panic!("future must not be polled after it returned `Poll::Ready`")
}
}
}
}
/// `AndThenApplyFn` service factory
pub(crate) struct AndThenApplyFnFactory<A, B, F, Fut, Res, Err> {
srv: Rc<(A, B, F)>,
r: PhantomData<(Fut, Res, Err)>,
}
impl<A, B, F, Fut, Res, Err> AndThenApplyFnFactory<A, B, F, Fut, Res, Err>
where
A: ServiceFactory,
B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
F: Fn(A::Response, &B::Service) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>,
{
/// Create new `ApplyNewService` new service instance
pub(crate) fn new(a: A, b: B, f: F) -> Self {
Self {
srv: Rc::new((a, b, f)),
r: PhantomData,
}
}
}
impl<A, B, F, Fut, Res, Err> Clone for AndThenApplyFnFactory<A, B, F, Fut, Res, Err> {
fn clone(&self) -> Self {
Self {
srv: self.srv.clone(),
r: PhantomData,
}
}
}
impl<A, B, F, Fut, Res, Err> ServiceFactory
for AndThenApplyFnFactory<A, B, F, Fut, Res, Err>
where
A: ServiceFactory,
A::Config: Clone,
B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
F: Fn(A::Response, &B::Service) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>,
{
type Request = A::Request;
type Response = Res;
type Error = Err;
type Service = AndThenApplyFn<A::Service, B::Service, F, Fut, Res, Err>;
type Config = A::Config;
type InitError = A::InitError;
type Future = AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>;
fn new_service(&self, cfg: A::Config) -> Self::Future {
let srv = &*self.srv;
AndThenApplyFnFactoryResponse {
a: None,
b: None,
f: srv.2.clone(),
fut_a: srv.0.new_service(cfg.clone()),
fut_b: srv.1.new_service(cfg),
}
}
}
pin_project_lite::pin_project! {
pub(crate) struct AndThenApplyFnFactoryResponse<A, B, F, Fut, Res, Err>
where
A: ServiceFactory,
B: ServiceFactory<Config = A::Config, InitError = A::InitError>,
F: Fn(A::Response, &B::Service) -> Fut,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error>,
Err: From<B::Error>,
{
#[pin]
fut_b: B::Future,
#[pin]
fut_a: A::Future,
f: F,
a: Option<A::Service>,
b: Option<B::Service>,
}
}
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>,
F: Fn(A::Response, &B::Service) -> Fut + Clone,
Fut: Future<Output = Result<Res, Err>>,
Err: From<A::Error> + From<B::Error>,
{
type Output =
Result<AndThenApplyFn<A::Service, B::Service, F, Fut, Res, Err>, A::InitError>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let this = self.project();
if this.a.is_none() {
if let Poll::Ready(service) = this.fut_a.poll(cx)? {
*this.a = Some(service);
}
}
if this.b.is_none() {
if let Poll::Ready(service) = this.fut_b.poll(cx)? {
*this.b = Some(service);
}
}
if this.a.is_some() && this.b.is_some() {
Poll::Ready(Ok(AndThenApplyFn {
srv: Rc::new((
this.a.take().unwrap(),
this.b.take().unwrap(),
this.f.clone(),
)),
r: PhantomData,
}))
} else {
Poll::Pending
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{fn_service, pipeline, pipeline_factory, Service, ServiceFactory};
use ntex_util::future::{lazy, Ready};
#[derive(Clone)]
struct Srv;
impl Service for Srv {
type Request = ();
type Response = ();
type Error = ();
type Future = Ready<(), ()>;
fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
fn call(&self, _: Self::Request) -> Self::Future {
Ready::Ok(())
}
}
#[ntex::test]
async fn test_service() {
let srv = pipeline(Ready::<_, ()>::Ok)
.and_then_apply_fn(Srv, |req: &'static str, s| {
let f = s.call(());
async move { f.await.map(move |res| (req, res)) }
})
.clone();
let res = lazy(|cx| srv.poll_ready(cx)).await;
assert_eq!(res, Poll::Ready(Ok(())));
let res = srv.call("srv").await;
assert!(res.is_ok());
assert_eq!(res.unwrap(), ("srv", ()));
let res = lazy(|cx| srv.poll_shutdown(cx, false)).await;
assert_eq!(res, Poll::Ready(()));
}
#[ntex::test]
async fn test_service_factory() {
let new_srv =
pipeline_factory(|| Ready::<_, ()>::Ok(fn_service(Ready::<_, ()>::Ok)))
.and_then_apply_fn(
|| Ready::Ok(Srv),
|req: &'static str, s| {
let f = s.call(());
async move { f.await.map(move |res| (req, res)) }
},
)
.clone();
let srv = new_srv.new_service(()).await.unwrap();
let res = lazy(|cx| srv.poll_ready(cx)).await;
assert_eq!(res, Poll::Ready(Ok(())));
let res = srv.call("srv").await;
assert!(res.is_ok());
assert_eq!(res.unwrap(), ("srv", ()));
}
}

3
ntex-service/src/lib.rs
View file

@ -1,4 +1,4 @@
//#![deny(rust_2018_idioms, warnings)]
#![deny(rust_2018_idioms, warnings)]
#![allow(clippy::type_complexity)]
use std::future::Future;
@ -6,7 +6,6 @@ use std::rc::Rc;
use std::task::{self, Context, Poll};
mod and_then;
// mod and_then_apply_fn;
mod apply;
pub mod boxed;
mod fn_service;

6
ntex-tls/Cargo.toml
View file

@ -26,9 +26,9 @@ rustls = ["tls_rust"]
[dependencies]
ntex-bytes = "0.1.8"
ntex-io = "0.1.0-b.3"
ntex-util = "0.1.3"
ntex-service = "0.3.0"
ntex-io = "0.1.0-b.5"
ntex-util = "0.1.4"
ntex-service = "0.3.0-b.0"
pin-project-lite = "0.2"
# openssl

4
ntex/CHANGES.md
View file

@ -1,6 +1,8 @@
# Changes
## [0.5.0-b.3] - 2021-12-23
## [0.5.0-b.3] - 2021-12-24
* Use new ntex-service traits
* Remove websocket support from http::client

6
ntex/Cargo.toml
View file

@ -41,13 +41,13 @@ url = ["url-pkg"]
[dependencies]
ntex-codec = "0.6.0"
ntex-router = "0.5.1"
ntex-service = "0.3.0"
ntex-service = "0.3.0-b.0"
ntex-macros = "0.1.3"
ntex-util = "0.1.4"
ntex-bytes = "0.1.8"
ntex-tls = "0.1.0-b.2"
ntex-tls = "0.1.0-b.3"
ntex-io = "0.1.0-b.5"
ntex-rt = { version = "0.4.0-b.1", default-features = false, features = ["tokio"] }
ntex-rt = { version = "0.4.0-b.2", default-features = false, features = ["tokio"] }
base64 = "0.13"
bitflags = "1.3"