proxmox-backup/examples/h2s-server.rs

use std::sync::Arc;

use anyhow::{format_err, Error};
use futures::*;
use hyper::{Request, Response, Body};
use openssl::ssl::{SslMethod, SslAcceptor, SslFiletype};
use tokio::net::{TcpListener, TcpStream};

use proxmox_backup::configdir;

// Simple H2 server to test H2 speed with h2s-client.rs

fn main() -> Result<(), Error> {
    proxmox_backup::tools::runtime::main(run())
}

async fn run() -> Result<(), Error> {
    let key_path = configdir!("/proxy.key");
    let cert_path = configdir!("/proxy.pem");

    let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
    acceptor.set_private_key_file(key_path, SslFiletype::PEM)
        .map_err(|err| format_err!("unable to read proxy key {} - {}", key_path, err))?;
    acceptor.set_certificate_chain_file(cert_path)
        .map_err(|err| format_err!("unable to read proxy cert {} - {}", cert_path, err))?;
    acceptor.check_private_key().unwrap();

    let acceptor = Arc::new(acceptor.build());

    let mut listener = TcpListener::bind(std::net::SocketAddr::from(([127,0,0,1], 8008))).await?;

    println!("listening on {:?}", listener.local_addr());

    loop {
        let (socket, _addr) = listener.accept().await?;
        tokio::spawn(handle_connection(socket, Arc::clone(&acceptor))
            .map(|res| {
                if let Err(err) = res {
                    eprintln!("Error: {}", err);
                }
            }));
    }
}

async fn handle_connection(
    socket: TcpStream,
    acceptor: Arc<SslAcceptor>,
) -> Result<(), Error> {
    socket.set_nodelay(true).unwrap();
    socket.set_send_buffer_size(1024*1024).unwrap();
    socket.set_recv_buffer_size(1024*1024).unwrap();

    let socket = tokio_openssl::accept(acceptor.as_ref(), socket).await?;

    let mut http = hyper::server::conn::Http::new();
    http.http2_only(true);
    // increase window size: todo - find optiomal size
    let max_window_size = (1 << 31) - 2;
    http.http2_initial_stream_window_size(max_window_size);
    http.http2_initial_connection_window_size(max_window_size);

    let service = hyper::service::service_fn(|_req: Request<Body>| {
        println!("Got request");
        let buffer = vec![65u8; 1024*1024]; // nonsense [A,A,A,A...]
        let body = Body::from(buffer);

        let response = Response::builder()
            .status(http::StatusCode::OK)
            .header(http::header::CONTENT_TYPE, "application/octet-stream")
            .body(body)
            .unwrap();
        future::ok::<_, Error>(response)
    });

    http.serve_connection(socket, service)
        .map_err(Error::from)
        .await?;

    println!("H2 connection CLOSE !");
    Ok(())
}
src/bin/h2s-server.rs: switch to async Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-08-28 16:01:10 +02:00			`use std::sync::Arc;`

switch from failure to anyhow Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2020-04-17 14:11:25 +02:00			`use anyhow::{format_err, Error};`
src/bin/h2s-server.rs: test to reproduce slow h2 download Simplified code, use with h2s-client.rs. 2019-06-29 14:57:54 +02:00			`use futures::*;`
			`use hyper::{Request, Response, Body};`
use hyper/tokio-openssl instead of hyper/tokio-tls This exposes the complete SSL setup. And download is much faster now (600MB/s instead of 130MB/s)! 2019-07-02 13:33:58 +02:00			`use openssl::ssl::{SslMethod, SslAcceptor, SslFiletype};`
src/bin/h2s-server.rs: switch to async Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-08-28 16:01:10 +02:00			`use tokio::net::{TcpListener, TcpStream};`
src/bin/h2s-server.rs: test to reproduce slow h2 download Simplified code, use with h2s-client.rs. 2019-06-29 14:57:54 +02:00
src/bin/h2s-server.rs: switch to async Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-08-28 16:01:10 +02:00			`use proxmox_backup::configdir;`
src/bin/h2s-server.rs: test to reproduce slow h2 download Simplified code, use with h2s-client.rs. 2019-06-29 14:57:54 +02:00
src/bin/h2s-server.rs: switch to async Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-08-28 16:01:10 +02:00			`// Simple H2 server to test H2 speed with h2s-client.rs`
src/bin/h2s-server.rs: test to reproduce slow h2 download Simplified code, use with h2s-client.rs. 2019-06-29 14:57:54 +02:00
introduce new runtime tokio helpers Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2020-01-20 12:52:22 +01:00			`fn main() -> Result<(), Error> {`
			`proxmox_backup::tools::runtime::main(run())`
			`}`

			`async fn run() -> Result<(), Error> {`
use hyper/tokio-openssl instead of hyper/tokio-tls This exposes the complete SSL setup. And download is much faster now (600MB/s instead of 130MB/s)! 2019-07-02 13:33:58 +02:00			`let key_path = configdir!("/proxy.key");`
			`let cert_path = configdir!("/proxy.pem");`
src/bin/h2s-server.rs: test to reproduce slow h2 download Simplified code, use with h2s-client.rs. 2019-06-29 14:57:54 +02:00
use hyper/tokio-openssl instead of hyper/tokio-tls This exposes the complete SSL setup. And download is much faster now (600MB/s instead of 130MB/s)! 2019-07-02 13:33:58 +02:00			`let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();`
			`acceptor.set_private_key_file(key_path, SslFiletype::PEM)`
			`.map_err(\|err\| format_err!("unable to read proxy key {} - {}", key_path, err))?;`
			`acceptor.set_certificate_chain_file(cert_path)`
			`.map_err(\|err\| format_err!("unable to read proxy cert {} - {}", cert_path, err))?;`
			`acceptor.check_private_key().unwrap();`
src/bin/h2s-server.rs: test to reproduce slow h2 download Simplified code, use with h2s-client.rs. 2019-06-29 14:57:54 +02:00
use hyper/tokio-openssl instead of hyper/tokio-tls This exposes the complete SSL setup. And download is much faster now (600MB/s instead of 130MB/s)! 2019-07-02 13:33:58 +02:00			`let acceptor = Arc::new(acceptor.build());`
src/bin/h2s-server.rs: test to reproduce slow h2 download Simplified code, use with h2s-client.rs. 2019-06-29 14:57:54 +02:00
update a chunk of stuff to the hyper release Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-12-12 15:27:07 +01:00			`let mut listener = TcpListener::bind(std::net::SocketAddr::from(([127,0,0,1], 8008))).await?;`
src/bin/h2s-server.rs: test to reproduce slow h2 download Simplified code, use with h2s-client.rs. 2019-06-29 14:57:54 +02:00
			`println!("listening on {:?}", listener.local_addr());`

update a chunk of stuff to the hyper release Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-12-12 15:27:07 +01:00			`loop {`
			`let (socket, _addr) = listener.accept().await?;`
src/bin/h2s-server.rs: switch to async Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-08-28 16:01:10 +02:00			`tokio::spawn(handle_connection(socket, Arc::clone(&acceptor))`
			`.map(\|res\| {`
			`if let Err(err) = res {`
			`eprintln!("Error: {}", err);`
src/bin/h2s-server.rs: test to reproduce slow h2 download Simplified code, use with h2s-client.rs. 2019-06-29 14:57:54 +02:00			`}`
src/bin/h2s-server.rs: switch to async Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-08-28 16:01:10 +02:00			`}));`
			`}`
			`}`

			`async fn handle_connection(`
			`socket: TcpStream,`
			`acceptor: Arc<SslAcceptor>,`
			`) -> Result<(), Error> {`
			`socket.set_nodelay(true).unwrap();`
			`socket.set_send_buffer_size(1024*1024).unwrap();`
			`socket.set_recv_buffer_size(1024*1024).unwrap();`

			`let socket = tokio_openssl::accept(acceptor.as_ref(), socket).await?;`

			`let mut http = hyper::server::conn::Http::new();`
			`http.http2_only(true);`
			`// increase window size: todo - find optiomal size`
			`let max_window_size = (1 << 31) - 2;`
			`http.http2_initial_stream_window_size(max_window_size);`
			`http.http2_initial_connection_window_size(max_window_size);`

			`let service = hyper::service::service_fn(\|_req: Request<Body>\| {`
			`println!("Got request");`
			`let buffer = vec![65u8; 1024*1024]; // nonsense [A,A,A,A...]`
			`let body = Body::from(buffer);`

			`let response = Response::builder()`
			`.status(http::StatusCode::OK)`
			`.header(http::header::CONTENT_TYPE, "application/octet-stream")`
			`.body(body)`
			`.unwrap();`
			`future::ok::<_, Error>(response)`
			`});`

			`http.serve_connection(socket, service)`
			`.map_err(Error::from)`
			`.await?;`
src/bin/h2s-server.rs: test to reproduce slow h2 download Simplified code, use with h2s-client.rs. 2019-06-29 14:57:54 +02:00
src/bin/h2s-server.rs: switch to async Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com> 2019-08-28 16:01:10 +02:00			`println!("H2 connection CLOSE !");`
src/bin/h2s-server.rs: test to reproduce slow h2 download Simplified code, use with h2s-client.rs. 2019-06-29 14:57:54 +02:00			`Ok(())`
			`}`