gway 0.1.1

proxy
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

use std::{net::SocketAddr, sync::Arc};

use hyper::{Request, body::Incoming, service::service_fn};
use hyper_util::rt::{TokioExecutor, TokioIo};
use rustls::ServerConfig;
use tokio::net::TcpListener;
use tokio_rustls::TlsAcceptor;

use crate::{CertLoader, LoadCert, Result, Route, proxy};

pub async fn srv<D: LoadCert>(
  addr: SocketAddr,
  route: Arc<Route>,
  cert_loader: Arc<CertLoader<D>>,
) -> Result<()> {
  let listener = TcpListener::bind(addr).await?;
  let mut tls_config = ServerConfig::builder()
    .with_no_client_auth()
    .with_cert_resolver(cert_loader);
  tls_config.alpn_protocols = vec![b"h2".to_vec()];
  let tls_acceptor = TlsAcceptor::from(Arc::new(tls_config));

  loop {
    let (stream, _remote_addr) = listener.accept().await?;
    let tls_acceptor = tls_acceptor.clone();
    let route = route.clone();
    tokio::spawn(async move {
      let stream = match tls_acceptor.accept(stream).await {
        Ok(stream) => stream,
        Err(err) => {
          eprintln!("tls accept error: {}", err);
          return;
        }
      };

      let io = TokioIo::new(stream);
      let service = service_fn(move |req: Request<Incoming>| {
        let route = route.clone();
        async move { Ok::<_, hyper::Error>(proxy(req, route).await) }
      });

      let conn_builder = hyper::server::conn::http2::Builder::new(TokioExecutor::new());
      if let Err(err) = conn_builder.serve_connection(io, service).await {
        eprintln!("h2 error: {}", err);
      }
    });
  }
}