Make examples/simple.rs compatible with hyper v1
#1
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,67 +1,120 @@ | ||
| use std::convert::Infallible; | ||
| use std::io; | ||
| use std::net::{IpAddr, SocketAddr}; | ||
| use std::time::Duration; | ||
|
|
||
| use http_body_util::combinators::UnsyncBoxBody; | ||
| use http_body_util::{BodyExt, Empty, Full}; | ||
| use hyper::body::{Bytes, Incoming}; | ||
| use hyper::server::conn::http1; | ||
| use hyper::service::service_fn; | ||
| use hyper::{Request, Response, StatusCode}; | ||
| use hyper_util::rt::{TokioExecutor, TokioIo, TokioTimer}; | ||
| use tokio::net::TcpListener; | ||
|
|
||
| use hyper_reverse_proxy::ReverseProxy; | ||
| use hyper_rustls::{ConfigBuilderExt, HttpsConnector}; | ||
| use hyper_util::client::legacy::connect::HttpConnector; | ||
|
|
||
| type Connector = HttpsConnector<HttpConnector>; | ||
| type ResponseBody = UnsyncBoxBody<Bytes, std::io::Error>; | ||
|
|
||
| lazy_static::lazy_static! { | ||
|
There was a problem hiding this comment. As long as you're here fixing up the example, I think it's no longer recommended to use lazy_static. From the lazy_static repo:
So if anything it'd be better to use that. There was a problem hiding this comment. Good idea, I opened #2. |
||
| static ref PROXY_CLIENT: ReverseProxy<Connector> = { | ||
| let connector: Connector = Connector::builder() | ||
| .with_tls_config( | ||
| rustls::ClientConfig::builder() | ||
| .with_native_roots() | ||
| .expect("with_native_roots") | ||
| .with_no_client_auth(), | ||
| ) | ||
| .https_or_http() | ||
| .enable_http1() | ||
| .build(); | ||
|
Comment on lines
+31
to
+32
There was a problem hiding this comment. Only enabling http1 because http2 requires that the upstream server also supports http2, since we're not doing any http2-to-http1 translation at the moment. |
||
| ReverseProxy::new( | ||
| hyper_util::client::legacy::Builder::new(TokioExecutor::new()) | ||
| .pool_idle_timeout(Duration::from_secs(3)) | ||
| .pool_timer(TokioTimer::new()) | ||
|
There was a problem hiding this comment. Motivation: The default idle timeout is 90 seconds, which is far too long for most services that you connect the reverse proxy to. My test service used 15 seconds, which means I started getting an error 15 seconds after I opened the reverse proxy. Ideally the keep-alive header from the upstream server would be used automatically. But that can change per request, so I think it would require quite a lot of work to make this seamless. Open to ideas here. There was a problem hiding this comment.
Was this an error from hyper-reverse-proxy? If so I would say the solution would be to silence that error. If upstream has decided that an idle connection should get closed that's not really an error, that's business as usual (imo). 90 seconds does initially strike me as being too long for a default, but it's what go's builtin reverse proxy uses (via the DefaultTransport.IdleConnTimeout), and they've probably thought about it more than I have. In any case the client would ideally honor the keep alive timeout provided by the server, but that's more a concern of the There was a problem hiding this comment. Sorry, I guess I wasn't very clear on what was happening here. The error is:
Because the connection between the proxy and the upstream service has been closed (in my case after 15 seconds), but the connection between the client and the proxy is still open. So on the next request the proxy will attempt to use a connection that is already closed, which results in the error. Here's a GitHub thread discussing the issue: hyperium/hyper#2136 The TL;DR seems to be that it isn't always safe to automatically retry the request. Anyway, I thought that it might be useful to include in the example, but perhaps it requires a comment explaining the problem. There was a problem hiding this comment. I see, maybe best to just include that link as a comment there for now 👍 |
||
| .build::<_, Incoming>(connector), | ||
| ) | ||
| }; | ||
| } | ||
|
|
||
| async fn handle( | ||
| client_ip: IpAddr, | ||
| req: Request<Incoming>, | ||
| ) -> Result<Response<ResponseBody>, Infallible> { | ||
| let host = req.headers().get("host").and_then(|v| v.to_str().ok()); | ||
| if host.is_some_and(|host| host.starts_with("service1.localhost")) { | ||
| match PROXY_CLIENT | ||
|
Comment on lines
+47
to
+48
There was a problem hiding this comment. The motivation for using the host header over the path is because the path is forwarded to the upstream server, and most servers will return a useless 404 for the path |
||
| .call(client_ip, "http://127.0.0.1:13901", req) | ||
| .await | ||
| { | ||
| Ok(response) => Ok(response), | ||
| Err(_error) => Ok(Response::builder() | ||
| .status(StatusCode::INTERNAL_SERVER_ERROR) | ||
| .body(UnsyncBoxBody::new( | ||
| Empty::<Bytes>::new().map_err(io::Error::other), | ||
| )) | ||
| .unwrap()), | ||
| } | ||
| } else if host.is_some_and(|host| host.starts_with("service2.localhost")) { | ||
| match PROXY_CLIENT | ||
| .call(client_ip, "http://127.0.0.1:13902", req) | ||
| .await | ||
| { | ||
| Ok(response) => Ok(response), | ||
| Err(_error) => Ok(Response::builder() | ||
| .status(StatusCode::INTERNAL_SERVER_ERROR) | ||
| .body(UnsyncBoxBody::new( | ||
| Empty::<Bytes>::new().map_err(io::Error::other), | ||
| )) | ||
| .unwrap()), | ||
| } | ||
| } else { | ||
| let body_str = format!("{:?}", req); | ||
| Ok(Response::new(UnsyncBoxBody::new( | ||
| Full::new(Bytes::from(body_str)).map_err(io::Error::other), | ||
| ))) | ||
| } | ||
| } | ||
|
|
||
| #[tokio::main] | ||
| async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> { | ||
| let bind_addr = "127.0.0.1:8000"; | ||
| let addr: SocketAddr = bind_addr.parse().expect("Could not parse ip:port."); | ||
|
|
||
| // We create a TcpListener and bind it to the address | ||
| let listener = TcpListener::bind(addr).await?; | ||
|
|
||
| println!( | ||
| "Access service1 on http://service1.localhost:{}", | ||
| addr.port() | ||
| ); | ||
| println!( | ||
| "Access service2 on http://service2.localhost:{}", | ||
| addr.port() | ||
| ); | ||
|
|
||
| // We start a loop to continuously accept incoming connections | ||
| loop { | ||
| let (stream, remote_addr) = listener.accept().await?; | ||
| let client_ip = remote_addr.ip(); | ||
|
|
||
| // Use an adapter to access something implementing `tokio::io` traits as if they implement | ||
| // `hyper::rt` IO traits. | ||
| let io = TokioIo::new(stream); | ||
|
|
||
| // Spawn a tokio task to serve multiple connections concurrently | ||
| tokio::task::spawn(async move { | ||
| // Finally, we bind the incoming connection to our `hello` service | ||
| if let Err(err) = http1::Builder::new() | ||
| // `service_fn` converts our function in a `Service` | ||
| .serve_connection(io, service_fn(move |req| handle(client_ip, req))) | ||
| .await | ||
| { | ||
| eprintln!("Error serving connection: {:?}", err); | ||
| } | ||
| }); | ||
| } | ||
| } | ||
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Motivation: hyper-trust-dns was rebranded to hyper-hickory and no longer has a HttpsConnector, so using hyper-rustls instead.