examples/h2s-server.rs

   1 use std::sync::Arc;
   2
   3 use anyhow::{format_err, Error};
   4 use futures::*;
   5 use hyper::{Body, Request, Response};
   6 use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod};
   7 use tokio::net::{TcpListener, TcpStream};
   8
   9 use pbs_buildcfg::configdir;
  10
  11 fn main() -> Result<(), Error> {
  12     proxmox_async::runtime::main(run())
  13 }
  14
  15 async fn run() -> Result<(), Error> {
  16     let key_path = configdir!("/proxy.key");
  17     let cert_path = configdir!("/proxy.pem");
  18
  19     let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
  20     acceptor
  21         .set_private_key_file(key_path, SslFiletype::PEM)
  22         .map_err(|err| format_err!("unable to read proxy key {} - {}", key_path, err))?;
  23     acceptor
  24         .set_certificate_chain_file(cert_path)
  25         .map_err(|err| format_err!("unable to read proxy cert {} - {}", cert_path, err))?;
  26     acceptor.check_private_key().unwrap();
  27
  28     let acceptor = Arc::new(acceptor.build());
  29
  30     let listener = TcpListener::bind(std::net::SocketAddr::from(([127, 0, 0, 1], 8008))).await?;
  31
  32     println!("listening on {:?}", listener.local_addr());
  33
  34     loop {
  35         let (socket, _addr) = listener.accept().await?;
  36         tokio::spawn(handle_connection(socket, Arc::clone(&acceptor)).map(|res| {
  37             if let Err(err) = res {
  38                 eprintln!("Error: {}", err);
  39             }
  40         }));
  41     }
  42 }
  43
  44 async fn handle_connection(socket: TcpStream, acceptor: Arc<SslAcceptor>) -> Result<(), Error> {
  45     socket.set_nodelay(true).unwrap();
  46
  47     let ssl = openssl::ssl::Ssl::new(acceptor.context())?;
  48     let stream = tokio_openssl::SslStream::new(ssl, socket)?;
  49     let mut stream = Box::pin(stream);
  50
  51     stream.as_mut().accept().await?;
  52
  53     let mut http = hyper::server::conn::Http::new();
  54     http.http2_only(true);
  55     // increase window size: todo - find optiomal size
  56     let max_window_size = (1 << 31) - 2;
  57     http.http2_initial_stream_window_size(max_window_size);
  58     http.http2_initial_connection_window_size(max_window_size);
  59
  60     let service = hyper::service::service_fn(|_req: Request<Body>| {
  61         println!("Got request");
  62         let buffer = vec![65u8; 4 * 1024 * 1024]; // nonsense [A,A,A,A...]
  63         let body = Body::from(buffer);
  64
  65         let response = Response::builder()
  66             .status(http::StatusCode::OK)
  67             .header(http::header::CONTENT_TYPE, "application/octet-stream")
  68             .body(body)
  69             .unwrap();
  70         future::ok::<_, Error>(response)
  71     });
  72
  73     http.serve_connection(stream, service)
  74         .map_err(Error::from)
  75         .await?;
  76
  77     println!("H2 connection CLOSE !");
  78     Ok(())
  79 }