Merge pull request #27 from msalinas92/feature/https-support

msalinas92 · web-flow · commit b130b1371958 · 2025-07-17T19:11:33.000-04:00
Feature/https support
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -61,6 +61,8 @@ tower = "0.5.2"
 tower-http = { version = "0.4", features = ["cors"] }
 rust-embed = "8.2.0"
 mime_guess = "2.0"
+hyper-tls = "0.5"
+url = "2"
 
 [dev-dependencies]
 tokio = { version = "1", features = ["macros", "rt-multi-thread", "test-util"] }
diff --git a/Dockerfile b/Dockerfile
@@ -4,4 +4,4 @@ ARG BINARY
 
 COPY --chmod=755 ${BINARY} /cachebolt
 
-ENTRYPOINT ["/cachebolt"]
+ENTRYPOINT ["/cachebolt"]
diff --git a/config.yaml b/config.yaml
@@ -53,4 +53,4 @@ latency_failover:
 # 🚫 List of request headers to ignore when computing cache keys (case-insensitive)
 ignored_headers:
   - postman-token
-  - if-none-match
+  - if-none-match
diff --git a/src/config.rs b/src/config.rs
@@ -58,6 +58,7 @@ pub struct LatencyFailover {
     pub default_max_latency_ms: u64,
 
     /// Specific path-based rules, applied in order.
+    #[serde(default)] // <--- Esto lo hace opcional en YAML y por defecto = []
     pub path_rules: Vec<MaxLatencyRule>,
 }
 
diff --git a/src/proxy.rs b/src/proxy.rs
@@ -14,6 +14,8 @@
 use axum::response::IntoResponse;
 use bytes::Bytes;
 use hyper::client::HttpConnector;
+use hyper_tls::HttpsConnector;
+type HttpsClient = Client<HttpsConnector<HttpConnector>>;
 use hyper::{Body, Client, Request, Response};
 use once_cell::sync::Lazy;
 use sha2::{Digest, Sha256};
@@ -47,10 +49,12 @@ pub static SEMAPHORE: Lazy<Arc<Semaphore>> =
     Lazy::new(|| Arc::new(Semaphore::new(*MAX_CONCURRENT_REQUESTS)));
 
 /// Shared HTTP client for all outbound requests
-static HTTP_CLIENT: Lazy<Client<HttpConnector>> = Lazy::new(Client::new);
+static HTTP_CLIENT: Lazy<HttpsClient> = Lazy::new(|| {
+    let https = HttpsConnector::new();
+    Client::builder().build::<_, Body>(https)
+});
 
 /// Background task that persistently writes cache entries to the configured backend
-
 static CACHE_WRITER: Lazy<mpsc::Sender<(String, Bytes, Vec<(String, String)>)>> = Lazy::new(|| {
     let (tx, mut rx) = mpsc::channel::<(String, Bytes, Vec<(String, String)>)>(100);
     tokio::spawn(async move {
@@ -82,6 +86,11 @@ pub async fn proxy_handler(req: Request<Body>) -> impl IntoResponse {
     let uri = req.uri().to_string();
     tracing::debug!("🔗 Received request for URI: {}", uri);
 
+    tracing::debug!("🔎 Incoming request headers:");
+    for (k, v) in req.headers().iter() {
+        tracing::debug!("    {}: {:?}", k, v);
+    }
+
     // Increment total request counter for each URI
     counter!("cachebolt_proxy_requests_total", "uri" => uri.clone()).increment(1);
 
@@ -169,9 +178,11 @@ pub async fn proxy_handler(req: Request<Body>) -> impl IntoResponse {
                     }
 
                     // Split response into parts
-                    let (parts, body) = resp.into_parts();
+                    let (mut parts, body) = resp.into_parts();
                     let body_bytes = hyper::body::to_bytes(body).await.unwrap_or_default();
 
+                    parts.headers.remove("content-length");
+
                     let headers_vec = parts
                         .headers
                         .iter()
@@ -210,7 +221,10 @@ pub async fn proxy_handler(req: Request<Body>) -> impl IntoResponse {
                             );
                         }
                     } else {
-                        tracing::info!("⏩ Cache bypass activated for '{}' due to client header", uri);
+                        tracing::info!(
+                            "⏩ Cache bypass activated for '{}' due to client header",
+                            uri
+                        );
                     }
 
                     Response::from_parts(parts, Body::from(body_bytes))
@@ -304,18 +318,58 @@ pub fn hash_uri(uri: &str) -> String {
 }
 
 /// Sends an outbound GET request to the downstream backend
+/// Sends an outbound GET request to the downstream backend, forwarding all headers except 'accept-encoding'.
+/// This prevents curl: (52) Empty reply from server errors caused by unsupported encodings.
+///
+/// # Arguments
+/// - `uri`: The path to append to the downstream base URL.
+/// - `original_req`: The incoming Axum request, from which headers are forwarded.
+///
+/// # Returns
+/// - `Ok(Response)` with the downstream response if successful.
+/// - `Err(())` if the downstream call fails or the request could not be built.
 pub async fn forward_request(uri: &str, original_req: Request<Body>) -> Result<Response<Body>, ()> {
+    // Get the config and build the downstream full URL
     let cfg = CONFIG.get().unwrap();
     let full_url = format!("{}{}", cfg.downstream_base_url, uri);
 
+    // Debug: Log the scheme, host, and path of the downstream URL
+    if let Ok(parsed_url) = url::Url::parse(&full_url) {
+        tracing::info!(
+            "🌐 Downstream request: scheme='{}' host='{}' path='{}'",
+            parsed_url.scheme(),
+            parsed_url.host_str().unwrap_or(""),
+            parsed_url.path()
+        );
+    }
+
+    // Parse downstream_base_url to extract the host (domain)
+    let downstream_host = url::Url::parse(&cfg.downstream_base_url)
+        .ok()
+        .and_then(|u| u.host_str().map(|s| s.to_string()))
+        .unwrap_or_else(|| "".to_string());
+
+    // Build the request, starting with the URL and GET method
     let mut builder = Request::builder().uri(full_url.clone()).method("GET");
 
-    // Clone headers from the original request
+    // Copy all headers from the incoming request,
+    // except for 'accept-encoding' and 'host'
+    // (We want to control the Host header for SNI/proxying, and avoid content-encoding issues.)
     for (key, value) in original_req.headers().iter() {
+        if key.as_str().eq_ignore_ascii_case("accept-encoding")
+            || key.as_str().eq_ignore_ascii_case("host")
+        {
+            continue;
+        }
         builder = builder.header(key, value);
     }
 
-    // Build the request
+    // Inject the Host header, if it was successfully extracted from the downstream_base_url
+    if !downstream_host.is_empty() {
+        builder = builder.header("Host", downstream_host);
+    }
+
+    // Build the final request object with empty body
     let req = match builder.body(Body::empty()) {
         Ok(req) => req,
         Err(e) => {
@@ -324,7 +378,7 @@ pub async fn forward_request(uri: &str, original_req: Request<Body>) -> Result<R
         }
     };
 
-    // Make the request without timeout
+    // Send the HTTP request to the downstream service
     match HTTP_CLIENT.request(req).await {
         Ok(resp) => Ok(resp),
         Err(e) => {

Original file line number	Diff line number	Diff line change
`@@ -4,4 +4,4 @@ ARG BINARY`
`4`	`4`
`5`	`5`	`COPY --chmod=755 ${BINARY} /cachebolt`
`6`	`6`
`7`		`-ENTRYPOINT ["/cachebolt"]`
	`7`	`+ENTRYPOINT ["/cachebolt"]`
Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,7 @@ pub struct LatencyFailover {`
`58`	`58`	`pub default_max_latency_ms: u64,`
`59`	`59`
`60`	`60`	`/// Specific path-based rules, applied in order.`
	`61`	`+ #[serde(default)] // <--- Esto lo hace opcional en YAML y por defecto = []`
`61`	`62`	`pub path_rules: Vec<MaxLatencyRule>,`
`62`	`63`	`}`
`63`	`64`