krisselden/hyper-http2.rs

## hyper-http2.rs
extern crate hyper;
extern crate tls_api;
extern crate tls_api_openssl;
extern crate tokio_tls_api;
use futures::{Future, Stream};
use hyper::server::conn::{AddrIncoming, Http};
use hyper::service::service_fn_ok;
use hyper::{Body, Request, Response};
use tls_api::TlsAcceptorBuilder;
use tokio_tls_api::accept_async;

fn main() -> Result<(), Box<std::error::Error>> {
    let pkcs12 = include_bytes!("localhost.p12");
    let mut tls_acceptor_builder =
        tls_api_openssl::TlsAcceptorBuilder::from_pkcs12(pkcs12, "test")?;
    // negotiage HTTP2 protocol during TLS negotiation
    tls_acceptor_builder
        .set_alpn_protocols(&[b"h2"])
        .expect("set_alpn_protocols");
    let tls_acceptor = tls_acceptor_builder.build()?;

    let addr = "127.0.0.1:12345".parse()?;
    let incoming = AddrIncoming::bind(&addr)?;

    let server = incoming
        .for_each(move |hyper_addr_stream| {
            println!("new connection {:?}", hyper_addr_stream.remote_addr());
            let handle_connection = accept_async(&tls_acceptor, hyper_addr_stream)
                .and_then(|tls_stream| {
                    let http = Http::new();
                    http.serve_connection(tls_stream, service_fn_ok(handle_request))
                        .and_then(|_| {
                            println!("connection closed");
                            Ok(())
                        })
                        .or_else(|err| {
                            println!("hyper serve error {:?}", err);
                            Ok(())
                        })
                })
                .or_else(|err| {
                    println!("TLS error {:?}", err);
                    Ok(())
                });

            hyper::rt::spawn(handle_connection);
            Ok(())
        })
        .or_else(|err| {
            println!("Server error {:?}", err);
            Ok(())
        });

    hyper::rt::run(server);
    Ok(())
}

fn handle_request(req: Request<Body>) -> Response<Body> {
    let uri_str = format!("{}", req.uri());
    println!("responding to {}", uri_str);
    Response::new(Body::from(uri_str.into_bytes()))
}
	extern crate hyper;
	extern crate tls_api;
	extern crate tls_api_openssl;
	extern crate tokio_tls_api;
	use futures::{Future, Stream};
	use hyper::server::conn::{AddrIncoming, Http};
	use hyper::service::service_fn_ok;
	use hyper::{Body, Request, Response};
	use tls_api::TlsAcceptorBuilder;
	use tokio_tls_api::accept_async;

	fn main() -> Result<(), Box<std::error::Error>> {
	let pkcs12 = include_bytes!("localhost.p12");
	let mut tls_acceptor_builder =
	tls_api_openssl::TlsAcceptorBuilder::from_pkcs12(pkcs12, "test")?;
	// negotiage HTTP2 protocol during TLS negotiation
	tls_acceptor_builder
	.set_alpn_protocols(&[b"h2"])
	.expect("set_alpn_protocols");
	let tls_acceptor = tls_acceptor_builder.build()?;

	let addr = "127.0.0.1:12345".parse()?;
	let incoming = AddrIncoming::bind(&addr)?;

	let server = incoming
	.for_each(move \|hyper_addr_stream\| {
	println!("new connection {:?}", hyper_addr_stream.remote_addr());
	let handle_connection = accept_async(&tls_acceptor, hyper_addr_stream)
	.and_then(\|tls_stream\| {
	let http = Http::new();
	http.serve_connection(tls_stream, service_fn_ok(handle_request))
	.and_then(\|_\| {
	println!("connection closed");
	Ok(())
	})
	.or_else(\|err\| {
	println!("hyper serve error {:?}", err);
	Ok(())
	})
	})
	.or_else(\|err\| {
	println!("TLS error {:?}", err);
	Ok(())
	});

	hyper::rt::spawn(handle_connection);
	Ok(())
	})
	.or_else(\|err\| {
	println!("Server error {:?}", err);
	Ok(())
	});

	hyper::rt::run(server);
	Ok(())
	}

	fn handle_request(req: Request<Body>) -> Response<Body> {
	let uri_str = format!("{}", req.uri());
	println!("responding to {}", uri_str);
	Response::new(Body::from(uri_str.into_bytes()))
	}