switch to proxy pkg

robherley · robherley · commit 9519f4352435 · 2025-11-01T21:36:56.000-04:00
diff --git a/crates/funcd/Cargo.toml b/crates/funcd/Cargo.toml
@@ -11,10 +11,9 @@ path = "src/main.rs"
 
 [dependencies]
 anyhow = "1.0"
-axum = "0.8.6"
+axum = { version = "0.8.6", features = ["ws"] }
+axum-reverse-proxy = "1.0.3"
 http-body-util = "0.1"
-hyper = { version = "1.6.1", features = ["client", "http1", "http2"] }
-hyper-util = { version = "0.1", features = ["client-legacy", "http1", "http2", "tokio"] }
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.145"
 tokio = { version = "1", features = ["full"] }
diff --git a/crates/funcd/src/main.rs b/crates/funcd/src/main.rs
@@ -61,7 +61,6 @@ async fn main() -> Result<()> {
     };
 
     info!("will proxy requests to port: {}", http_port);
-
-    server::serve(&http_addr, http_port).await?;
+    server::proxy(&http_addr, http_port).await?;
     Ok(())
 }
diff --git a/crates/funcd/src/server.rs b/crates/funcd/src/server.rs
@@ -1,79 +1,14 @@
 use anyhow::Result;
-use axum::{
-    Router,
-    body::Body,
-    extract::State,
-    http::{Request, StatusCode},
-    response::{IntoResponse, Response},
-};
-use hyper_util::{
-    // https://github.com/hyperium/hyper/issues/3948
-    client::legacy::{Client, connect::HttpConnector},
-    rt::TokioExecutor,
-};
-use std::sync::Arc;
-use tracing::{error, info};
-
-#[derive(Clone)]
-struct ProxyState {
-    client: Client<HttpConnector, Body>,
-    proxy_port: u16,
-}
-
-pub async fn serve(addr: &str, proxy_port: u16) -> Result<()> {
-    let client = Client::builder(TokioExecutor::new()).build_http();
-    let state = Arc::new(ProxyState { client, proxy_port });
-    let router = Router::new().fallback(proxy_handler).with_state(state);
+use axum::Router;
+use axum_reverse_proxy::ReverseProxy;
+use tracing::info;
+
+pub async fn proxy(addr: &str, proxy_port: u16) -> Result<()> {
+    let process_host = format!("http://localhost:{}", proxy_port);
+    let proxy = ReverseProxy::new("/", &process_host);
+    let app: Router = proxy.into();
     let listener = tokio::net::TcpListener::bind(&addr).await?;
     info!(component = "http", addr = %addr, proxy_port, "listening");
-    axum::serve(listener, router).await?;
+    axum::serve(listener, app).await?;
     Ok(())
 }
-
-async fn proxy_handler(
-    State(state): State<Arc<ProxyState>>,
-    mut req: Request<Body>,
-) -> Result<Response, RoutingError> {
-    let proxy_uri = format!(
-        "http://127.0.0.1:{}{}",
-        state.proxy_port,
-        req.uri()
-            .path_and_query()
-            .map(|pq| pq.as_str())
-            .unwrap_or("/")
-    );
-
-    info!(
-        method = %req.method(),
-        uri = %req.uri(),
-        proxy_uri = %proxy_uri,
-        "proxying request"
-    );
-
-    *req.uri_mut() = proxy_uri.parse().map_err(|e| {
-        error!("failed to parse proxy URI: {}", e);
-        RoutingError::BadRequest
-    })?;
-
-    let response = state.client.request(req).await.map_err(|e| {
-        error!("proxy request failed: {}", e);
-        RoutingError::ProxyError
-    })?;
-
-    Ok(response.map(Body::new))
-}
-
-enum RoutingError {
-    BadRequest,
-    ProxyError,
-}
-
-impl IntoResponse for RoutingError {
-    fn into_response(self) -> Response {
-        let (status, message) = match self {
-            RoutingError::BadRequest => (StatusCode::BAD_REQUEST, "Bad request"),
-            RoutingError::ProxyError => (StatusCode::BAD_GATEWAY, "Proxy error"),
-        };
-        (status, message).into_response()
-    }
-}

Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,6 @@ async fn main() -> Result<()> {`
`61`	`61`	`};`
`62`	`62`
`63`	`63`	`info!("will proxy requests to port: {}", http_port);`
`64`		`-`
`65`		`- server::serve(&http_addr, http_port).await?;`
	`64`	`+ server::proxy(&http_addr, http_port).await?;`
`66`	`65`	`Ok(())`
`67`	`66`	`}`