actix/actix-extras
1
0
Fork 0
mirror of https://github.com/actix/actix-extras.git synced 2025-01-23 15:24:36 +01:00
Code Issues Releases Wiki Activity

update server service requirenments

Browse Source
This commit is contained in:
Nikolay Kim 2019-03-11 15:09:42 -07:00
parent 6436004194
commit ad43ca735b
7 changed files with 130 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
examples/framed_hello.rs
View File

@ -2,8 +2,8 @@ use std::{env, io};
use actix_codec::Framed; use actix_codec::Framed;
use actix_http::{h1, Response, SendResponse, ServiceConfig}; use actix_http::{h1, Response, SendResponse, ServiceConfig};
use actix_server::Server; use actix_server::{Io, Server};
use actix_service::NewService; use actix_service::{fn_service, NewService};
use actix_utils::framed::IntoFramed; use actix_utils::framed::IntoFramed;
use actix_utils::stream::TakeItem; use actix_utils::stream::TakeItem;
use futures::Future; use futures::Future;
@ -14,7 +14,8 @@ fn main() -> io::Result<()> {
Server::build() Server::build()
.bind("framed_hello", "127.0.0.1:8080", || { .bind("framed_hello", "127.0.0.1:8080", || {
IntoFramed::new(|| h1::Codec::new(ServiceConfig::default())) fn_service(|io: Io<_>| Ok(io.into_parts().0))
.and_then(IntoFramed::new(|| h1::Codec::new(ServiceConfig::default())))
.and_then(TakeItem::new().map_err(|_| ())) .and_then(TakeItem::new().map_err(|_| ()))
.and_then(|(_req, _framed): (_, Framed<_, _>)| { .and_then(|(_req, _framed): (_, Framed<_, _>)| {
SendResponse::send(_framed, Response::Ok().body("Hello world!")) SendResponse::send(_framed, Response::Ok().body("Hello world!"))

6
src/builder.rs
View File

@ -95,7 +95,7 @@ where
// } // }
/// Finish service configuration and create *http service* for HTTP/1 protocol. /// Finish service configuration and create *http service* for HTTP/1 protocol.
pub fn h1<F, B>(self, service: F) -> H1Service<T, S, B> pub fn h1<F, P, B>(self, service: F) -> H1Service<T, P, S, B>
where where
B: MessageBody + 'static, B: MessageBody + 'static,
F: IntoNewService<S, SrvConfig>, F: IntoNewService<S, SrvConfig>,
@ -110,7 +110,7 @@ where
} }
/// Finish service configuration and create *http service* for HTTP/2 protocol. /// Finish service configuration and create *http service* for HTTP/2 protocol.
pub fn h2<F, B>(self, service: F) -> H2Service<T, S, B> pub fn h2<F, P, B>(self, service: F) -> H2Service<T, P, S, B>
where where
B: MessageBody + 'static, B: MessageBody + 'static,
F: IntoNewService<S, SrvConfig>, F: IntoNewService<S, SrvConfig>,
@ -125,7 +125,7 @@ where
} }
/// Finish service configuration and create `HttpService` instance. /// Finish service configuration and create `HttpService` instance.
pub fn finish<F, B>(self, service: F) -> HttpService<T, S, B> pub fn finish<F, P, B>(self, service: F) -> HttpService<T, P, S, B>
where where
B: MessageBody + 'static, B: MessageBody + 'static,
F: IntoNewService<S, SrvConfig>, F: IntoNewService<S, SrvConfig>,

67
src/h1/service.rs
View File

@ -2,7 +2,7 @@ use std::fmt::Debug;
use std::marker::PhantomData; use std::marker::PhantomData;
use actix_codec::{AsyncRead, AsyncWrite, Framed}; use actix_codec::{AsyncRead, AsyncWrite, Framed};
use actix_server_config::ServerConfig as SrvConfig; use actix_server_config::{Io, ServerConfig as SrvConfig};
use actix_service::{IntoNewService, NewService, Service}; use actix_service::{IntoNewService, NewService, Service};
use actix_utils::cloneable::CloneableService; use actix_utils::cloneable::CloneableService;
use futures::future::{ok, FutureResult}; use futures::future::{ok, FutureResult};
@ -19,13 +19,13 @@ use super::dispatcher::Dispatcher;
use super::Message; use super::Message;
/// `NewService` implementation for HTTP1 transport /// `NewService` implementation for HTTP1 transport
pub struct H1Service<T, S, B> { pub struct H1Service<T, P, S, B> {
srv: S, srv: S,
cfg: ServiceConfig, cfg: ServiceConfig,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, P, B)>,
} }
impl<T, S, B> H1Service<T, S, B> impl<T, P, S, B> H1Service<T, P, S, B>
where where
S: NewService<SrvConfig, Request = Request>, S: NewService<SrvConfig, Request = Request>,
S::Error: Debug, S::Error: Debug,
@ -57,7 +57,7 @@ where
} }
} }
impl<T, S, B> NewService<SrvConfig> for H1Service<T, S, B> impl<T, P, S, B> NewService<SrvConfig> for H1Service<T, P, S, B>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
S: NewService<SrvConfig, Request = Request>, S: NewService<SrvConfig, Request = Request>,
@ -66,12 +66,12 @@ where
S::Service: 'static, S::Service: 'static,
B: MessageBody, B: MessageBody,
{ {
type Request = T; type Request = Io<T, P>;
type Response = (); type Response = ();
type Error = DispatchError; type Error = DispatchError;
type InitError = S::InitError; type InitError = S::InitError;
type Service = H1ServiceHandler<T, S::Service, B>; type Service = H1ServiceHandler<T, P, S::Service, B>;
type Future = H1ServiceResponse<T, S, B>; type Future = H1ServiceResponse<T, P, S, B>;
fn new_service(&self, cfg: &SrvConfig) -> Self::Future { fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
H1ServiceResponse { H1ServiceResponse {
@ -83,13 +83,13 @@ where
} }
#[doc(hidden)] #[doc(hidden)]
pub struct H1ServiceResponse<T, S: NewService<SrvConfig, Request = Request>, B> { pub struct H1ServiceResponse<T, P, S: NewService<SrvConfig, Request = Request>, B> {
fut: <S::Future as IntoFuture>::Future, fut: <S::Future as IntoFuture>::Future,
cfg: Option<ServiceConfig>, cfg: Option<ServiceConfig>,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, P, B)>,
} }
impl<T, S, B> Future for H1ServiceResponse<T, S, B> impl<T, P, S, B> Future for H1ServiceResponse<T, P, S, B>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
S: NewService<SrvConfig, Request = Request>, S: NewService<SrvConfig, Request = Request>,
@ -98,7 +98,7 @@ where
S::Response: Into<Response<B>>, S::Response: Into<Response<B>>,
B: MessageBody, B: MessageBody,
{ {
type Item = H1ServiceHandler<T, S::Service, B>; type Item = H1ServiceHandler<T, P, S::Service, B>;
type Error = S::InitError; type Error = S::InitError;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> { fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@ -111,20 +111,20 @@ where
} }
/// `Service` implementation for HTTP1 transport /// `Service` implementation for HTTP1 transport
pub struct H1ServiceHandler<T, S: 'static, B> { pub struct H1ServiceHandler<T, P, S: 'static, B> {
srv: CloneableService<S>, srv: CloneableService<S>,
cfg: ServiceConfig, cfg: ServiceConfig,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, P, B)>,
} }
impl<T, S, B> H1ServiceHandler<T, S, B> impl<T, P, S, B> H1ServiceHandler<T, P, S, B>
where where
S: Service<Request = Request>, S: Service<Request = Request>,
S::Error: Debug, S::Error: Debug,
S::Response: Into<Response<B>>, S::Response: Into<Response<B>>,
B: MessageBody, B: MessageBody,
{ {
fn new(cfg: ServiceConfig, srv: S) -> H1ServiceHandler<T, S, B> { fn new(cfg: ServiceConfig, srv: S) -> H1ServiceHandler<T, P, S, B> {
H1ServiceHandler { H1ServiceHandler {
srv: CloneableService::new(srv), srv: CloneableService::new(srv),
cfg, cfg,
@ -133,7 +133,7 @@ where
} }
} }
impl<T, S, B> Service for H1ServiceHandler<T, S, B> impl<T, P, S, B> Service for H1ServiceHandler<T, P, S, B>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
S: Service<Request = Request>, S: Service<Request = Request>,
@ -141,7 +141,7 @@ where
S::Response: Into<Response<B>>, S::Response: Into<Response<B>>,
B: MessageBody, B: MessageBody,
{ {
type Request = T; type Request = Io<T, P>;
type Response = (); type Response = ();
type Error = DispatchError; type Error = DispatchError;
type Future = Dispatcher<T, S, B>; type Future = Dispatcher<T, S, B>;
@ -153,19 +153,19 @@ where
}) })
} }
fn call(&mut self, req: T) -> Self::Future { fn call(&mut self, req: Self::Request) -> Self::Future {
Dispatcher::new(req, self.cfg.clone(), self.srv.clone()) Dispatcher::new(req.into_parts().0, self.cfg.clone(), self.srv.clone())
} }
} }
/// `NewService` implementation for `OneRequestService` service /// `NewService` implementation for `OneRequestService` service
#[derive(Default)] #[derive(Default)]
pub struct OneRequest<T> { pub struct OneRequest<T, P> {
config: ServiceConfig, config: ServiceConfig,
_t: PhantomData<T>, _t: PhantomData<(T, P)>,
} }
impl<T> OneRequest<T> impl<T, P> OneRequest<T, P>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
{ {
@ -178,15 +178,15 @@ where
} }
} }
impl<T> NewService<SrvConfig> for OneRequest<T> impl<T, P> NewService<SrvConfig> for OneRequest<T, P>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
{ {
type Request = T; type Request = Io<T, P>;
type Response = (Request, Framed<T, Codec>); type Response = (Request, Framed<T, Codec>);
type Error = ParseError; type Error = ParseError;
type InitError = (); type InitError = ();
type Service = OneRequestService<T>; type Service = OneRequestService<T, P>;
type Future = FutureResult<Self::Service, Self::InitError>; type Future = FutureResult<Self::Service, Self::InitError>;
fn new_service(&self, _: &SrvConfig) -> Self::Future { fn new_service(&self, _: &SrvConfig) -> Self::Future {
@ -199,16 +199,16 @@ where
/// `Service` implementation for HTTP1 transport. Reads one request and returns /// `Service` implementation for HTTP1 transport. Reads one request and returns
/// request and framed object. /// request and framed object.
pub struct OneRequestService<T> { pub struct OneRequestService<T, P> {
config: ServiceConfig, config: ServiceConfig,
_t: PhantomData<T>, _t: PhantomData<(T, P)>,
} }
impl<T> Service for OneRequestService<T> impl<T, P> Service for OneRequestService<T, P>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
{ {
type Request = T; type Request = Io<T, P>;
type Response = (Request, Framed<T, Codec>); type Response = (Request, Framed<T, Codec>);
type Error = ParseError; type Error = ParseError;
type Future = OneRequestServiceResponse<T>; type Future = OneRequestServiceResponse<T>;
@ -217,9 +217,12 @@ where
Ok(Async::Ready(())) Ok(Async::Ready(()))
} }
fn call(&mut self, req: T) -> Self::Future { fn call(&mut self, req: Self::Request) -> Self::Future {
OneRequestServiceResponse { OneRequestServiceResponse {
framed: Some(Framed::new(req, Codec::new(self.config.clone()))), framed: Some(Framed::new(
req.into_parts().0,
Codec::new(self.config.clone()),
)),
} }
} }
} }

40
src/h2/service.rs
View File

@ -3,7 +3,7 @@ use std::marker::PhantomData;
use std::{io, net}; use std::{io, net};
use actix_codec::{AsyncRead, AsyncWrite, Framed}; use actix_codec::{AsyncRead, AsyncWrite, Framed};
use actix_server_config::ServerConfig as SrvConfig; use actix_server_config::{Io, ServerConfig as SrvConfig};
use actix_service::{IntoNewService, NewService, Service}; use actix_service::{IntoNewService, NewService, Service};
use actix_utils::cloneable::CloneableService; use actix_utils::cloneable::CloneableService;
use bytes::Bytes; use bytes::Bytes;
@ -23,13 +23,13 @@ use crate::response::Response;
use super::dispatcher::Dispatcher; use super::dispatcher::Dispatcher;
/// `NewService` implementation for HTTP2 transport /// `NewService` implementation for HTTP2 transport
pub struct H2Service<T, S, B> { pub struct H2Service<T, P, S, B> {
srv: S, srv: S,
cfg: ServiceConfig, cfg: ServiceConfig,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, P, B)>,
} }
impl<T, S, B> H2Service<T, S, B> impl<T, P, S, B> H2Service<T, P, S, B>
where where
S: NewService<SrvConfig, Request = Request>, S: NewService<SrvConfig, Request = Request>,
S::Service: 'static, S::Service: 'static,
@ -61,7 +61,7 @@ where
} }
} }
impl<T, S, B> NewService<SrvConfig> for H2Service<T, S, B> impl<T, P, S, B> NewService<SrvConfig> for H2Service<T, P, S, B>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
S: NewService<SrvConfig, Request = Request>, S: NewService<SrvConfig, Request = Request>,
@ -70,12 +70,12 @@ where
S::Response: Into<Response<B>>, S::Response: Into<Response<B>>,
B: MessageBody + 'static, B: MessageBody + 'static,
{ {
type Request = T; type Request = Io<T, P>;
type Response = (); type Response = ();
type Error = DispatchError; type Error = DispatchError;
type InitError = S::InitError; type InitError = S::InitError;
type Service = H2ServiceHandler<T, S::Service, B>; type Service = H2ServiceHandler<T, P, S::Service, B>;
type Future = H2ServiceResponse<T, S, B>; type Future = H2ServiceResponse<T, P, S, B>;
fn new_service(&self, cfg: &SrvConfig) -> Self::Future { fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
H2ServiceResponse { H2ServiceResponse {
@ -87,13 +87,13 @@ where
} }
#[doc(hidden)] #[doc(hidden)]
pub struct H2ServiceResponse<T, S: NewService<SrvConfig, Request = Request>, B> { pub struct H2ServiceResponse<T, P, S: NewService<SrvConfig, Request = Request>, B> {
fut: <S::Future as IntoFuture>::Future, fut: <S::Future as IntoFuture>::Future,
cfg: Option<ServiceConfig>, cfg: Option<ServiceConfig>,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, P, B)>,
} }
impl<T, S, B> Future for H2ServiceResponse<T, S, B> impl<T, P, S, B> Future for H2ServiceResponse<T, P, S, B>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
S: NewService<SrvConfig, Request = Request>, S: NewService<SrvConfig, Request = Request>,
@ -102,7 +102,7 @@ where
S::Error: Debug, S::Error: Debug,
B: MessageBody + 'static, B: MessageBody + 'static,
{ {
type Item = H2ServiceHandler<T, S::Service, B>; type Item = H2ServiceHandler<T, P, S::Service, B>;
type Error = S::InitError; type Error = S::InitError;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> { fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@ -115,20 +115,20 @@ where
} }
/// `Service` implementation for http/2 transport /// `Service` implementation for http/2 transport
pub struct H2ServiceHandler<T, S: 'static, B> { pub struct H2ServiceHandler<T, P, S: 'static, B> {
srv: CloneableService<S>, srv: CloneableService<S>,
cfg: ServiceConfig, cfg: ServiceConfig,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, P, B)>,
} }
impl<T, S, B> H2ServiceHandler<T, S, B> impl<T, P, S, B> H2ServiceHandler<T, P, S, B>
where where
S: Service<Request = Request> + 'static, S: Service<Request = Request> + 'static,
S::Error: Debug, S::Error: Debug,
S::Response: Into<Response<B>>, S::Response: Into<Response<B>>,
B: MessageBody + 'static, B: MessageBody + 'static,
{ {
fn new(cfg: ServiceConfig, srv: S) -> H2ServiceHandler<T, S, B> { fn new(cfg: ServiceConfig, srv: S) -> H2ServiceHandler<T, P, S, B> {
H2ServiceHandler { H2ServiceHandler {
cfg, cfg,
srv: CloneableService::new(srv), srv: CloneableService::new(srv),
@ -137,7 +137,7 @@ where
} }
} }
impl<T, S, B> Service for H2ServiceHandler<T, S, B> impl<T, P, S, B> Service for H2ServiceHandler<T, P, S, B>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
S: Service<Request = Request> + 'static, S: Service<Request = Request> + 'static,
@ -145,7 +145,7 @@ where
S::Response: Into<Response<B>>, S::Response: Into<Response<B>>,
B: MessageBody + 'static, B: MessageBody + 'static,
{ {
type Request = T; type Request = Io<T, P>;
type Response = (); type Response = ();
type Error = DispatchError; type Error = DispatchError;
type Future = H2ServiceHandlerResponse<T, S, B>; type Future = H2ServiceHandlerResponse<T, S, B>;
@ -157,12 +157,12 @@ where
}) })
} }
fn call(&mut self, req: T) -> Self::Future { fn call(&mut self, req: Self::Request) -> Self::Future {
H2ServiceHandlerResponse { H2ServiceHandlerResponse {
state: State::Handshake( state: State::Handshake(
Some(self.srv.clone()), Some(self.srv.clone()),
Some(self.cfg.clone()), Some(self.cfg.clone()),
server::handshake(req), server::handshake(req.into_parts().0),
), ),
} }
} }

94
src/service/service.rs
View File

@ -3,7 +3,7 @@ use std::marker::PhantomData;
use std::{fmt, io}; use std::{fmt, io};
use actix_codec::{AsyncRead, AsyncWrite, Framed, FramedParts}; use actix_codec::{AsyncRead, AsyncWrite, Framed, FramedParts};
use actix_server_config::ServerConfig as SrvConfig; use actix_server_config::{Io as ServerIo, Protocol, ServerConfig as SrvConfig};
use actix_service::{IntoNewService, NewService, Service}; use actix_service::{IntoNewService, NewService, Service};
use actix_utils::cloneable::CloneableService; use actix_utils::cloneable::CloneableService;
use bytes::{Buf, BufMut, Bytes, BytesMut}; use bytes::{Buf, BufMut, Bytes, BytesMut};
@ -20,13 +20,27 @@ use crate::response::Response;
use crate::{h1, h2::Dispatcher}; use crate::{h1, h2::Dispatcher};
/// `NewService` HTTP1.1/HTTP2 transport implementation /// `NewService` HTTP1.1/HTTP2 transport implementation
pub struct HttpService<T, S, B> { pub struct HttpService<T, P, S, B> {
srv: S, srv: S,
cfg: ServiceConfig, cfg: ServiceConfig,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, P, B)>,
} }
impl<T, S, B> HttpService<T, S, B> impl<T, S, B> HttpService<T, (), S, B>
where
S: NewService<SrvConfig, Request = Request>,
S::Service: 'static,
S::Error: Debug + 'static,
S::Response: Into<Response<B>>,
B: MessageBody + 'static,
{
/// Create builder for `HttpService` instance.
pub fn build() -> HttpServiceBuilder<T, S> {
HttpServiceBuilder::new()
}
}
impl<T, P, S, B> HttpService<T, P, S, B>
where where
S: NewService<SrvConfig, Request = Request>, S: NewService<SrvConfig, Request = Request>,
S::Service: 'static, S::Service: 'static,
@ -56,14 +70,9 @@ where
_t: PhantomData, _t: PhantomData,
} }
} }
/// Create builder for `HttpService` instance.
pub fn build() -> HttpServiceBuilder<T, S> {
HttpServiceBuilder::new()
}
} }
impl<T, S, B> NewService<SrvConfig> for HttpService<T, S, B> impl<T, P, S, B> NewService<SrvConfig> for HttpService<T, P, S, B>
where where
T: AsyncRead + AsyncWrite + 'static, T: AsyncRead + AsyncWrite + 'static,
S: NewService<SrvConfig, Request = Request>, S: NewService<SrvConfig, Request = Request>,
@ -72,12 +81,12 @@ where
S::Response: Into<Response<B>>, S::Response: Into<Response<B>>,
B: MessageBody + 'static, B: MessageBody + 'static,
{ {
type Request = T; type Request = ServerIo<T, P>;
type Response = (); type Response = ();
type Error = DispatchError; type Error = DispatchError;
type InitError = S::InitError; type InitError = S::InitError;
type Service = HttpServiceHandler<T, S::Service, B>; type Service = HttpServiceHandler<T, P, S::Service, B>;
type Future = HttpServiceResponse<T, S, B>; type Future = HttpServiceResponse<T, P, S, B>;
fn new_service(&self, cfg: &SrvConfig) -> Self::Future { fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
HttpServiceResponse { HttpServiceResponse {
@ -89,13 +98,13 @@ where
} }
#[doc(hidden)] #[doc(hidden)]
pub struct HttpServiceResponse<T, S: NewService<SrvConfig>, B> { pub struct HttpServiceResponse<T, P, S: NewService<SrvConfig>, B> {
fut: <S::Future as IntoFuture>::Future, fut: <S::Future as IntoFuture>::Future,
cfg: Option<ServiceConfig>, cfg: Option<ServiceConfig>,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, P, B)>,
} }
impl<T, S, B> Future for HttpServiceResponse<T, S, B> impl<T, P, S, B> Future for HttpServiceResponse<T, P, S, B>
where where
T: AsyncRead + AsyncWrite, T: AsyncRead + AsyncWrite,
S: NewService<SrvConfig, Request = Request>, S: NewService<SrvConfig, Request = Request>,
@ -104,7 +113,7 @@ where
S::Error: Debug, S::Error: Debug,
B: MessageBody + 'static, B: MessageBody + 'static,
{ {
type Item = HttpServiceHandler<T, S::Service, B>; type Item = HttpServiceHandler<T, P, S::Service, B>;
type Error = S::InitError; type Error = S::InitError;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> { fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
@ -117,20 +126,20 @@ where
} }
/// `Service` implementation for http transport /// `Service` implementation for http transport
pub struct HttpServiceHandler<T, S: 'static, B> { pub struct HttpServiceHandler<T, P, S: 'static, B> {
srv: CloneableService<S>, srv: CloneableService<S>,
cfg: ServiceConfig, cfg: ServiceConfig,
_t: PhantomData<(T, B)>, _t: PhantomData<(T, P, B)>,
} }
impl<T, S, B> HttpServiceHandler<T, S, B> impl<T, P, S, B> HttpServiceHandler<T, P, S, B>
where where
S: Service<Request = Request> + 'static, S: Service<Request = Request> + 'static,
S::Error: Debug, S::Error: Debug,
S::Response: Into<Response<B>>, S::Response: Into<Response<B>>,
B: MessageBody + 'static, B: MessageBody + 'static,
{ {
fn new(cfg: ServiceConfig, srv: S) -> HttpServiceHandler<T, S, B> { fn new(cfg: ServiceConfig, srv: S) -> HttpServiceHandler<T, P, S, B> {
HttpServiceHandler { HttpServiceHandler {
cfg, cfg,
srv: CloneableService::new(srv), srv: CloneableService::new(srv),
@ -139,7 +148,7 @@ where
} }
} }
impl<T, S, B> Service for HttpServiceHandler<T, S, B> impl<T, P, S, B> Service for HttpServiceHandler<T, P, S, B>
where where
T: AsyncRead + AsyncWrite + 'static, T: AsyncRead + AsyncWrite + 'static,
S: Service<Request = Request> + 'static, S: Service<Request = Request> + 'static,
@ -147,7 +156,7 @@ where
S::Response: Into<Response<B>>, S::Response: Into<Response<B>>,
B: MessageBody + 'static, B: MessageBody + 'static,
{ {
type Request = T; type Request = ServerIo<T, P>;
type Response = (); type Response = ();
type Error = DispatchError; type Error = DispatchError;
type Future = HttpServiceHandlerResponse<T, S, B>; type Future = HttpServiceHandlerResponse<T, S, B>;
@ -159,14 +168,37 @@ where
}) })
} }
fn call(&mut self, req: T) -> Self::Future { fn call(&mut self, req: Self::Request) -> Self::Future {
HttpServiceHandlerResponse { let (io, params, proto) = req.into_parts();
state: State::Unknown(Some(( match proto {
req, Protocol::Http2 => {
BytesMut::with_capacity(14), let io = Io {
self.cfg.clone(), inner: io,
self.srv.clone(), unread: None,
))), };
HttpServiceHandlerResponse {
state: State::Handshake(Some((
server::handshake(io),
self.cfg.clone(),
self.srv.clone(),
))),
}
}
Protocol::Http10 | Protocol::Http11 => HttpServiceHandlerResponse {
state: State::H1(h1::Dispatcher::new(
io,
self.cfg.clone(),
self.srv.clone(),
)),
},
_ => HttpServiceHandlerResponse {
state: State::Unknown(Some((
io,
BytesMut::with_capacity(14),
self.cfg.clone(),
self.srv.clone(),
))),
},
} }
} }
} }

2
tests/test_server.rs
View File

@ -49,7 +49,7 @@ fn test_h1_2() {
} }
#[cfg(feature = "ssl")] #[cfg(feature = "ssl")]
fn ssl_acceptor<T>() -> std::io::Result<actix_server::ssl::OpensslAcceptor<T>> { fn ssl_acceptor<T>() -> std::io::Result<actix_server::ssl::OpensslAcceptor<T, ()>> {
use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod}; use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
// load ssl keys // load ssl keys
let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap(); let mut builder = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();

6
tests/test_ws.rs
View File

@ -2,7 +2,8 @@ use std::io;
use actix_codec::Framed; use actix_codec::Framed;
use actix_http_test::TestServer; use actix_http_test::TestServer;
use actix_service::NewService; use actix_server::Io;
use actix_service::{fn_service, NewService};
use actix_utils::framed::IntoFramed; use actix_utils::framed::IntoFramed;
use actix_utils::stream::TakeItem; use actix_utils::stream::TakeItem;
use bytes::{Bytes, BytesMut}; use bytes::{Bytes, BytesMut};
@ -35,7 +36,8 @@ fn ws_service(req: ws::Frame) -> impl Future<Item = ws::Message, Error = io::Err
#[test] #[test]
fn test_simple() { fn test_simple() {
let mut srv = TestServer::new(|| { let mut srv = TestServer::new(|| {
IntoFramed::new(|| h1::Codec::new(ServiceConfig::default())) fn_service(|io: Io<_>| Ok(io.into_parts().0))
.and_then(IntoFramed::new(|| h1::Codec::new(ServiceConfig::default())))
.and_then(TakeItem::new().map_err(|_| ())) .and_then(TakeItem::new().map_err(|_| ()))
.and_then(|(req, framed): (_, Framed<_, _>)| { .and_then(|(req, framed): (_, Framed<_, _>)| {
// validate request // validate request