improve code readability

actix-http/src/h2/dispatcher.rs

@@ -1,14 +1,15 @@
-use std::convert::TryFrom;
 use std::future::Future;
 use std::marker::PhantomData;
 use std::net;
 use std::pin::Pin;
 use std::task::{Context, Poll};
+use std::{cmp, convert::TryFrom};
 
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_rt::time::{Instant, Sleep};
 use actix_service::Service;
 use bytes::{Bytes, BytesMut};
+use futures_core::ready;
 use h2::server::{Connection, SendResponse};
 use h2::SendStream;
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
@@ -27,7 +28,7 @@ use crate::Extensions;
 
 const CHUNK_SIZE: usize = 16_384;
 
-/// Dispatcher for HTTP/2 protocol
+/// Dispatcher for HTTP/2 protocol.
 #[pin_project::pin_project]
 pub struct Dispatcher<T, S, B>
 where
@@ -42,7 +43,7 @@ where
     peer_addr: Option<net::SocketAddr>,
     ka_expire: Instant,
     ka_timer: Option<Sleep>,
-    _t: PhantomData<B>,
+    _phantom: PhantomData<B>,
 }
 
 impl<T, S, B> Dispatcher<T, S, B>
@@ -50,7 +51,6 @@ where
     T: AsyncRead + AsyncWrite + Unpin,
     S: Service<Request>,
     S::Error: Into<Error>,
-    // S::Future: 'static,
     S::Response: Into<Response<B>>,
     B: MessageBody,
 {
@@ -86,7 +86,7 @@ where
             on_connect_data,
             ka_expire,
             ka_timer,
-            _t: PhantomData,
+            _phantom: PhantomData,
         }
     }
 }
@@ -107,10 +107,12 @@ where
         let this = self.get_mut();
 
         loop {
-            match Pin::new(&mut this.connection).poll_accept(cx) {
-                Poll::Ready(None) => return Poll::Ready(Ok(())),
-                Poll::Ready(Some(Err(err))) => return Poll::Ready(Err(err.into())),
-                Poll::Ready(Some(Ok((req, res)))) => {
+            match ready!(Pin::new(&mut this.connection).poll_accept(cx)) {
+                None => return Poll::Ready(Ok(())),
+
+                Some(Err(err)) => return Poll::Ready(Err(err.into())),
+
+                Some(Ok((req, res))) => {
                     // update keep-alive expire
                     if this.ka_timer.is_some() {
                         if let Some(expire) = this.config.keep_alive_expire() {
@@ -119,11 +121,9 @@ where
                     }
 
                     let (parts, body) = req.into_parts();
-                    let mut req = Request::with_payload(Payload::<
-                        crate::payload::PayloadStream,
-                    >::H2(
-                        crate::h2::Payload::new(body)
-                    ));
+                    let pl = crate::h2::Payload::new(body);
+                    let pl = Payload::<crate::payload::PayloadStream>::H2(pl);
+                    let mut req = Request::with_payload(pl);
 
                     let head = &mut req.head_mut();
                     head.uri = parts.uri;
@@ -135,22 +135,18 @@ where
                     // merge on_connect_ext data into request extensions
                     req.extensions_mut().drain_from(&mut this.on_connect_data);
 
-                    actix_rt::spawn(ServiceResponse::<
-                        S::Future,
-                        S::Response,
-                        S::Error,
-                        B,
-                    > {
+                    let svc = ServiceResponse::<S::Future, S::Response, S::Error, B> {
                         state: ServiceResponseState::ServiceCall(
                             this.service.call(req),
                             Some(res),
                         ),
                         config: this.config.clone(),
                         buffer: None,
-                        _t: PhantomData,
-                    });
+                        _phantom: PhantomData,
+                    };
+
+                    actix_rt::spawn(svc);
                 }
-                Poll::Pending => return Poll::Pending,
             }
         }
     }
@@ -162,7 +158,7 @@ struct ServiceResponse<F, I, E, B> {
     state: ServiceResponseState<F, B>,
     config: ServiceConfig,
     buffer: Option<Bytes>,
-    _t: PhantomData<(I, E)>,
+    _phantom: PhantomData<(I, E)>,
 }
 
 #[pin_project::pin_project(project = ServiceResponseStateProj)]
@@ -199,8 +195,9 @@ where
                 skip_len = true;
                 *size = BodySize::Stream;
             }
-            _ => (),
+            _ => {}
         }
+
         let _ = match size {
             BodySize::None | BodySize::Stream => None,
             BodySize::Empty => res
@@ -215,11 +212,13 @@ where
         // copy headers
         for (key, value) in head.headers.iter() {
             match *key {
-                CONNECTION | TRANSFER_ENCODING => continue, // http2 specific
+                // omit HTTP/1 only headers
+                CONNECTION | TRANSFER_ENCODING => continue,
                 CONTENT_LENGTH if skip_len => continue,
                 DATE => has_date = true,
-                _ => (),
+                _ => {}
             }
+
             res.headers_mut().append(key, value.clone());
         }
 
@@ -251,109 +250,117 @@ where
         let mut this = self.as_mut().project();
 
         match this.state.project() {
-            ServiceResponseStateProj::ServiceCall(call, send) => match call.poll(cx) {
-                Poll::Ready(Ok(res)) => {
-                    let (res, body) = res.into().replace_body(());
+            ServiceResponseStateProj::ServiceCall(call, send) => {
+                match ready!(call.poll(cx)) {
+                    Ok(res) => {
+                        let (res, body) = res.into().replace_body(());
 
-                    let mut send = send.take().unwrap();
-                    let mut size = body.size();
-                    let h2_res = self.as_mut().prepare_response(res.head(), &mut size);
-                    this = self.as_mut().project();
+                        let mut send = send.take().unwrap();
+                        let mut size = body.size();
+                        let h2_res =
+                            self.as_mut().prepare_response(res.head(), &mut size);
+                        this = self.as_mut().project();
 
-                    let stream = match send.send_response(h2_res, size.is_eof()) {
-                        Err(e) => {
-                            trace!("Error sending h2 response: {:?}", e);
-                            return Poll::Ready(());
+                        let stream = match send.send_response(h2_res, size.is_eof()) {
+                            Err(e) => {
+                                trace!("Error sending HTTP/2 response: {:?}", e);
+                                return Poll::Ready(());
+                            }
+                            Ok(stream) => stream,
+                        };
+
+                        if size.is_eof() {
+                            Poll::Ready(())
+                        } else {
+                            this.state
+                                .set(ServiceResponseState::SendPayload(stream, body));
+                            self.poll(cx)
                         }
-                        Ok(stream) => stream,
-                    };
+                    }
 
-                    if size.is_eof() {
-                        Poll::Ready(())
-                    } else {
-                        this.state
-                            .set(ServiceResponseState::SendPayload(stream, body));
-                        self.poll(cx)
+                    Err(e) => {
+                        let res: Response = e.into().into();
+                        let (res, body) = res.replace_body(());
+
+                        let mut send = send.take().unwrap();
+                        let mut size = body.size();
+                        let h2_res =
+                            self.as_mut().prepare_response(res.head(), &mut size);
+                        this = self.as_mut().project();
+
+                        let stream = match send.send_response(h2_res, size.is_eof()) {
+                            Err(e) => {
+                                trace!("Error sending HTTP/2 response: {:?}", e);
+                                return Poll::Ready(());
+                            }
+                            Ok(stream) => stream,
+                        };
+
+                        if size.is_eof() {
+                            Poll::Ready(())
+                        } else {
+                            this.state.set(ServiceResponseState::SendPayload(
+                                stream,
+                                body.into_body(),
+                            ));
+                            self.poll(cx)
+                        }
                     }
                 }
-                Poll::Pending => Poll::Pending,
-                Poll::Ready(Err(e)) => {
-                    let res: Response = e.into().into();
-                    let (res, body) = res.replace_body(());
+            }
 
-                    let mut send = send.take().unwrap();
-                    let mut size = body.size();
-                    let h2_res = self.as_mut().prepare_response(res.head(), &mut size);
-                    this = self.as_mut().project();
-
-                    let stream = match send.send_response(h2_res, size.is_eof()) {
-                        Err(e) => {
-                            trace!("Error sending h2 response: {:?}", e);
-                            return Poll::Ready(());
-                        }
-                        Ok(stream) => stream,
-                    };
-
-                    if size.is_eof() {
-                        Poll::Ready(())
-                    } else {
-                        this.state.set(ServiceResponseState::SendPayload(
-                            stream,
-                            body.into_body(),
-                        ));
-                        self.poll(cx)
-                    }
-                }
-            },
             ServiceResponseStateProj::SendPayload(ref mut stream, ref mut body) => {
                 loop {
                     loop {
-                        if let Some(ref mut buffer) = this.buffer {
-                            match stream.poll_capacity(cx) {
-                                Poll::Pending => return Poll::Pending,
-                                Poll::Ready(None) => return Poll::Ready(()),
-                                Poll::Ready(Some(Ok(cap))) => {
-                                    let len = buffer.len();
-                                    let bytes = buffer.split_to(std::cmp::min(cap, len));
+                        match this.buffer {
+                            Some(ref mut buffer) => {
+                                match ready!(stream.poll_capacity(cx)) {
+                                    None => return Poll::Ready(()),
 
-                                    if let Err(e) = stream.send_data(bytes, false) {
+                                    Some(Ok(cap)) => {
+                                        let len = buffer.len();
+                                        let bytes = buffer.split_to(cmp::min(cap, len));
+
+                                        if let Err(e) = stream.send_data(bytes, false) {
+                                            warn!("{:?}", e);
+                                            return Poll::Ready(());
+                                        } else if !buffer.is_empty() {
+                                            let cap = cmp::min(buffer.len(), CHUNK_SIZE);
+                                            stream.reserve_capacity(cap);
+                                        } else {
+                                            this.buffer.take();
+                                        }
+                                    }
+
+                                    Some(Err(e)) => {
                                         warn!("{:?}", e);
                                         return Poll::Ready(());
-                                    } else if !buffer.is_empty() {
-                                        let cap =
-                                            std::cmp::min(buffer.len(), CHUNK_SIZE);
-                                        stream.reserve_capacity(cap);
-                                    } else {
-                                        this.buffer.take();
                                     }
                                 }
-                                Poll::Ready(Some(Err(e))) => {
-                                    warn!("{:?}", e);
-                                    return Poll::Ready(());
-                                }
                             }
-                        } else {
-                            match body.as_mut().poll_next(cx) {
-                                Poll::Pending => return Poll::Pending,
-                                Poll::Ready(None) => {
+
+                            None => match ready!(body.as_mut().poll_next(cx)) {
+                                None => {
                                     if let Err(e) = stream.send_data(Bytes::new(), true)
                                     {
                                         warn!("{:?}", e);
                                     }
                                     return Poll::Ready(());
                                 }
-                                Poll::Ready(Some(Ok(chunk))) => {
-                                    stream.reserve_capacity(std::cmp::min(
+
+                                Some(Ok(chunk)) => {
+                                    stream.reserve_capacity(cmp::min(
                                         chunk.len(),
                                         CHUNK_SIZE,
                                     ));
                                     *this.buffer = Some(chunk);
                                 }
-                                Poll::Ready(Some(Err(e))) => {
+
+                                Some(Err(e)) => {
                                     error!("Response payload stream error: {:?}", e);
                                     return Poll::Ready(());
                                 }
-                            }
+                            },
                         }
                     }
                 }

actix-http/src/h2/mod.rs

@@ -1,9 +1,12 @@
-//! HTTP/2 implementation
-use std::pin::Pin;
-use std::task::{Context, Poll};
+//! HTTP/2 implementation.
+
+use std::{
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 use bytes::Bytes;
-use futures_core::Stream;
+use futures_core::{ready, Stream};
 use h2::RecvStream;
 
 mod dispatcher;
@@ -13,14 +16,14 @@ pub use self::dispatcher::Dispatcher;
 pub use self::service::H2Service;
 use crate::error::PayloadError;
 
-/// H2 receive stream
+/// HTTP/2 peer stream.
 pub struct Payload {
-    pl: RecvStream,
+    stream: RecvStream,
 }
 
 impl Payload {
-    pub(crate) fn new(pl: RecvStream) -> Self {
-        Self { pl }
+    pub(crate) fn new(stream: RecvStream) -> Self {
+        Self { stream }
     }
 }
 
@@ -33,18 +36,17 @@ impl Stream for Payload {
     ) -> Poll<Option<Self::Item>> {
         let this = self.get_mut();
 
-        match Pin::new(&mut this.pl).poll_data(cx) {
-            Poll::Ready(Some(Ok(chunk))) => {
+        match ready!(Pin::new(&mut this.stream).poll_data(cx)) {
+            Some(Ok(chunk)) => {
                 let len = chunk.len();
-                if let Err(err) = this.pl.flow_control().release_capacity(len) {
-                    Poll::Ready(Some(Err(err.into())))
-                } else {
-                    Poll::Ready(Some(Ok(chunk)))
+
+                match this.stream.flow_control().release_capacity(len) {
+                    Ok(()) => Poll::Ready(Some(Ok(chunk))),
+                    Err(err) => Poll::Ready(Some(Err(err.into()))),
                 }
             }
-            Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err(err.into()))),
-            Poll::Pending => Poll::Pending,
-            Poll::Ready(None) => Poll::Ready(None),
+            Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),
+            None => Poll::Ready(None),
         }
     }
 }

actix-http/src/h2/service.rs

@@ -26,12 +26,12 @@ use crate::{ConnectCallback, Extensions};
 
 use super::dispatcher::Dispatcher;
 
-/// `ServiceFactory` implementation for HTTP2 transport
+/// `ServiceFactory` implementation for HTTP/2 transport
 pub struct H2Service<T, S, B> {
     srv: S,
     cfg: ServiceConfig,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _t: PhantomData<(T, B)>,
+    _phantom: PhantomData<(T, B)>,
 }
 
 impl<T, S, B> H2Service<T, S, B>
@@ -42,7 +42,7 @@ where
     <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
 {
-    /// Create new `HttpService` instance with config.
+    /// Create new `H2Service` instance with config.
     pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
         cfg: ServiceConfig,
         service: F,
@@ -51,7 +51,7 @@ where
             cfg,
             on_connect_ext: None,
             srv: service.into_factory(),
-            _t: PhantomData,
+            _phantom: PhantomData,
         }
     }
 
@@ -70,7 +70,7 @@ where
     <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
 {
-    /// Create simple tcp based service
+    /// Create plain TCP based service
     pub fn tcp(
         self,
     ) -> impl ServiceFactory<
@@ -106,7 +106,7 @@ mod openssl {
         <S::Service as Service<Request>>::Future: 'static,
         B: MessageBody + 'static,
     {
-        /// Create ssl based service
+        /// Create OpenSSL based service
         pub fn openssl(
             self,
             acceptor: SslAcceptor,
@@ -149,7 +149,7 @@ mod rustls {
         <S::Service as Service<Request>>::Future: 'static,
         B: MessageBody + 'static,
     {
-        /// Create openssl based service
+        /// Create Rustls based service
         pub fn rustls(
             self,
             mut config: ServerConfig,
@@ -200,7 +200,7 @@ where
             fut: self.srv.new_service(()),
             cfg: Some(self.cfg.clone()),
             on_connect_ext: self.on_connect_ext.clone(),
-            _t: PhantomData,
+            _phantom: PhantomData,
         }
     }
 }
@@ -215,7 +215,7 @@ where
     fut: S::Future,
     cfg: Option<ServiceConfig>,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _t: PhantomData<B>,
+    _phantom: PhantomData<B>,
 }
 
 impl<T, S, B> Future for H2ServiceResponse<T, S, B>
@@ -232,14 +232,14 @@ where
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.as_mut().project();
 
-        Poll::Ready(ready!(this.fut.poll(cx)).map(|service| {
+        this.fut.poll(cx).map_ok(|service| {
             let this = self.as_mut().project();
             H2ServiceHandler::new(
                 this.cfg.take().unwrap(),
                 this.on_connect_ext.clone(),
                 service,
             )
-        }))
+        })
     }
 }
 
@@ -251,7 +251,7 @@ where
     srv: CloneableService<S>,
     cfg: ServiceConfig,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
-    _t: PhantomData<B>,
+    _phantom: PhantomData<B>,
 }
 
 impl<T, S, B> H2ServiceHandler<T, S, B>
@@ -271,7 +271,7 @@ where
             cfg,
             on_connect_ext,
             srv: CloneableService::new(srv),
-            _t: PhantomData,
+            _phantom: PhantomData,
         }
     }
 }
@@ -363,8 +363,8 @@ where
                 ref peer_addr,
                 ref mut on_connect_data,
                 ref mut handshake,
-            ) => match Pin::new(handshake).poll(cx) {
-                Poll::Ready(Ok(conn)) => {
+            ) => match ready!(Pin::new(handshake).poll(cx)) {
+                Ok(conn) => {
                     self.state = State::Incoming(Dispatcher::new(
                         srv.take().unwrap(),
                         conn,
@@ -375,11 +375,10 @@ where
                     ));
                     self.poll(cx)
                 }
-                Poll::Ready(Err(err)) => {
+                Err(err) => {
                     trace!("H2 handshake error: {}", err);
                     Poll::Ready(Err(err.into()))
                 }
-                Poll::Pending => Poll::Pending,
             },
         }
     }