[proxmox-backup.git] / src / bin / 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(())
}
Commit	Line	Data
e235c8f7 WB	1	use std::sync::Arc;
e235c8f7 WB	2
f7d4e4b5	3	use anyhow::{format_err, Error};
5ed2277f	4	use futures::*;
5ed2277f	5	use hyper::{Request, Response, Body};
6d1f61b2	6	use openssl::ssl::{SslMethod, SslAcceptor, SslFiletype};
e235c8f7	7	use tokio::net::{TcpListener, TcpStream};
5ed2277f	8
e235c8f7	9	use proxmox_backup::configdir;
5ed2277f	10
e235c8f7	11	// Simple H2 server to test H2 speed with h2s-client.rs
5ed2277f	12
d973aa82 WB	13	fn main() -> Result<(), Error> {
	14	proxmox_backup::tools::runtime::main(run())
	15	}
	16
	17	async fn run() -> Result<(), Error> {
6d1f61b2 DM	18	let key_path = configdir!("/proxy.key");
6d1f61b2 DM	19	let cert_path = configdir!("/proxy.pem");
5ed2277f	20
6d1f61b2 DM	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();
5ed2277f	27
6d1f61b2	28	let acceptor = Arc::new(acceptor.build());
5ed2277f	29
db0cb9ce	30	let mut listener = TcpListener::bind(std::net::SocketAddr::from(([127,0,0,1], 8008))).await?;
5ed2277f DM	31
	32	println!("listening on {:?}", listener.local_addr());
	33
db0cb9ce WB	34	loop {
db0cb9ce WB	35	let (socket, _addr) = listener.accept().await?;
e235c8f7 WB	36	tokio::spawn(handle_connection(socket, Arc::clone(&acceptor))
	37	.map(\|res\| {
	38	if let Err(err) = res {
	39	eprintln!("Error: {}", err);
5ed2277f	40	}
e235c8f7 WB	41	}));
e235c8f7 WB	42	}
e235c8f7 WB	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?;
5ed2277f	78
e235c8f7	79	println!("H2 connection CLOSE !");
5ed2277f DM	80	Ok(())
5ed2277f DM	81	}