v0.29.2

src/proxy/forward/response.rs

@@ -1,6 +1,12 @@
 {
     match upstream_result {
         Ok(Ok(mut response)) => {
+            if let Some(fallback) = execute_error_fallback(
+                state.clone(), peer, local, &snapshot, &host, tls, route,
+                response.status(), &fallback_request, &fallback_body,
+            ).await {
+                return fallback;
+            }
             let (origin_validation_headers, origin_plan, origin_reason, mut response) =
                 include!("success_prepare.rs");
             include!("success_finish.rs")
@@ -53,6 +59,12 @@
                     return stale;
                 }
             }
+            if let Some(fallback) = execute_error_fallback(
+                state.clone(), peer, local, &snapshot, &host, tls, route,
+                status, &fallback_request, &fallback_body,
+            ).await {
+                return fallback;
+            }
             let mut response = error(
                 status,
                 if status == StatusCode::SERVICE_UNAVAILABLE {
@@ -95,6 +107,12 @@
                     return stale;
                 }
             }
+            if let Some(fallback) = execute_error_fallback(
+                state.clone(), peer, local, &snapshot, &host, tls, route,
+                StatusCode::GATEWAY_TIMEOUT, &fallback_request, &fallback_body,
+            ).await {
+                return fallback;
+            }
             error(
                 StatusCode::GATEWAY_TIMEOUT,
                 "RustProxy: upstream response deadline exceeded\n",

src/proxy/forward/route_cache.rs

@@ -39,6 +39,12 @@ if route.unavailable {
     response
         .headers_mut()
         .insert("retry-after", HeaderValue::from_static("1"));
+    if let Some(fallback) = execute_error_fallback(
+        state.clone(), peer, local, &snapshot, &host, tls, route,
+        response.status(), &fallback_request, &fallback_body,
+    ).await {
+        return fallback;
+    }
     return response;
 }
 if let crate::config::CompiledSource::WebServer(service) = &route.source {
@@ -88,6 +94,12 @@ if let crate::config::CompiledSource::WebServer(service) = &route.source {
         },
     )
     .await;
+    if let Some(fallback) = execute_error_fallback(
+        state.clone(), peer, local, &snapshot, &host, tls, route,
+        response.status(), &fallback_request, &fallback_body,
+    ).await {
+        return fallback;
+    }
     response.extensions_mut().insert(StaticSourceResponse);
     return response;
 }
@@ -108,6 +120,12 @@ let (backend, backend_lease, affinity_cookie) = if let Some(pool) = &route.pool
             response
                 .headers_mut()
                 .insert("retry-after", HeaderValue::from_static("1"));
+            if let Some(fallback) = execute_error_fallback(
+                state.clone(), peer, local, &snapshot, &host, tls, route,
+                response.status(), &fallback_request, &fallback_body,
+            ).await {
+                return fallback;
+            }
             return response;
         }
         Err(crate::balance::SelectionFailure::Capacity) => {
@@ -118,6 +136,12 @@ let (backend, backend_lease, affinity_cookie) = if let Some(pool) = &route.pool
             response
                 .headers_mut()
                 .insert("retry-after", HeaderValue::from_static("1"));
+            if let Some(fallback) = execute_error_fallback(
+                state.clone(), peer, local, &snapshot, &host, tls, route,
+                response.status(), &fallback_request, &fallback_body,
+            ).await {
+                return fallback;
+            }
             return response;
         }
     };
@@ -128,10 +152,17 @@ let (backend, backend_lease, affinity_cookie) = if let Some(pool) = &route.pool
     )
 } else {
     let Some(backend) = route.backend.clone() else {
-        return error(
+        let response = error(
             StatusCode::INTERNAL_SERVER_ERROR,
             "RustProxy: Reverse Proxy route has no backend\n",
         );
+        if let Some(fallback) = execute_error_fallback(
+            state.clone(), peer, local, &snapshot, &host, tls, route,
+            response.status(), &fallback_request, &fallback_body,
+        ).await {
+            return fallback;
+        }
+        return response;
     };
     (backend, None, None)
 };