src/bin/h2s-server.rs

   1 use std::sync::Arc;
   2
   3 use failure::*;
   4 use futures::*;
   5 use hyper::{Request, Response, Body};
   6 use openssl::ssl::{SslMethod, SslAcceptor, SslFiletype};
   7 use tokio::net::{TcpListener, TcpStream};
   8
   9 use proxmox_backup::configdir;
  10
  11 // Simple H2 server to test H2 speed with h2s-client.rs
  12
  13 fn main() -> Result<(), Error> {
  14     proxmox_backup::tools::runtime::main(run())
  15 }
  16
  17 async fn run() -> Result<(), Error> {
  18     let key_path = configdir!("/proxy.key");
  19     let cert_path = configdir!("/proxy.pem");
  20
  21     let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
  22     acceptor.set_private_key_file(key_path, SslFiletype::PEM)
  23         .map_err(|err| format_err!("unable to read proxy key {} - {}", key_path, err))?;
  24     acceptor.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 mut 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))
  37             .map(|res| {
  38                 if let Err(err) = res {
  39                     eprintln!("Error: {}", err);
  40                 }
  41             }));
  42     }
  43 }
  44
  45 async fn handle_connection(
  46     socket: TcpStream,
  47     acceptor: Arc<SslAcceptor>,
  48 ) -> Result<(), Error> {
  49     socket.set_nodelay(true).unwrap();
  50     socket.set_send_buffer_size(1024*1024).unwrap();
  51     socket.set_recv_buffer_size(1024*1024).unwrap();
  52
  53     let socket = tokio_openssl::accept(acceptor.as_ref(), socket).await?;
  54
  55     let mut http = hyper::server::conn::Http::new();
  56     http.http2_only(true);
  57     // increase window size: todo - find optiomal size
  58     let max_window_size = (1 << 31) - 2;
  59     http.http2_initial_stream_window_size(max_window_size);
  60     http.http2_initial_connection_window_size(max_window_size);
  61
  62     let service = hyper::service::service_fn(|_req: Request<Body>| {
  63         println!("Got request");
  64         let buffer = vec![65u8; 1024*1024]; // nonsense [A,A,A,A...]
  65         let body = Body::from(buffer);
  66
  67         let response = Response::builder()
  68             .status(http::StatusCode::OK)
  69             .header(http::header::CONTENT_TYPE, "application/octet-stream")
  70             .body(body)
  71             .unwrap();
  72         future::ok::<_, Error>(response)
  73     });
  74
  75     http.serve_connection(socket, service)
  76         .map_err(Error::from)
  77         .await?;
  78
  79     println!("H2 connection CLOSE !");
  80     Ok(())
  81 }