Merge actix-http project

actix-http/src/h1/client.rs

@@ -0,0 +1,241 @@
+#![allow(unused_imports, unused_variables, dead_code)]
+use std::io::{self, Write};
+
+use actix_codec::{Decoder, Encoder};
+use bitflags::bitflags;
+use bytes::{BufMut, Bytes, BytesMut};
+use http::header::{
+    HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING, UPGRADE,
+};
+use http::{Method, Version};
+
+use super::decoder::{PayloadDecoder, PayloadItem, PayloadType};
+use super::{decoder, encoder};
+use super::{Message, MessageType};
+use crate::body::BodyLength;
+use crate::config::ServiceConfig;
+use crate::error::{ParseError, PayloadError};
+use crate::helpers;
+use crate::message::{ConnectionType, Head, MessagePool, RequestHead, ResponseHead};
+
+bitflags! {
+    struct Flags: u8 {
+        const HEAD              = 0b0000_0001;
+        const KEEPALIVE_ENABLED = 0b0000_1000;
+        const STREAM            = 0b0001_0000;
+    }
+}
+
+const AVERAGE_HEADER_SIZE: usize = 30;
+
+/// HTTP/1 Codec
+pub struct ClientCodec {
+    inner: ClientCodecInner,
+}
+
+/// HTTP/1 Payload Codec
+pub struct ClientPayloadCodec {
+    inner: ClientCodecInner,
+}
+
+struct ClientCodecInner {
+    config: ServiceConfig,
+    decoder: decoder::MessageDecoder<ResponseHead>,
+    payload: Option<PayloadDecoder>,
+    version: Version,
+    ctype: ConnectionType,
+
+    // encoder part
+    flags: Flags,
+    headers_size: u32,
+    encoder: encoder::MessageEncoder<RequestHead>,
+}
+
+impl Default for ClientCodec {
+    fn default() -> Self {
+        ClientCodec::new(ServiceConfig::default())
+    }
+}
+
+impl ClientCodec {
+    /// Create HTTP/1 codec.
+    ///
+    /// `keepalive_enabled` how response `connection` header get generated.
+    pub fn new(config: ServiceConfig) -> Self {
+        let flags = if config.keep_alive_enabled() {
+            Flags::KEEPALIVE_ENABLED
+        } else {
+            Flags::empty()
+        };
+        ClientCodec {
+            inner: ClientCodecInner {
+                config,
+                decoder: decoder::MessageDecoder::default(),
+                payload: None,
+                version: Version::HTTP_11,
+                ctype: ConnectionType::Close,
+
+                flags,
+                headers_size: 0,
+                encoder: encoder::MessageEncoder::default(),
+            },
+        }
+    }
+
+    /// Check if request is upgrade
+    pub fn upgrade(&self) -> bool {
+        self.inner.ctype == ConnectionType::Upgrade
+    }
+
+    /// Check if last response is keep-alive
+    pub fn keepalive(&self) -> bool {
+        self.inner.ctype == ConnectionType::KeepAlive
+    }
+
+    /// Check last request's message type
+    pub fn message_type(&self) -> MessageType {
+        if self.inner.flags.contains(Flags::STREAM) {
+            MessageType::Stream
+        } else if self.inner.payload.is_none() {
+            MessageType::None
+        } else {
+            MessageType::Payload
+        }
+    }
+
+    /// Convert message codec to a payload codec
+    pub fn into_payload_codec(self) -> ClientPayloadCodec {
+        ClientPayloadCodec { inner: self.inner }
+    }
+}
+
+impl ClientPayloadCodec {
+    /// Check if last response is keep-alive
+    pub fn keepalive(&self) -> bool {
+        self.inner.ctype == ConnectionType::KeepAlive
+    }
+
+    /// Transform payload codec to a message codec
+    pub fn into_message_codec(self) -> ClientCodec {
+        ClientCodec { inner: self.inner }
+    }
+}
+
+impl Decoder for ClientCodec {
+    type Item = ResponseHead;
+    type Error = ParseError;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        debug_assert!(!self.inner.payload.is_some(), "Payload decoder is set");
+
+        if let Some((req, payload)) = self.inner.decoder.decode(src)? {
+            if let Some(ctype) = req.ctype {
+                // do not use peer's keep-alive
+                self.inner.ctype = if ctype == ConnectionType::KeepAlive {
+                    self.inner.ctype
+                } else {
+                    ctype
+                };
+            }
+
+            if !self.inner.flags.contains(Flags::HEAD) {
+                match payload {
+                    PayloadType::None => self.inner.payload = None,
+                    PayloadType::Payload(pl) => self.inner.payload = Some(pl),
+                    PayloadType::Stream(pl) => {
+                        self.inner.payload = Some(pl);
+                        self.inner.flags.insert(Flags::STREAM);
+                    }
+                }
+            } else {
+                self.inner.payload = None;
+            }
+            Ok(Some(req))
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+impl Decoder for ClientPayloadCodec {
+    type Item = Option<Bytes>;
+    type Error = PayloadError;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        debug_assert!(
+            self.inner.payload.is_some(),
+            "Payload decoder is not specified"
+        );
+
+        Ok(match self.inner.payload.as_mut().unwrap().decode(src)? {
+            Some(PayloadItem::Chunk(chunk)) => Some(Some(chunk)),
+            Some(PayloadItem::Eof) => {
+                self.inner.payload.take();
+                Some(None)
+            }
+            None => None,
+        })
+    }
+}
+
+impl Encoder for ClientCodec {
+    type Item = Message<(RequestHead, BodyLength)>;
+    type Error = io::Error;
+
+    fn encode(
+        &mut self,
+        item: Self::Item,
+        dst: &mut BytesMut,
+    ) -> Result<(), Self::Error> {
+        match item {
+            Message::Item((mut msg, length)) => {
+                let inner = &mut self.inner;
+                inner.version = msg.version;
+                inner.flags.set(Flags::HEAD, msg.method == Method::HEAD);
+
+                // connection status
+                inner.ctype = match msg.connection_type() {
+                    ConnectionType::KeepAlive => {
+                        if inner.flags.contains(Flags::KEEPALIVE_ENABLED) {
+                            ConnectionType::KeepAlive
+                        } else {
+                            ConnectionType::Close
+                        }
+                    }
+                    ConnectionType::Upgrade => ConnectionType::Upgrade,
+                    ConnectionType::Close => ConnectionType::Close,
+                };
+
+                inner.encoder.encode(
+                    dst,
+                    &mut msg,
+                    false,
+                    false,
+                    inner.version,
+                    length,
+                    inner.ctype,
+                    &inner.config,
+                )?;
+            }
+            Message::Chunk(Some(bytes)) => {
+                self.inner.encoder.encode_chunk(bytes.as_ref(), dst)?;
+            }
+            Message::Chunk(None) => {
+                self.inner.encoder.encode_eof(dst)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+pub struct Writer<'a>(pub &'a mut BytesMut);
+
+impl<'a> io::Write for Writer<'a> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0.extend_from_slice(buf);
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}

actix-http/src/h1/codec.rs

@@ -0,0 +1,242 @@
+#![allow(unused_imports, unused_variables, dead_code)]
+use std::fmt;
+use std::io::{self, Write};
+
+use actix_codec::{Decoder, Encoder};
+use bitflags::bitflags;
+use bytes::{BufMut, Bytes, BytesMut};
+use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
+use http::{Method, StatusCode, Version};
+
+use super::decoder::{PayloadDecoder, PayloadItem, PayloadType};
+use super::{decoder, encoder};
+use super::{Message, MessageType};
+use crate::body::BodyLength;
+use crate::config::ServiceConfig;
+use crate::error::ParseError;
+use crate::helpers;
+use crate::message::{ConnectionType, Head, ResponseHead};
+use crate::request::Request;
+use crate::response::Response;
+
+bitflags! {
+    struct Flags: u8 {
+        const HEAD              = 0b0000_0001;
+        const KEEPALIVE_ENABLED = 0b0000_1000;
+        const STREAM            = 0b0001_0000;
+    }
+}
+
+const AVERAGE_HEADER_SIZE: usize = 30;
+
+/// HTTP/1 Codec
+pub struct Codec {
+    config: ServiceConfig,
+    decoder: decoder::MessageDecoder<Request>,
+    payload: Option<PayloadDecoder>,
+    version: Version,
+    ctype: ConnectionType,
+
+    // encoder part
+    flags: Flags,
+    headers_size: u32,
+    encoder: encoder::MessageEncoder<Response<()>>,
+}
+
+impl Default for Codec {
+    fn default() -> Self {
+        Codec::new(ServiceConfig::default())
+    }
+}
+
+impl fmt::Debug for Codec {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "h1::Codec({:?})", self.flags)
+    }
+}
+
+impl Codec {
+    /// Create HTTP/1 codec.
+    ///
+    /// `keepalive_enabled` how response `connection` header get generated.
+    pub fn new(config: ServiceConfig) -> Self {
+        let flags = if config.keep_alive_enabled() {
+            Flags::KEEPALIVE_ENABLED
+        } else {
+            Flags::empty()
+        };
+        Codec {
+            config,
+            decoder: decoder::MessageDecoder::default(),
+            payload: None,
+            version: Version::HTTP_11,
+            ctype: ConnectionType::Close,
+
+            flags,
+            headers_size: 0,
+            encoder: encoder::MessageEncoder::default(),
+        }
+    }
+
+    /// Check if request is upgrade
+    pub fn upgrade(&self) -> bool {
+        self.ctype == ConnectionType::Upgrade
+    }
+
+    /// Check if last response is keep-alive
+    pub fn keepalive(&self) -> bool {
+        self.ctype == ConnectionType::KeepAlive
+    }
+
+    /// Check last request's message type
+    pub fn message_type(&self) -> MessageType {
+        if self.flags.contains(Flags::STREAM) {
+            MessageType::Stream
+        } else if self.payload.is_none() {
+            MessageType::None
+        } else {
+            MessageType::Payload
+        }
+    }
+}
+
+impl Decoder for Codec {
+    type Item = Message<Request>;
+    type Error = ParseError;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        if self.payload.is_some() {
+            Ok(match self.payload.as_mut().unwrap().decode(src)? {
+                Some(PayloadItem::Chunk(chunk)) => Some(Message::Chunk(Some(chunk))),
+                Some(PayloadItem::Eof) => {
+                    self.payload.take();
+                    Some(Message::Chunk(None))
+                }
+                None => None,
+            })
+        } else if let Some((req, payload)) = self.decoder.decode(src)? {
+            let head = req.head();
+            self.flags.set(Flags::HEAD, head.method == Method::HEAD);
+            self.version = head.version;
+            self.ctype = head.connection_type();
+            if self.ctype == ConnectionType::KeepAlive
+                && !self.flags.contains(Flags::KEEPALIVE_ENABLED)
+            {
+                self.ctype = ConnectionType::Close
+            }
+            match payload {
+                PayloadType::None => self.payload = None,
+                PayloadType::Payload(pl) => self.payload = Some(pl),
+                PayloadType::Stream(pl) => {
+                    self.payload = Some(pl);
+                    self.flags.insert(Flags::STREAM);
+                }
+            }
+            Ok(Some(Message::Item(req)))
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+impl Encoder for Codec {
+    type Item = Message<(Response<()>, BodyLength)>;
+    type Error = io::Error;
+
+    fn encode(
+        &mut self,
+        item: Self::Item,
+        dst: &mut BytesMut,
+    ) -> Result<(), Self::Error> {
+        match item {
+            Message::Item((mut res, length)) => {
+                // set response version
+                res.head_mut().version = self.version;
+
+                // connection status
+                self.ctype = if let Some(ct) = res.head().ctype {
+                    if ct == ConnectionType::KeepAlive {
+                        self.ctype
+                    } else {
+                        ct
+                    }
+                } else {
+                    self.ctype
+                };
+
+                // encode message
+                let len = dst.len();
+                self.encoder.encode(
+                    dst,
+                    &mut res,
+                    self.flags.contains(Flags::HEAD),
+                    self.flags.contains(Flags::STREAM),
+                    self.version,
+                    length,
+                    self.ctype,
+                    &self.config,
+                )?;
+                self.headers_size = (dst.len() - len) as u32;
+            }
+            Message::Chunk(Some(bytes)) => {
+                self.encoder.encode_chunk(bytes.as_ref(), dst)?;
+            }
+            Message::Chunk(None) => {
+                self.encoder.encode_eof(dst)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{cmp, io};
+
+    use actix_codec::{AsyncRead, AsyncWrite};
+    use bytes::{Buf, Bytes, BytesMut};
+    use http::{Method, Version};
+
+    use super::*;
+    use crate::error::ParseError;
+    use crate::h1::Message;
+    use crate::httpmessage::HttpMessage;
+    use crate::request::Request;
+
+    #[test]
+    fn test_http_request_chunked_payload_and_next_message() {
+        let mut codec = Codec::default();
+
+        let mut buf = BytesMut::from(
+            "GET /test HTTP/1.1\r\n\
+             transfer-encoding: chunked\r\n\r\n",
+        );
+        let item = codec.decode(&mut buf).unwrap().unwrap();
+        let req = item.message();
+
+        assert_eq!(req.method(), Method::GET);
+        assert!(req.chunked().unwrap());
+
+        buf.extend(
+            b"4\r\ndata\r\n4\r\nline\r\n0\r\n\r\n\
+               POST /test2 HTTP/1.1\r\n\
+               transfer-encoding: chunked\r\n\r\n"
+                .iter(),
+        );
+
+        let msg = codec.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(msg.chunk().as_ref(), b"data");
+
+        let msg = codec.decode(&mut buf).unwrap().unwrap();
+        assert_eq!(msg.chunk().as_ref(), b"line");
+
+        let msg = codec.decode(&mut buf).unwrap().unwrap();
+        assert!(msg.eof());
+
+        // decode next message
+        let item = codec.decode(&mut buf).unwrap().unwrap();
+        let req = item.message();
+        assert_eq!(*req.method(), Method::POST);
+        assert!(req.chunked().unwrap());
+    }
+}

actix-http/src/h1/dispatcher.rs

@@ -0,0 +1,636 @@
+use std::collections::VecDeque;
+use std::fmt::Debug;
+use std::mem;
+use std::time::Instant;
+
+use actix_codec::{AsyncRead, AsyncWrite, Framed};
+use actix_service::Service;
+use actix_utils::cloneable::CloneableService;
+use bitflags::bitflags;
+use futures::{Async, Future, Poll, Sink, Stream};
+use log::{debug, error, trace};
+use tokio_timer::Delay;
+
+use crate::body::{Body, BodyLength, MessageBody, ResponseBody};
+use crate::config::ServiceConfig;
+use crate::error::DispatchError;
+use crate::error::{ParseError, PayloadError};
+use crate::request::Request;
+use crate::response::Response;
+
+use super::codec::Codec;
+use super::payload::{Payload, PayloadSender, PayloadStatus, PayloadWriter};
+use super::{Message, MessageType};
+
+const MAX_PIPELINED_MESSAGES: usize = 16;
+
+bitflags! {
+    pub struct Flags: u8 {
+        const STARTED            = 0b0000_0001;
+        const KEEPALIVE_ENABLED  = 0b0000_0010;
+        const KEEPALIVE          = 0b0000_0100;
+        const POLLED             = 0b0000_1000;
+        const SHUTDOWN           = 0b0010_0000;
+        const DISCONNECTED       = 0b0100_0000;
+        const DROPPING           = 0b1000_0000;
+    }
+}
+
+/// Dispatcher for HTTP/1.1 protocol
+pub struct Dispatcher<T, S: Service<Request = Request> + 'static, B: MessageBody>
+where
+    S::Error: Debug,
+{
+    inner: Option<InnerDispatcher<T, S, B>>,
+}
+
+struct InnerDispatcher<T, S: Service<Request = Request> + 'static, B: MessageBody>
+where
+    S::Error: Debug,
+{
+    service: CloneableService<S>,
+    flags: Flags,
+    framed: Framed<T, Codec>,
+    error: Option<DispatchError>,
+    config: ServiceConfig,
+
+    state: State<S, B>,
+    payload: Option<PayloadSender>,
+    messages: VecDeque<DispatcherMessage>,
+
+    ka_expire: Instant,
+    ka_timer: Option<Delay>,
+}
+
+enum DispatcherMessage {
+    Item(Request),
+    Error(Response<()>),
+}
+
+enum State<S: Service<Request = Request>, B: MessageBody> {
+    None,
+    ServiceCall(S::Future),
+    SendPayload(ResponseBody<B>),
+}
+
+impl<S: Service<Request = Request>, B: MessageBody> State<S, B> {
+    fn is_empty(&self) -> bool {
+        if let State::None = self {
+            true
+        } else {
+            false
+        }
+    }
+}
+
+impl<T, S, B> Dispatcher<T, S, B>
+where
+    T: AsyncRead + AsyncWrite,
+    S: Service<Request = Request> + 'static,
+    S::Error: Debug,
+    S::Response: Into<Response<B>>,
+    B: MessageBody,
+{
+    /// Create http/1 dispatcher.
+    pub fn new(stream: T, config: ServiceConfig, service: CloneableService<S>) -> Self {
+        Dispatcher::with_timeout(
+            Framed::new(stream, Codec::new(config.clone())),
+            config,
+            None,
+            service,
+        )
+    }
+
+    /// Create http/1 dispatcher with slow request timeout.
+    pub fn with_timeout(
+        framed: Framed<T, Codec>,
+        config: ServiceConfig,
+        timeout: Option<Delay>,
+        service: CloneableService<S>,
+    ) -> Self {
+        let keepalive = config.keep_alive_enabled();
+        let flags = if keepalive {
+            Flags::KEEPALIVE | Flags::KEEPALIVE_ENABLED
+        } else {
+            Flags::empty()
+        };
+
+        // keep-alive timer
+        let (ka_expire, ka_timer) = if let Some(delay) = timeout {
+            (delay.deadline(), Some(delay))
+        } else if let Some(delay) = config.keep_alive_timer() {
+            (delay.deadline(), Some(delay))
+        } else {
+            (config.now(), None)
+        };
+
+        Dispatcher {
+            inner: Some(InnerDispatcher {
+                framed,
+                payload: None,
+                state: State::None,
+                error: None,
+                messages: VecDeque::new(),
+                service,
+                flags,
+                config,
+                ka_expire,
+                ka_timer,
+            }),
+        }
+    }
+}
+
+impl<T, S, B> InnerDispatcher<T, S, B>
+where
+    T: AsyncRead + AsyncWrite,
+    S: Service<Request = Request> + 'static,
+    S::Error: Debug,
+    S::Response: Into<Response<B>>,
+    B: MessageBody,
+{
+    fn can_read(&self) -> bool {
+        if self.flags.contains(Flags::DISCONNECTED) {
+            return false;
+        }
+
+        if let Some(ref info) = self.payload {
+            info.need_read() == PayloadStatus::Read
+        } else {
+            true
+        }
+    }
+
+    // if checked is set to true, delay disconnect until all tasks have finished.
+    fn client_disconnected(&mut self) {
+        self.flags.insert(Flags::DISCONNECTED);
+        if let Some(mut payload) = self.payload.take() {
+            payload.set_error(PayloadError::Incomplete(None));
+        }
+    }
+
+    /// Flush stream
+    fn poll_flush(&mut self) -> Poll<bool, DispatchError> {
+        if !self.framed.is_write_buf_empty() {
+            match self.framed.poll_complete() {
+                Ok(Async::NotReady) => Ok(Async::NotReady),
+                Err(err) => {
+                    debug!("Error sending data: {}", err);
+                    Err(err.into())
+                }
+                Ok(Async::Ready(_)) => {
+                    // if payload is not consumed we can not use connection
+                    if self.payload.is_some() && self.state.is_empty() {
+                        return Err(DispatchError::PayloadIsNotConsumed);
+                    }
+                    Ok(Async::Ready(true))
+                }
+            }
+        } else {
+            Ok(Async::Ready(false))
+        }
+    }
+
+    fn send_response(
+        &mut self,
+        message: Response<()>,
+        body: ResponseBody<B>,
+    ) -> Result<State<S, B>, DispatchError> {
+        self.framed
+            .force_send(Message::Item((message, body.length())))
+            .map_err(|err| {
+                if let Some(mut payload) = self.payload.take() {
+                    payload.set_error(PayloadError::Incomplete(None));
+                }
+                DispatchError::Io(err)
+            })?;
+
+        self.flags
+            .set(Flags::KEEPALIVE, self.framed.get_codec().keepalive());
+        match body.length() {
+            BodyLength::None | BodyLength::Empty => Ok(State::None),
+            _ => Ok(State::SendPayload(body)),
+        }
+    }
+
+    fn poll_response(&mut self) -> Result<(), DispatchError> {
+        let mut retry = self.can_read();
+        loop {
+            let state = match mem::replace(&mut self.state, State::None) {
+                State::None => match self.messages.pop_front() {
+                    Some(DispatcherMessage::Item(req)) => {
+                        Some(self.handle_request(req)?)
+                    }
+                    Some(DispatcherMessage::Error(res)) => {
+                        self.send_response(res, ResponseBody::Other(Body::Empty))?;
+                        None
+                    }
+                    None => None,
+                },
+                State::ServiceCall(mut fut) => match fut.poll() {
+                    Ok(Async::Ready(res)) => {
+                        let (res, body) = res.into().replace_body(());
+                        Some(self.send_response(res, body)?)
+                    }
+                    Ok(Async::NotReady) => {
+                        self.state = State::ServiceCall(fut);
+                        None
+                    }
+                    Err(_e) => {
+                        let res: Response = Response::InternalServerError().finish();
+                        let (res, body) = res.replace_body(());
+                        Some(self.send_response(res, body.into_body())?)
+                    }
+                },
+                State::SendPayload(mut stream) => {
+                    loop {
+                        if !self.framed.is_write_buf_full() {
+                            match stream
+                                .poll_next()
+                                .map_err(|_| DispatchError::Unknown)?
+                            {
+                                Async::Ready(Some(item)) => {
+                                    self.framed
+                                        .force_send(Message::Chunk(Some(item)))?;
+                                    continue;
+                                }
+                                Async::Ready(None) => {
+                                    self.framed.force_send(Message::Chunk(None))?;
+                                }
+                                Async::NotReady => {
+                                    self.state = State::SendPayload(stream);
+                                    return Ok(());
+                                }
+                            }
+                        } else {
+                            self.state = State::SendPayload(stream);
+                            return Ok(());
+                        }
+                        break;
+                    }
+                    None
+                }
+            };
+
+            match state {
+                Some(state) => self.state = state,
+                None => {
+                    // if read-backpressure is enabled and we consumed some data.
+                    // we may read more data and retry
+                    if !retry && self.can_read() && self.poll_request()? {
+                        retry = self.can_read();
+                        continue;
+                    }
+                    break;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn handle_request(&mut self, req: Request) -> Result<State<S, B>, DispatchError> {
+        let mut task = self.service.call(req);
+        match task.poll() {
+            Ok(Async::Ready(res)) => {
+                let (res, body) = res.into().replace_body(());
+                self.send_response(res, body)
+            }
+            Ok(Async::NotReady) => Ok(State::ServiceCall(task)),
+            Err(_e) => {
+                let res: Response = Response::InternalServerError().finish();
+                let (res, body) = res.replace_body(());
+                self.send_response(res, body.into_body())
+            }
+        }
+    }
+
+    /// Process one incoming requests
+    pub(self) fn poll_request(&mut self) -> Result<bool, DispatchError> {
+        // limit a mount of non processed requests
+        if self.messages.len() >= MAX_PIPELINED_MESSAGES {
+            return Ok(false);
+        }
+
+        let mut updated = false;
+        loop {
+            match self.framed.poll() {
+                Ok(Async::Ready(Some(msg))) => {
+                    updated = true;
+                    self.flags.insert(Flags::STARTED);
+
+                    match msg {
+                        Message::Item(mut req) => {
+                            match self.framed.get_codec().message_type() {
+                                MessageType::Payload | MessageType::Stream => {
+                                    let (ps, pl) = Payload::create(false);
+                                    let (req1, _) =
+                                        req.replace_payload(crate::Payload::H1(pl));
+                                    req = req1;
+                                    self.payload = Some(ps);
+                                }
+                                //MessageType::Stream => {
+                                //    self.unhandled = Some(req);
+                                //    return Ok(updated);
+                                //}
+                                _ => (),
+                            }
+
+                            // handle request early
+                            if self.state.is_empty() {
+                                self.state = self.handle_request(req)?;
+                            } else {
+                                self.messages.push_back(DispatcherMessage::Item(req));
+                            }
+                        }
+                        Message::Chunk(Some(chunk)) => {
+                            if let Some(ref mut payload) = self.payload {
+                                payload.feed_data(chunk);
+                            } else {
+                                error!(
+                                    "Internal server error: unexpected payload chunk"
+                                );
+                                self.flags.insert(Flags::DISCONNECTED);
+                                self.messages.push_back(DispatcherMessage::Error(
+                                    Response::InternalServerError().finish().drop_body(),
+                                ));
+                                self.error = Some(DispatchError::InternalError);
+                                break;
+                            }
+                        }
+                        Message::Chunk(None) => {
+                            if let Some(mut payload) = self.payload.take() {
+                                payload.feed_eof();
+                            } else {
+                                error!("Internal server error: unexpected eof");
+                                self.flags.insert(Flags::DISCONNECTED);
+                                self.messages.push_back(DispatcherMessage::Error(
+                                    Response::InternalServerError().finish().drop_body(),
+                                ));
+                                self.error = Some(DispatchError::InternalError);
+                                break;
+                            }
+                        }
+                    }
+                }
+                Ok(Async::Ready(None)) => {
+                    self.client_disconnected();
+                    break;
+                }
+                Ok(Async::NotReady) => break,
+                Err(ParseError::Io(e)) => {
+                    self.client_disconnected();
+                    self.error = Some(DispatchError::Io(e));
+                    break;
+                }
+                Err(e) => {
+                    if let Some(mut payload) = self.payload.take() {
+                        payload.set_error(PayloadError::EncodingCorrupted);
+                    }
+
+                    // Malformed requests should be responded with 400
+                    self.messages.push_back(DispatcherMessage::Error(
+                        Response::BadRequest().finish().drop_body(),
+                    ));
+                    self.flags.insert(Flags::DISCONNECTED);
+                    self.error = Some(e.into());
+                    break;
+                }
+            }
+        }
+
+        if self.ka_timer.is_some() && updated {
+            if let Some(expire) = self.config.keep_alive_expire() {
+                self.ka_expire = expire;
+            }
+        }
+        Ok(updated)
+    }
+
+    /// keep-alive timer
+    fn poll_keepalive(&mut self) -> Result<(), DispatchError> {
+        if self.ka_timer.is_none() {
+            // shutdown timeout
+            if self.flags.contains(Flags::SHUTDOWN) {
+                if let Some(interval) = self.config.client_disconnect_timer() {
+                    self.ka_timer = Some(Delay::new(interval));
+                } else {
+                    self.flags.insert(Flags::DISCONNECTED);
+                    return Ok(());
+                }
+            } else {
+                return Ok(());
+            }
+        }
+
+        match self.ka_timer.as_mut().unwrap().poll().map_err(|e| {
+            error!("Timer error {:?}", e);
+            DispatchError::Unknown
+        })? {
+            Async::Ready(_) => {
+                // if we get timeout during shutdown, drop connection
+                if self.flags.contains(Flags::SHUTDOWN) {
+                    return Err(DispatchError::DisconnectTimeout);
+                } else if self.ka_timer.as_mut().unwrap().deadline() >= self.ka_expire {
+                    // check for any outstanding tasks
+                    if self.state.is_empty() && self.framed.is_write_buf_empty() {
+                        if self.flags.contains(Flags::STARTED) {
+                            trace!("Keep-alive timeout, close connection");
+                            self.flags.insert(Flags::SHUTDOWN);
+
+                            // start shutdown timer
+                            if let Some(deadline) = self.config.client_disconnect_timer()
+                            {
+                                if let Some(timer) = self.ka_timer.as_mut() {
+                                    timer.reset(deadline);
+                                    let _ = timer.poll();
+                                }
+                            } else {
+                                // no shutdown timeout, drop socket
+                                self.flags.insert(Flags::DISCONNECTED);
+                                return Ok(());
+                            }
+                        } else {
+                            // timeout on first request (slow request) return 408
+                            if !self.flags.contains(Flags::STARTED) {
+                                trace!("Slow request timeout");
+                                let _ = self.send_response(
+                                    Response::RequestTimeout().finish().drop_body(),
+                                    ResponseBody::Other(Body::Empty),
+                                );
+                            } else {
+                                trace!("Keep-alive connection timeout");
+                            }
+                            self.flags.insert(Flags::STARTED | Flags::SHUTDOWN);
+                            self.state = State::None;
+                        }
+                    } else if let Some(deadline) = self.config.keep_alive_expire() {
+                        if let Some(timer) = self.ka_timer.as_mut() {
+                            timer.reset(deadline);
+                            let _ = timer.poll();
+                        }
+                    }
+                } else if let Some(timer) = self.ka_timer.as_mut() {
+                    timer.reset(self.ka_expire);
+                    let _ = timer.poll();
+                }
+            }
+            Async::NotReady => (),
+        }
+
+        Ok(())
+    }
+}
+
+impl<T, S, B> Future for Dispatcher<T, S, B>
+where
+    T: AsyncRead + AsyncWrite,
+    S: Service<Request = Request>,
+    S::Error: Debug,
+    S::Response: Into<Response<B>>,
+    B: MessageBody,
+{
+    type Item = ();
+    type Error = DispatchError;
+
+    #[inline]
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let inner = self.inner.as_mut().unwrap();
+
+        if inner.flags.contains(Flags::SHUTDOWN) {
+            inner.poll_keepalive()?;
+            if inner.flags.contains(Flags::DISCONNECTED) {
+                Ok(Async::Ready(()))
+            } else {
+                // try_ready!(inner.poll_flush());
+                match inner.framed.get_mut().shutdown()? {
+                    Async::Ready(_) => Ok(Async::Ready(())),
+                    Async::NotReady => Ok(Async::NotReady),
+                }
+            }
+        } else {
+            inner.poll_keepalive()?;
+            inner.poll_request()?;
+            loop {
+                inner.poll_response()?;
+                if let Async::Ready(false) = inner.poll_flush()? {
+                    break;
+                }
+            }
+
+            if inner.flags.contains(Flags::DISCONNECTED) {
+                return Ok(Async::Ready(()));
+            }
+
+            // keep-alive and stream errors
+            if inner.state.is_empty() && inner.framed.is_write_buf_empty() {
+                if let Some(err) = inner.error.take() {
+                    return Err(err);
+                }
+                // disconnect if keep-alive is not enabled
+                else if inner.flags.contains(Flags::STARTED)
+                    && !inner.flags.intersects(Flags::KEEPALIVE)
+                {
+                    inner.flags.insert(Flags::SHUTDOWN);
+                    self.poll()
+                }
+                // disconnect if shutdown
+                else if inner.flags.contains(Flags::SHUTDOWN) {
+                    self.poll()
+                } else {
+                    return Ok(Async::NotReady);
+                }
+            } else {
+                return Ok(Async::NotReady);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{cmp, io};
+
+    use actix_codec::{AsyncRead, AsyncWrite};
+    use actix_service::IntoService;
+    use bytes::{Buf, Bytes};
+    use futures::future::{lazy, ok};
+
+    use super::*;
+    use crate::error::Error;
+
+    struct Buffer {
+        buf: Bytes,
+        err: Option<io::Error>,
+    }
+
+    impl Buffer {
+        fn new(data: &'static str) -> Buffer {
+            Buffer {
+                buf: Bytes::from(data),
+                err: None,
+            }
+        }
+    }
+
+    impl AsyncRead for Buffer {}
+    impl io::Read for Buffer {
+        fn read(&mut self, dst: &mut [u8]) -> Result<usize, io::Error> {
+            if self.buf.is_empty() {
+                if self.err.is_some() {
+                    Err(self.err.take().unwrap())
+                } else {
+                    Err(io::Error::new(io::ErrorKind::WouldBlock, ""))
+                }
+            } else {
+                let size = cmp::min(self.buf.len(), dst.len());
+                let b = self.buf.split_to(size);
+                dst[..size].copy_from_slice(&b);
+                Ok(size)
+            }
+        }
+    }
+
+    impl io::Write for Buffer {
+        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+            Ok(buf.len())
+        }
+        fn flush(&mut self) -> io::Result<()> {
+            Ok(())
+        }
+    }
+    impl AsyncWrite for Buffer {
+        fn shutdown(&mut self) -> Poll<(), io::Error> {
+            Ok(Async::Ready(()))
+        }
+        fn write_buf<B: Buf>(&mut self, _: &mut B) -> Poll<usize, io::Error> {
+            Ok(Async::NotReady)
+        }
+    }
+
+    #[test]
+    fn test_req_parse_err() {
+        let mut sys = actix_rt::System::new("test");
+        let _ = sys.block_on(lazy(|| {
+            let buf = Buffer::new("GET /test HTTP/1\r\n\r\n");
+
+            let mut h1 = Dispatcher::new(
+                buf,
+                ServiceConfig::default(),
+                CloneableService::new(
+                    (|_| ok::<_, Error>(Response::Ok().finish())).into_service(),
+                ),
+            );
+            assert!(h1.poll().is_ok());
+            assert!(h1.poll().is_ok());
+            assert!(h1
+                .inner
+                .as_ref()
+                .unwrap()
+                .flags
+                .contains(Flags::DISCONNECTED));
+            // assert_eq!(h1.tasks.len(), 1);
+            ok::<_, ()>(())
+        }));
+    }
+}

actix-http/src/h1/encoder.rs

@@ -0,0 +1,421 @@
+#![allow(unused_imports, unused_variables, dead_code)]
+use std::fmt::Write as FmtWrite;
+use std::io::Write;
+use std::marker::PhantomData;
+use std::str::FromStr;
+use std::{cmp, fmt, io, mem};
+
+use bytes::{BufMut, Bytes, BytesMut};
+use http::header::{
+    HeaderValue, ACCEPT_ENCODING, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING,
+};
+use http::{HeaderMap, Method, StatusCode, Version};
+
+use crate::body::BodyLength;
+use crate::config::ServiceConfig;
+use crate::header::ContentEncoding;
+use crate::helpers;
+use crate::message::{ConnectionType, RequestHead, ResponseHead};
+use crate::request::Request;
+use crate::response::Response;
+
+const AVERAGE_HEADER_SIZE: usize = 30;
+
+#[derive(Debug)]
+pub(crate) struct MessageEncoder<T: MessageType> {
+    pub length: BodyLength,
+    pub te: TransferEncoding,
+    _t: PhantomData<T>,
+}
+
+impl<T: MessageType> Default for MessageEncoder<T> {
+    fn default() -> Self {
+        MessageEncoder {
+            length: BodyLength::None,
+            te: TransferEncoding::empty(),
+            _t: PhantomData,
+        }
+    }
+}
+
+pub(crate) trait MessageType: Sized {
+    fn status(&self) -> Option<StatusCode>;
+
+    fn connection_type(&self) -> Option<ConnectionType>;
+
+    fn headers(&self) -> &HeaderMap;
+
+    fn chunked(&self) -> bool;
+
+    fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()>;
+
+    fn encode_headers(
+        &mut self,
+        dst: &mut BytesMut,
+        version: Version,
+        mut length: BodyLength,
+        ctype: ConnectionType,
+        config: &ServiceConfig,
+    ) -> io::Result<()> {
+        let chunked = self.chunked();
+        let mut skip_len = length != BodyLength::Stream;
+
+        // Content length
+        if let Some(status) = self.status() {
+            match status {
+                StatusCode::NO_CONTENT
+                | StatusCode::CONTINUE
+                | StatusCode::PROCESSING => length = BodyLength::None,
+                StatusCode::SWITCHING_PROTOCOLS => {
+                    skip_len = true;
+                    length = BodyLength::Stream;
+                }
+                _ => (),
+            }
+        }
+        match length {
+            BodyLength::Stream => {
+                if chunked {
+                    dst.extend_from_slice(b"\r\ntransfer-encoding: chunked\r\n")
+                } else {
+                    skip_len = false;
+                    dst.extend_from_slice(b"\r\n");
+                }
+            }
+            BodyLength::Empty => {
+                dst.extend_from_slice(b"\r\ncontent-length: 0\r\n");
+            }
+            BodyLength::Sized(len) => helpers::write_content_length(len, dst),
+            BodyLength::Sized64(len) => {
+                dst.extend_from_slice(b"\r\ncontent-length: ");
+                write!(dst.writer(), "{}", len)?;
+                dst.extend_from_slice(b"\r\n");
+            }
+            BodyLength::None => dst.extend_from_slice(b"\r\n"),
+        }
+
+        // Connection
+        match ctype {
+            ConnectionType::Upgrade => dst.extend_from_slice(b"connection: upgrade\r\n"),
+            ConnectionType::KeepAlive if version < Version::HTTP_11 => {
+                dst.extend_from_slice(b"connection: keep-alive\r\n")
+            }
+            ConnectionType::Close if version >= Version::HTTP_11 => {
+                dst.extend_from_slice(b"connection: close\r\n")
+            }
+            _ => (),
+        }
+
+        // write headers
+        let mut pos = 0;
+        let mut has_date = false;
+        let mut remaining = dst.remaining_mut();
+        let mut buf = unsafe { &mut *(dst.bytes_mut() as *mut [u8]) };
+        for (key, value) in self.headers() {
+            match *key {
+                CONNECTION => continue,
+                TRANSFER_ENCODING | CONTENT_LENGTH if skip_len => continue,
+                DATE => {
+                    has_date = true;
+                }
+                _ => (),
+            }
+
+            let v = value.as_ref();
+            let k = key.as_str().as_bytes();
+            let len = k.len() + v.len() + 4;
+            if len > remaining {
+                unsafe {
+                    dst.advance_mut(pos);
+                }
+                pos = 0;
+                dst.reserve(len);
+                remaining = dst.remaining_mut();
+                unsafe {
+                    buf = &mut *(dst.bytes_mut() as *mut _);
+                }
+            }
+
+            buf[pos..pos + k.len()].copy_from_slice(k);
+            pos += k.len();
+            buf[pos..pos + 2].copy_from_slice(b": ");
+            pos += 2;
+            buf[pos..pos + v.len()].copy_from_slice(v);
+            pos += v.len();
+            buf[pos..pos + 2].copy_from_slice(b"\r\n");
+            pos += 2;
+            remaining -= len;
+        }
+        unsafe {
+            dst.advance_mut(pos);
+        }
+
+        // optimized date header, set_date writes \r\n
+        if !has_date {
+            config.set_date(dst);
+        } else {
+            // msg eof
+            dst.extend_from_slice(b"\r\n");
+        }
+
+        Ok(())
+    }
+}
+
+impl MessageType for Response<()> {
+    fn status(&self) -> Option<StatusCode> {
+        Some(self.head().status)
+    }
+
+    fn chunked(&self) -> bool {
+        !self.head().no_chunking
+    }
+
+    fn connection_type(&self) -> Option<ConnectionType> {
+        self.head().ctype
+    }
+
+    fn headers(&self) -> &HeaderMap {
+        &self.head().headers
+    }
+
+    fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()> {
+        let head = self.head();
+        let reason = head.reason().as_bytes();
+        dst.reserve(256 + head.headers.len() * AVERAGE_HEADER_SIZE + reason.len());
+
+        // status line
+        helpers::write_status_line(head.version, head.status.as_u16(), dst);
+        dst.extend_from_slice(reason);
+        Ok(())
+    }
+}
+
+impl MessageType for RequestHead {
+    fn status(&self) -> Option<StatusCode> {
+        None
+    }
+
+    fn connection_type(&self) -> Option<ConnectionType> {
+        self.ctype
+    }
+
+    fn chunked(&self) -> bool {
+        !self.no_chunking
+    }
+
+    fn headers(&self) -> &HeaderMap {
+        &self.headers
+    }
+
+    fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()> {
+        write!(
+            Writer(dst),
+            "{} {} {}",
+            self.method,
+            self.uri.path_and_query().map(|u| u.as_str()).unwrap_or("/"),
+            match self.version {
+                Version::HTTP_09 => "HTTP/0.9",
+                Version::HTTP_10 => "HTTP/1.0",
+                Version::HTTP_11 => "HTTP/1.1",
+                Version::HTTP_2 => "HTTP/2.0",
+            }
+        )
+        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+    }
+}
+
+impl<T: MessageType> MessageEncoder<T> {
+    /// Encode message
+    pub fn encode_chunk(&mut self, msg: &[u8], buf: &mut BytesMut) -> io::Result<bool> {
+        self.te.encode(msg, buf)
+    }
+
+    /// Encode eof
+    pub fn encode_eof(&mut self, buf: &mut BytesMut) -> io::Result<()> {
+        self.te.encode_eof(buf)
+    }
+
+    pub fn encode(
+        &mut self,
+        dst: &mut BytesMut,
+        message: &mut T,
+        head: bool,
+        stream: bool,
+        version: Version,
+        length: BodyLength,
+        ctype: ConnectionType,
+        config: &ServiceConfig,
+    ) -> io::Result<()> {
+        // transfer encoding
+        if !head {
+            self.te = match length {
+                BodyLength::Empty => TransferEncoding::empty(),
+                BodyLength::Sized(len) => TransferEncoding::length(len as u64),
+                BodyLength::Sized64(len) => TransferEncoding::length(len),
+                BodyLength::Stream => {
+                    if message.chunked() && !stream {
+                        TransferEncoding::chunked()
+                    } else {
+                        TransferEncoding::eof()
+                    }
+                }
+                BodyLength::None => TransferEncoding::empty(),
+            };
+        } else {
+            self.te = TransferEncoding::empty();
+        }
+
+        message.encode_status(dst)?;
+        message.encode_headers(dst, version, length, ctype, config)
+    }
+}
+
+/// Encoders to handle different Transfer-Encodings.
+#[derive(Debug)]
+pub(crate) struct TransferEncoding {
+    kind: TransferEncodingKind,
+}
+
+#[derive(Debug, PartialEq, Clone)]
+enum TransferEncodingKind {
+    /// An Encoder for when Transfer-Encoding includes `chunked`.
+    Chunked(bool),
+    /// An Encoder for when Content-Length is set.
+    ///
+    /// Enforces that the body is not longer than the Content-Length header.
+    Length(u64),
+    /// An Encoder for when Content-Length is not known.
+    ///
+    /// Application decides when to stop writing.
+    Eof,
+}
+
+impl TransferEncoding {
+    #[inline]
+    pub fn empty() -> TransferEncoding {
+        TransferEncoding {
+            kind: TransferEncodingKind::Length(0),
+        }
+    }
+
+    #[inline]
+    pub fn eof() -> TransferEncoding {
+        TransferEncoding {
+            kind: TransferEncodingKind::Eof,
+        }
+    }
+
+    #[inline]
+    pub fn chunked() -> TransferEncoding {
+        TransferEncoding {
+            kind: TransferEncodingKind::Chunked(false),
+        }
+    }
+
+    #[inline]
+    pub fn length(len: u64) -> TransferEncoding {
+        TransferEncoding {
+            kind: TransferEncodingKind::Length(len),
+        }
+    }
+
+    /// Encode message. Return `EOF` state of encoder
+    #[inline]
+    pub fn encode(&mut self, msg: &[u8], buf: &mut BytesMut) -> io::Result<bool> {
+        match self.kind {
+            TransferEncodingKind::Eof => {
+                let eof = msg.is_empty();
+                buf.extend_from_slice(msg);
+                Ok(eof)
+            }
+            TransferEncodingKind::Chunked(ref mut eof) => {
+                if *eof {
+                    return Ok(true);
+                }
+
+                if msg.is_empty() {
+                    *eof = true;
+                    buf.extend_from_slice(b"0\r\n\r\n");
+                } else {
+                    writeln!(Writer(buf), "{:X}\r", msg.len())
+                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+
+                    buf.reserve(msg.len() + 2);
+                    buf.extend_from_slice(msg);
+                    buf.extend_from_slice(b"\r\n");
+                }
+                Ok(*eof)
+            }
+            TransferEncodingKind::Length(ref mut remaining) => {
+                if *remaining > 0 {
+                    if msg.is_empty() {
+                        return Ok(*remaining == 0);
+                    }
+                    let len = cmp::min(*remaining, msg.len() as u64);
+
+                    buf.extend_from_slice(&msg[..len as usize]);
+
+                    *remaining -= len as u64;
+                    Ok(*remaining == 0)
+                } else {
+                    Ok(true)
+                }
+            }
+        }
+    }
+
+    /// Encode eof. Return `EOF` state of encoder
+    #[inline]
+    pub fn encode_eof(&mut self, buf: &mut BytesMut) -> io::Result<()> {
+        match self.kind {
+            TransferEncodingKind::Eof => Ok(()),
+            TransferEncodingKind::Length(rem) => {
+                if rem != 0 {
+                    Err(io::Error::new(io::ErrorKind::UnexpectedEof, ""))
+                } else {
+                    Ok(())
+                }
+            }
+            TransferEncodingKind::Chunked(ref mut eof) => {
+                if !*eof {
+                    *eof = true;
+                    buf.extend_from_slice(b"0\r\n\r\n");
+                }
+                Ok(())
+            }
+        }
+    }
+}
+
+struct Writer<'a>(pub &'a mut BytesMut);
+
+impl<'a> io::Write for Writer<'a> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0.extend_from_slice(buf);
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bytes::Bytes;
+
+    #[test]
+    fn test_chunked_te() {
+        let mut bytes = BytesMut::new();
+        let mut enc = TransferEncoding::chunked();
+        {
+            assert!(!enc.encode(b"test", &mut bytes).ok().unwrap());
+            assert!(enc.encode(b"", &mut bytes).ok().unwrap());
+        }
+        assert_eq!(
+            bytes.take().freeze(),
+            Bytes::from_static(b"4\r\ntest\r\n0\r\n\r\n")
+        );
+    }
+}

actix-http/src/h1/mod.rs

@@ -0,0 +1,69 @@
+//! HTTP/1 implementation
+use bytes::Bytes;
+
+mod client;
+mod codec;
+mod decoder;
+mod dispatcher;
+mod encoder;
+mod payload;
+mod service;
+
+pub use self::client::{ClientCodec, ClientPayloadCodec};
+pub use self::codec::Codec;
+pub use self::dispatcher::Dispatcher;
+pub use self::payload::{Payload, PayloadBuffer};
+pub use self::service::{H1Service, H1ServiceHandler, OneRequest};
+
+#[derive(Debug)]
+/// Codec message
+pub enum Message<T> {
+    /// Http message
+    Item(T),
+    /// Payload chunk
+    Chunk(Option<Bytes>),
+}
+
+impl<T> From<T> for Message<T> {
+    fn from(item: T) -> Self {
+        Message::Item(item)
+    }
+}
+
+/// Incoming request type
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MessageType {
+    None,
+    Payload,
+    Stream,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::request::Request;
+
+    impl Message<Request> {
+        pub fn message(self) -> Request {
+            match self {
+                Message::Item(req) => req,
+                _ => panic!("error"),
+            }
+        }
+
+        pub fn chunk(self) -> Bytes {
+            match self {
+                Message::Chunk(Some(data)) => data,
+                _ => panic!("error"),
+            }
+        }
+
+        pub fn eof(self) -> bool {
+            match self {
+                Message::Chunk(None) => true,
+                Message::Chunk(Some(_)) => false,
+                _ => panic!("error"),
+            }
+        }
+    }
+}

actix-http/src/h1/payload.rs

@@ -0,0 +1,716 @@
+//! Payload stream
+use bytes::{Bytes, BytesMut};
+#[cfg(not(test))]
+use futures::task::current as current_task;
+use futures::task::Task;
+use futures::{Async, Poll, Stream};
+use std::cell::RefCell;
+use std::cmp;
+use std::collections::VecDeque;
+use std::rc::{Rc, Weak};
+
+use crate::error::PayloadError;
+
+/// max buffer size 32k
+pub(crate) const MAX_BUFFER_SIZE: usize = 32_768;
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum PayloadStatus {
+    Read,
+    Pause,
+    Dropped,
+}
+
+/// Buffered stream of bytes chunks
+///
+/// Payload stores chunks in a vector. First chunk can be received with
+/// `.readany()` method. Payload stream is not thread safe. Payload does not
+/// notify current task when new data is available.
+///
+/// Payload stream can be used as `Response` body stream.
+#[derive(Debug)]
+pub struct Payload {
+    inner: Rc<RefCell<Inner>>,
+}
+
+impl Payload {
+    /// Create payload stream.
+    ///
+    /// This method construct two objects responsible for bytes stream
+    /// generation.
+    ///
+    /// * `PayloadSender` - *Sender* side of the stream
+    ///
+    /// * `Payload` - *Receiver* side of the stream
+    pub fn create(eof: bool) -> (PayloadSender, Payload) {
+        let shared = Rc::new(RefCell::new(Inner::new(eof)));
+
+        (
+            PayloadSender {
+                inner: Rc::downgrade(&shared),
+            },
+            Payload { inner: shared },
+        )
+    }
+
+    /// Create empty payload
+    #[doc(hidden)]
+    pub fn empty() -> Payload {
+        Payload {
+            inner: Rc::new(RefCell::new(Inner::new(true))),
+        }
+    }
+
+    /// Length of the data in this payload
+    #[cfg(test)]
+    pub fn len(&self) -> usize {
+        self.inner.borrow().len()
+    }
+
+    /// Is payload empty
+    #[cfg(test)]
+    pub fn is_empty(&self) -> bool {
+        self.inner.borrow().len() == 0
+    }
+
+    /// Put unused data back to payload
+    #[inline]
+    pub fn unread_data(&mut self, data: Bytes) {
+        self.inner.borrow_mut().unread_data(data);
+    }
+
+    #[cfg(test)]
+    pub(crate) fn readall(&self) -> Option<Bytes> {
+        self.inner.borrow_mut().readall()
+    }
+
+    #[inline]
+    /// Set read buffer capacity
+    ///
+    /// Default buffer capacity is 32Kb.
+    pub fn set_read_buffer_capacity(&mut self, cap: usize) {
+        self.inner.borrow_mut().capacity = cap;
+    }
+}
+
+impl Stream for Payload {
+    type Item = Bytes;
+    type Error = PayloadError;
+
+    #[inline]
+    fn poll(&mut self) -> Poll<Option<Bytes>, PayloadError> {
+        self.inner.borrow_mut().readany()
+    }
+}
+
+impl Clone for Payload {
+    fn clone(&self) -> Payload {
+        Payload {
+            inner: Rc::clone(&self.inner),
+        }
+    }
+}
+
+/// Payload writer interface.
+pub(crate) trait PayloadWriter {
+    /// Set stream error.
+    fn set_error(&mut self, err: PayloadError);
+
+    /// Write eof into a stream which closes reading side of a stream.
+    fn feed_eof(&mut self);
+
+    /// Feed bytes into a payload stream
+    fn feed_data(&mut self, data: Bytes);
+
+    /// Need read data
+    fn need_read(&self) -> PayloadStatus;
+}
+
+/// Sender part of the payload stream
+pub struct PayloadSender {
+    inner: Weak<RefCell<Inner>>,
+}
+
+impl PayloadWriter for PayloadSender {
+    #[inline]
+    fn set_error(&mut self, err: PayloadError) {
+        if let Some(shared) = self.inner.upgrade() {
+            shared.borrow_mut().set_error(err)
+        }
+    }
+
+    #[inline]
+    fn feed_eof(&mut self) {
+        if let Some(shared) = self.inner.upgrade() {
+            shared.borrow_mut().feed_eof()
+        }
+    }
+
+    #[inline]
+    fn feed_data(&mut self, data: Bytes) {
+        if let Some(shared) = self.inner.upgrade() {
+            shared.borrow_mut().feed_data(data)
+        }
+    }
+
+    #[inline]
+    fn need_read(&self) -> PayloadStatus {
+        // we check need_read only if Payload (other side) is alive,
+        // otherwise always return true (consume payload)
+        if let Some(shared) = self.inner.upgrade() {
+            if shared.borrow().need_read {
+                PayloadStatus::Read
+            } else {
+                #[cfg(not(test))]
+                {
+                    if shared.borrow_mut().io_task.is_none() {
+                        shared.borrow_mut().io_task = Some(current_task());
+                    }
+                }
+                PayloadStatus::Pause
+            }
+        } else {
+            PayloadStatus::Dropped
+        }
+    }
+}
+
+#[derive(Debug)]
+struct Inner {
+    len: usize,
+    eof: bool,
+    err: Option<PayloadError>,
+    need_read: bool,
+    items: VecDeque<Bytes>,
+    capacity: usize,
+    task: Option<Task>,
+    io_task: Option<Task>,
+}
+
+impl Inner {
+    fn new(eof: bool) -> Self {
+        Inner {
+            eof,
+            len: 0,
+            err: None,
+            items: VecDeque::new(),
+            need_read: true,
+            capacity: MAX_BUFFER_SIZE,
+            task: None,
+            io_task: None,
+        }
+    }
+
+    #[inline]
+    fn set_error(&mut self, err: PayloadError) {
+        self.err = Some(err);
+    }
+
+    #[inline]
+    fn feed_eof(&mut self) {
+        self.eof = true;
+    }
+
+    #[inline]
+    fn feed_data(&mut self, data: Bytes) {
+        self.len += data.len();
+        self.items.push_back(data);
+        self.need_read = self.len < self.capacity;
+        if let Some(task) = self.task.take() {
+            task.notify()
+        }
+    }
+
+    #[cfg(test)]
+    fn len(&self) -> usize {
+        self.len
+    }
+
+    #[cfg(test)]
+    pub(crate) fn readall(&mut self) -> Option<Bytes> {
+        let len = self.items.iter().map(|b| b.len()).sum();
+        if len > 0 {
+            let mut buf = BytesMut::with_capacity(len);
+            for item in &self.items {
+                buf.extend_from_slice(item);
+            }
+            self.items = VecDeque::new();
+            self.len = 0;
+            Some(buf.take().freeze())
+        } else {
+            self.need_read = true;
+            None
+        }
+    }
+
+    fn readany(&mut self) -> Poll<Option<Bytes>, PayloadError> {
+        if let Some(data) = self.items.pop_front() {
+            self.len -= data.len();
+            self.need_read = self.len < self.capacity;
+            #[cfg(not(test))]
+            {
+                if self.need_read && self.task.is_none() {
+                    self.task = Some(current_task());
+                }
+                if let Some(task) = self.io_task.take() {
+                    task.notify()
+                }
+            }
+            Ok(Async::Ready(Some(data)))
+        } else if let Some(err) = self.err.take() {
+            Err(err)
+        } else if self.eof {
+            Ok(Async::Ready(None))
+        } else {
+            self.need_read = true;
+            #[cfg(not(test))]
+            {
+                if self.task.is_none() {
+                    self.task = Some(current_task());
+                }
+                if let Some(task) = self.io_task.take() {
+                    task.notify()
+                }
+            }
+            Ok(Async::NotReady)
+        }
+    }
+
+    fn unread_data(&mut self, data: Bytes) {
+        self.len += data.len();
+        self.items.push_front(data);
+    }
+}
+
+/// Payload buffer
+pub struct PayloadBuffer<S> {
+    len: usize,
+    items: VecDeque<Bytes>,
+    stream: S,
+}
+
+impl<S> PayloadBuffer<S>
+where
+    S: Stream<Item = Bytes, Error = PayloadError>,
+{
+    /// Create new `PayloadBuffer` instance
+    pub fn new(stream: S) -> Self {
+        PayloadBuffer {
+            len: 0,
+            items: VecDeque::new(),
+            stream,
+        }
+    }
+
+    /// Get mutable reference to an inner stream.
+    pub fn get_mut(&mut self) -> &mut S {
+        &mut self.stream
+    }
+
+    #[inline]
+    fn poll_stream(&mut self) -> Poll<bool, PayloadError> {
+        self.stream.poll().map(|res| match res {
+            Async::Ready(Some(data)) => {
+                self.len += data.len();
+                self.items.push_back(data);
+                Async::Ready(true)
+            }
+            Async::Ready(None) => Async::Ready(false),
+            Async::NotReady => Async::NotReady,
+        })
+    }
+
+    /// Read first available chunk of bytes
+    #[inline]
+    pub fn readany(&mut self) -> Poll<Option<Bytes>, PayloadError> {
+        if let Some(data) = self.items.pop_front() {
+            self.len -= data.len();
+            Ok(Async::Ready(Some(data)))
+        } else {
+            match self.poll_stream()? {
+                Async::Ready(true) => self.readany(),
+                Async::Ready(false) => Ok(Async::Ready(None)),
+                Async::NotReady => Ok(Async::NotReady),
+            }
+        }
+    }
+
+    /// Check if buffer contains enough bytes
+    #[inline]
+    pub fn can_read(&mut self, size: usize) -> Poll<Option<bool>, PayloadError> {
+        if size <= self.len {
+            Ok(Async::Ready(Some(true)))
+        } else {
+            match self.poll_stream()? {
+                Async::Ready(true) => self.can_read(size),
+                Async::Ready(false) => Ok(Async::Ready(None)),
+                Async::NotReady => Ok(Async::NotReady),
+            }
+        }
+    }
+
+    /// Return reference to the first chunk of data
+    #[inline]
+    pub fn get_chunk(&mut self) -> Poll<Option<&[u8]>, PayloadError> {
+        if self.items.is_empty() {
+            match self.poll_stream()? {
+                Async::Ready(true) => (),
+                Async::Ready(false) => return Ok(Async::Ready(None)),
+                Async::NotReady => return Ok(Async::NotReady),
+            }
+        }
+        match self.items.front().map(|c| c.as_ref()) {
+            Some(chunk) => Ok(Async::Ready(Some(chunk))),
+            None => Ok(Async::NotReady),
+        }
+    }
+
+    /// Read exact number of bytes
+    #[inline]
+    pub fn read_exact(&mut self, size: usize) -> Poll<Option<Bytes>, PayloadError> {
+        if size <= self.len {
+            self.len -= size;
+            let mut chunk = self.items.pop_front().unwrap();
+            if size < chunk.len() {
+                let buf = chunk.split_to(size);
+                self.items.push_front(chunk);
+                Ok(Async::Ready(Some(buf)))
+            } else if size == chunk.len() {
+                Ok(Async::Ready(Some(chunk)))
+            } else {
+                let mut buf = BytesMut::with_capacity(size);
+                buf.extend_from_slice(&chunk);
+
+                while buf.len() < size {
+                    let mut chunk = self.items.pop_front().unwrap();
+                    let rem = cmp::min(size - buf.len(), chunk.len());
+                    buf.extend_from_slice(&chunk.split_to(rem));
+                    if !chunk.is_empty() {
+                        self.items.push_front(chunk);
+                    }
+                }
+                Ok(Async::Ready(Some(buf.freeze())))
+            }
+        } else {
+            match self.poll_stream()? {
+                Async::Ready(true) => self.read_exact(size),
+                Async::Ready(false) => Ok(Async::Ready(None)),
+                Async::NotReady => Ok(Async::NotReady),
+            }
+        }
+    }
+
+    /// Remove specified amount if bytes from buffer
+    #[inline]
+    pub fn drop_bytes(&mut self, size: usize) {
+        if size <= self.len {
+            self.len -= size;
+
+            let mut len = 0;
+            while len < size {
+                let mut chunk = self.items.pop_front().unwrap();
+                let rem = cmp::min(size - len, chunk.len());
+                len += rem;
+                if rem < chunk.len() {
+                    chunk.split_to(rem);
+                    self.items.push_front(chunk);
+                }
+            }
+        }
+    }
+
+    /// Copy buffered data
+    pub fn copy(&mut self, size: usize) -> Poll<Option<BytesMut>, PayloadError> {
+        if size <= self.len {
+            let mut buf = BytesMut::with_capacity(size);
+            for chunk in &self.items {
+                if buf.len() < size {
+                    let rem = cmp::min(size - buf.len(), chunk.len());
+                    buf.extend_from_slice(&chunk[..rem]);
+                }
+                if buf.len() == size {
+                    return Ok(Async::Ready(Some(buf)));
+                }
+            }
+        }
+
+        match self.poll_stream()? {
+            Async::Ready(true) => self.copy(size),
+            Async::Ready(false) => Ok(Async::Ready(None)),
+            Async::NotReady => Ok(Async::NotReady),
+        }
+    }
+
+    /// Read until specified ending
+    pub fn read_until(&mut self, line: &[u8]) -> Poll<Option<Bytes>, PayloadError> {
+        let mut idx = 0;
+        let mut num = 0;
+        let mut offset = 0;
+        let mut found = false;
+        let mut length = 0;
+
+        for no in 0..self.items.len() {
+            {
+                let chunk = &self.items[no];
+                for (pos, ch) in chunk.iter().enumerate() {
+                    if *ch == line[idx] {
+                        idx += 1;
+                        if idx == line.len() {
+                            num = no;
+                            offset = pos + 1;
+                            length += pos + 1;
+                            found = true;
+                            break;
+                        }
+                    } else {
+                        idx = 0
+                    }
+                }
+                if !found {
+                    length += chunk.len()
+                }
+            }
+
+            if found {
+                let mut buf = BytesMut::with_capacity(length);
+                if num > 0 {
+                    for _ in 0..num {
+                        buf.extend_from_slice(&self.items.pop_front().unwrap());
+                    }
+                }
+                if offset > 0 {
+                    let mut chunk = self.items.pop_front().unwrap();
+                    buf.extend_from_slice(&chunk.split_to(offset));
+                    if !chunk.is_empty() {
+                        self.items.push_front(chunk)
+                    }
+                }
+                self.len -= length;
+                return Ok(Async::Ready(Some(buf.freeze())));
+            }
+        }
+
+        match self.poll_stream()? {
+            Async::Ready(true) => self.read_until(line),
+            Async::Ready(false) => Ok(Async::Ready(None)),
+            Async::NotReady => Ok(Async::NotReady),
+        }
+    }
+
+    /// Read bytes until new line delimiter
+    pub fn readline(&mut self) -> Poll<Option<Bytes>, PayloadError> {
+        self.read_until(b"\n")
+    }
+
+    /// Put unprocessed data back to the buffer
+    pub fn unprocessed(&mut self, data: Bytes) {
+        self.len += data.len();
+        self.items.push_front(data);
+    }
+
+    /// Get remaining data from the buffer
+    pub fn remaining(&mut self) -> Bytes {
+        self.items
+            .iter_mut()
+            .fold(BytesMut::new(), |mut b, c| {
+                b.extend_from_slice(c);
+                b
+            })
+            .freeze()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use actix_rt::Runtime;
+    use futures::future::{lazy, result};
+
+    #[test]
+    fn test_error() {
+        let err = PayloadError::Incomplete(None);
+        assert_eq!(
+            format!("{}", err),
+            "A payload reached EOF, but is not complete."
+        );
+    }
+
+    #[test]
+    fn test_basic() {
+        Runtime::new()
+            .unwrap()
+            .block_on(lazy(|| {
+                let (_, payload) = Payload::create(false);
+                let mut payload = PayloadBuffer::new(payload);
+
+                assert_eq!(payload.len, 0);
+                assert_eq!(Async::NotReady, payload.readany().ok().unwrap());
+
+                let res: Result<(), ()> = Ok(());
+                result(res)
+            }))
+            .unwrap();
+    }
+
+    #[test]
+    fn test_eof() {
+        Runtime::new()
+            .unwrap()
+            .block_on(lazy(|| {
+                let (mut sender, payload) = Payload::create(false);
+                let mut payload = PayloadBuffer::new(payload);
+
+                assert_eq!(Async::NotReady, payload.readany().ok().unwrap());
+                sender.feed_data(Bytes::from("data"));
+                sender.feed_eof();
+
+                assert_eq!(
+                    Async::Ready(Some(Bytes::from("data"))),
+                    payload.readany().ok().unwrap()
+                );
+                assert_eq!(payload.len, 0);
+                assert_eq!(Async::Ready(None), payload.readany().ok().unwrap());
+
+                let res: Result<(), ()> = Ok(());
+                result(res)
+            }))
+            .unwrap();
+    }
+
+    #[test]
+    fn test_err() {
+        Runtime::new()
+            .unwrap()
+            .block_on(lazy(|| {
+                let (mut sender, payload) = Payload::create(false);
+                let mut payload = PayloadBuffer::new(payload);
+
+                assert_eq!(Async::NotReady, payload.readany().ok().unwrap());
+
+                sender.set_error(PayloadError::Incomplete(None));
+                payload.readany().err().unwrap();
+                let res: Result<(), ()> = Ok(());
+                result(res)
+            }))
+            .unwrap();
+    }
+
+    #[test]
+    fn test_readany() {
+        Runtime::new()
+            .unwrap()
+            .block_on(lazy(|| {
+                let (mut sender, payload) = Payload::create(false);
+                let mut payload = PayloadBuffer::new(payload);
+
+                sender.feed_data(Bytes::from("line1"));
+                sender.feed_data(Bytes::from("line2"));
+
+                assert_eq!(
+                    Async::Ready(Some(Bytes::from("line1"))),
+                    payload.readany().ok().unwrap()
+                );
+                assert_eq!(payload.len, 0);
+
+                assert_eq!(
+                    Async::Ready(Some(Bytes::from("line2"))),
+                    payload.readany().ok().unwrap()
+                );
+                assert_eq!(payload.len, 0);
+
+                let res: Result<(), ()> = Ok(());
+                result(res)
+            }))
+            .unwrap();
+    }
+
+    #[test]
+    fn test_readexactly() {
+        Runtime::new()
+            .unwrap()
+            .block_on(lazy(|| {
+                let (mut sender, payload) = Payload::create(false);
+                let mut payload = PayloadBuffer::new(payload);
+
+                assert_eq!(Async::NotReady, payload.read_exact(2).ok().unwrap());
+
+                sender.feed_data(Bytes::from("line1"));
+                sender.feed_data(Bytes::from("line2"));
+
+                assert_eq!(
+                    Async::Ready(Some(Bytes::from_static(b"li"))),
+                    payload.read_exact(2).ok().unwrap()
+                );
+                assert_eq!(payload.len, 3);
+
+                assert_eq!(
+                    Async::Ready(Some(Bytes::from_static(b"ne1l"))),
+                    payload.read_exact(4).ok().unwrap()
+                );
+                assert_eq!(payload.len, 4);
+
+                sender.set_error(PayloadError::Incomplete(None));
+                payload.read_exact(10).err().unwrap();
+
+                let res: Result<(), ()> = Ok(());
+                result(res)
+            }))
+            .unwrap();
+    }
+
+    #[test]
+    fn test_readuntil() {
+        Runtime::new()
+            .unwrap()
+            .block_on(lazy(|| {
+                let (mut sender, payload) = Payload::create(false);
+                let mut payload = PayloadBuffer::new(payload);
+
+                assert_eq!(Async::NotReady, payload.read_until(b"ne").ok().unwrap());
+
+                sender.feed_data(Bytes::from("line1"));
+                sender.feed_data(Bytes::from("line2"));
+
+                assert_eq!(
+                    Async::Ready(Some(Bytes::from("line"))),
+                    payload.read_until(b"ne").ok().unwrap()
+                );
+                assert_eq!(payload.len, 1);
+
+                assert_eq!(
+                    Async::Ready(Some(Bytes::from("1line2"))),
+                    payload.read_until(b"2").ok().unwrap()
+                );
+                assert_eq!(payload.len, 0);
+
+                sender.set_error(PayloadError::Incomplete(None));
+                payload.read_until(b"b").err().unwrap();
+
+                let res: Result<(), ()> = Ok(());
+                result(res)
+            }))
+            .unwrap();
+    }
+
+    #[test]
+    fn test_unread_data() {
+        Runtime::new()
+            .unwrap()
+            .block_on(lazy(|| {
+                let (_, mut payload) = Payload::create(false);
+
+                payload.unread_data(Bytes::from("data"));
+                assert!(!payload.is_empty());
+                assert_eq!(payload.len(), 4);
+
+                assert_eq!(
+                    Async::Ready(Some(Bytes::from("data"))),
+                    payload.poll().ok().unwrap()
+                );
+
+                let res: Result<(), ()> = Ok(());
+                result(res)
+            }))
+            .unwrap();
+    }
+}

actix-http/src/h1/service.rs

@@ -0,0 +1,257 @@
+use std::fmt::Debug;
+use std::marker::PhantomData;
+
+use actix_codec::{AsyncRead, AsyncWrite, Framed};
+use actix_server_config::{Io, ServerConfig as SrvConfig};
+use actix_service::{IntoNewService, NewService, Service};
+use actix_utils::cloneable::CloneableService;
+use futures::future::{ok, FutureResult};
+use futures::{try_ready, Async, Future, IntoFuture, Poll, Stream};
+
+use crate::body::MessageBody;
+use crate::config::{KeepAlive, ServiceConfig};
+use crate::error::{DispatchError, ParseError};
+use crate::request::Request;
+use crate::response::Response;
+
+use super::codec::Codec;
+use super::dispatcher::Dispatcher;
+use super::Message;
+
+/// `NewService` implementation for HTTP1 transport
+pub struct H1Service<T, P, S, B> {
+    srv: S,
+    cfg: ServiceConfig,
+    _t: PhantomData<(T, P, B)>,
+}
+
+impl<T, P, S, B> H1Service<T, P, S, B>
+where
+    S: NewService<SrvConfig, Request = Request>,
+    S::Error: Debug,
+    S::Response: Into<Response<B>>,
+    S::Service: 'static,
+    B: MessageBody,
+{
+    /// Create new `HttpService` instance with default config.
+    pub fn new<F: IntoNewService<S, SrvConfig>>(service: F) -> Self {
+        let cfg = ServiceConfig::new(KeepAlive::Timeout(5), 5000, 0);
+
+        H1Service {
+            cfg,
+            srv: service.into_new_service(),
+            _t: PhantomData,
+        }
+    }
+
+    /// Create new `HttpService` instance with config.
+    pub fn with_config<F: IntoNewService<S, SrvConfig>>(
+        cfg: ServiceConfig,
+        service: F,
+    ) -> Self {
+        H1Service {
+            cfg,
+            srv: service.into_new_service(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, P, S, B> NewService<SrvConfig> for H1Service<T, P, S, B>
+where
+    T: AsyncRead + AsyncWrite,
+    S: NewService<SrvConfig, Request = Request>,
+    S::Error: Debug,
+    S::Response: Into<Response<B>>,
+    S::Service: 'static,
+    B: MessageBody,
+{
+    type Request = Io<T, P>;
+    type Response = ();
+    type Error = DispatchError;
+    type InitError = S::InitError;
+    type Service = H1ServiceHandler<T, P, S::Service, B>;
+    type Future = H1ServiceResponse<T, P, S, B>;
+
+    fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
+        H1ServiceResponse {
+            fut: self.srv.new_service(cfg).into_future(),
+            cfg: Some(self.cfg.clone()),
+            _t: PhantomData,
+        }
+    }
+}
+
+#[doc(hidden)]
+pub struct H1ServiceResponse<T, P, S: NewService<SrvConfig, Request = Request>, B> {
+    fut: <S::Future as IntoFuture>::Future,
+    cfg: Option<ServiceConfig>,
+    _t: PhantomData<(T, P, B)>,
+}
+
+impl<T, P, S, B> Future for H1ServiceResponse<T, P, S, B>
+where
+    T: AsyncRead + AsyncWrite,
+    S: NewService<SrvConfig, Request = Request>,
+    S::Service: 'static,
+    S::Error: Debug,
+    S::Response: Into<Response<B>>,
+    B: MessageBody,
+{
+    type Item = H1ServiceHandler<T, P, S::Service, B>;
+    type Error = S::InitError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let service = try_ready!(self.fut.poll());
+        Ok(Async::Ready(H1ServiceHandler::new(
+            self.cfg.take().unwrap(),
+            service,
+        )))
+    }
+}
+
+/// `Service` implementation for HTTP1 transport
+pub struct H1ServiceHandler<T, P, S: 'static, B> {
+    srv: CloneableService<S>,
+    cfg: ServiceConfig,
+    _t: PhantomData<(T, P, B)>,
+}
+
+impl<T, P, S, B> H1ServiceHandler<T, P, S, B>
+where
+    S: Service<Request = Request>,
+    S::Error: Debug,
+    S::Response: Into<Response<B>>,
+    B: MessageBody,
+{
+    fn new(cfg: ServiceConfig, srv: S) -> H1ServiceHandler<T, P, S, B> {
+        H1ServiceHandler {
+            srv: CloneableService::new(srv),
+            cfg,
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, P, S, B> Service for H1ServiceHandler<T, P, S, B>
+where
+    T: AsyncRead + AsyncWrite,
+    S: Service<Request = Request>,
+    S::Error: Debug,
+    S::Response: Into<Response<B>>,
+    B: MessageBody,
+{
+    type Request = Io<T, P>;
+    type Response = ();
+    type Error = DispatchError;
+    type Future = Dispatcher<T, S, B>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.srv.poll_ready().map_err(|e| {
+            log::error!("Http service readiness error: {:?}", e);
+            DispatchError::Service
+        })
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        Dispatcher::new(req.into_parts().0, self.cfg.clone(), self.srv.clone())
+    }
+}
+
+/// `NewService` implementation for `OneRequestService` service
+#[derive(Default)]
+pub struct OneRequest<T, P> {
+    config: ServiceConfig,
+    _t: PhantomData<(T, P)>,
+}
+
+impl<T, P> OneRequest<T, P>
+where
+    T: AsyncRead + AsyncWrite,
+{
+    /// Create new `H1SimpleService` instance.
+    pub fn new() -> Self {
+        OneRequest {
+            config: ServiceConfig::default(),
+            _t: PhantomData,
+        }
+    }
+}
+
+impl<T, P> NewService<SrvConfig> for OneRequest<T, P>
+where
+    T: AsyncRead + AsyncWrite,
+{
+    type Request = Io<T, P>;
+    type Response = (Request, Framed<T, Codec>);
+    type Error = ParseError;
+    type InitError = ();
+    type Service = OneRequestService<T, P>;
+    type Future = FutureResult<Self::Service, Self::InitError>;
+
+    fn new_service(&self, _: &SrvConfig) -> Self::Future {
+        ok(OneRequestService {
+            config: self.config.clone(),
+            _t: PhantomData,
+        })
+    }
+}
+
+/// `Service` implementation for HTTP1 transport. Reads one request and returns
+/// request and framed object.
+pub struct OneRequestService<T, P> {
+    config: ServiceConfig,
+    _t: PhantomData<(T, P)>,
+}
+
+impl<T, P> Service for OneRequestService<T, P>
+where
+    T: AsyncRead + AsyncWrite,
+{
+    type Request = Io<T, P>;
+    type Response = (Request, Framed<T, Codec>);
+    type Error = ParseError;
+    type Future = OneRequestServiceResponse<T>;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        OneRequestServiceResponse {
+            framed: Some(Framed::new(
+                req.into_parts().0,
+                Codec::new(self.config.clone()),
+            )),
+        }
+    }
+}
+
+#[doc(hidden)]
+pub struct OneRequestServiceResponse<T>
+where
+    T: AsyncRead + AsyncWrite,
+{
+    framed: Option<Framed<T, Codec>>,
+}
+
+impl<T> Future for OneRequestServiceResponse<T>
+where
+    T: AsyncRead + AsyncWrite,
+{
+    type Item = (Request, Framed<T, Codec>);
+    type Error = ParseError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        match self.framed.as_mut().unwrap().poll()? {
+            Async::Ready(Some(req)) => match req {
+                Message::Item(req) => {
+                    Ok(Async::Ready((req, self.framed.take().unwrap())))
+                }
+                Message::Chunk(_) => unreachable!("Something is wrong"),
+            },
+            Async::Ready(None) => Err(ParseError::Incomplete),
+            Async::NotReady => Ok(Async::NotReady),
+        }
+    }
+}