via 2.0.0-gm.4

An async multi-threaded web framework for people who appreciate simplicity.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::future::Future;
use std::io;
use std::pin::Pin;
use std::process::ExitCode;
use std::sync::Arc;
use std::task::{Context, Poll, ready};
use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
use tokio::net::{TcpListener, TcpStream, ToSocketAddrs};
use tokio_rustls::server::{Accept, TlsAcceptor, TlsStream};

use super::super::accept;
use super::super::server::ServerConfig;
use crate::app::AppService;
use crate::error::Error;

enum Negotiate {
    Ready(TlsStream<TcpStream>),
    Pending(Accept<TcpStream>),
}

pub fn listen_rustls<App, A>(
    config: ServerConfig,
    address: A,
    tls_config: rustls::ServerConfig,
    service: AppService<App>,
) -> impl Future<Output = Result<ExitCode, Error>>
where
    A: ToSocketAddrs,
    App: Send + Sync + 'static,
{
    let handshake = {
        let acceptor = TlsAcceptor::from(Arc::new(tls_config));
        Box::new(move |stream| {
            let acceptor = acceptor.clone();
            async move {
                let mut stream = Box::pin(Negotiate::Pending(acceptor.accept(stream)));
                stream.as_mut().await?;
                Ok(stream)
            }
        })
    };

    async {
        let exit = accept(
            config,
            TcpListener::bind(address).await?,
            handshake,
            service,
        );

        Ok(exit.await)
    }
}

impl AsyncRead for Negotiate {
    fn poll_read(
        self: Pin<&mut Self>,
        context: &mut Context,
        buf: &mut ReadBuf<'_>,
    ) -> Poll<io::Result<()>> {
        if let Self::Ready(stream) = self.get_mut() {
            Pin::new(stream).poll_read(context, buf)
        } else {
            Poll::Pending
        }
    }
}

impl AsyncWrite for Negotiate {
    fn poll_write(
        self: Pin<&mut Self>,
        context: &mut Context,
        buf: &[u8],
    ) -> Poll<io::Result<usize>> {
        if let Self::Ready(stream) = self.get_mut() {
            Pin::new(stream).poll_write(context, buf)
        } else {
            Poll::Pending
        }
    }

    fn poll_flush(self: Pin<&mut Self>, context: &mut Context) -> Poll<io::Result<()>> {
        if let Self::Ready(stream) = self.get_mut() {
            Pin::new(stream).poll_flush(context)
        } else {
            Poll::Pending
        }
    }

    fn poll_shutdown(self: Pin<&mut Self>, context: &mut Context) -> Poll<io::Result<()>> {
        if let Self::Ready(stream) = self.get_mut() {
            Pin::new(stream).poll_shutdown(context)
        } else {
            Poll::Pending
        }
    }

    fn is_write_vectored(&self) -> bool {
        true
    }

    fn poll_write_vectored(
        self: Pin<&mut Self>,
        context: &mut Context,
        bufs: &[io::IoSlice],
    ) -> Poll<io::Result<usize>> {
        if let Self::Ready(stream) = self.get_mut() {
            Pin::new(stream).poll_write_vectored(context, bufs)
        } else {
            Poll::Pending
        }
    }
}

impl Future for Negotiate {
    type Output = io::Result<()>;

    fn poll(self: Pin<&mut Self>, context: &mut Context) -> Poll<Self::Output> {
        let this = self.get_mut();

        if let Self::Pending(accept) = this {
            let stream = ready!(Pin::new(accept).poll(context)?);
            *this = Negotiate::Ready(stream);
        }

        Poll::Ready(Ok(()))
    }
}