Test: instantiate new clients for every request.

Trying to figure out why I am getting the below error occasionally in gitea:

Delivery: Post "https://webhookbridge.fizz.buzz/hook": context deadline exceeded (Client.Timeout exceeded while awaiting headers)

Cargo.toml

@@ -38,7 +38,7 @@ default = ["local_trigger"]
 local_trigger = []
 
 [dependencies]
-axum = { version = "0.7.5", default-features = false, features = ["tokio", "http1", "http2", "json"] }
+axum = { version = "0.7.5", default-features = false, features = ["tokio", "http1", "json"] }
 base64 = "0.22.1"
 hmac = "0.12.1"
 http-body-util = "0.1.2"
@@ -62,7 +62,7 @@ inherits = "release"
 lto = true
 strip = "symbols"
 
-[profile.dev]
+[target.'cfg(target_os = "linux")'.profile.dev]
 codegen-backend = "cranelift"
 
 [profile.dev.package."*"]

src/lib.rs

@@ -63,7 +63,6 @@ pub async fn launch_server() -> Result<(), Box<dyn std::error::Error>> {
         .collect();
     tracing::debug!("Using repo whitelist: {:?}", allowed_repos);
 
-    let allowed_repos = HashSet::new();
     let app = Router::new()
         .route("/hook", post(hook))
         .layer(middleware::from_fn(verify_signature))
@@ -98,7 +97,7 @@ pub async fn local_trigger(payload: &str) -> Result<(), Box<dyn std::error::Erro
 
     let allowed_repos = std::env::var("WEBHOOK_BRIDGE_REPO_WHITELIST")
         .ok()
-        .unwrap_or_else(String::new);
+        .unwrap_or_default();
     let allowed_repos: HashSet<_> = allowed_repos
         .split(",")
         .filter(|s| !s.is_empty())

src/webhook.rs

@@ -42,24 +42,54 @@ pub(crate) async fn hook(
     debug!("REQ: {:?}", payload);
     match payload {
         HookRequest::Push(webhook_payload) => {
-            handle_push(
+            let kubernetes_client: kube::Client = kube::Client::try_default()
-                state.gitea,
-                state.kubernetes_client,
-                state.allowed_repos.borrow(),
-                webhook_payload,
-            )
                 .await
-            .expect("Failed to handle push event.");
+                .expect("Set KUBECONFIG to a valid kubernetes config.");
-            (
+
+            let gitea_api_root = std::env::var("WEBHOOK_BRIDGE_API_ROOT");
+            let gitea_api_token = std::env::var("WEBHOOK_BRIDGE_OAUTH_TOKEN");
+            let (gitea_api_root, gitea_api_token) = match (gitea_api_root, gitea_api_token) {
+                (Ok(r), Ok(t)) => (r, t),
+                _ => {
+                    return (
                         StatusCode::OK,
                         Json(HookResponse {
                             ok: true,
                             message: None,
                         }),
+                    );
+                }
+            };
+            let gitea = GiteaClient::new(gitea_api_root, gitea_api_token);
+
+            let push_result = handle_push(
+                gitea,
+                kubernetes_client,
+                state.allowed_repos.borrow(),
+                webhook_payload,
             )
+            .await;
+            match push_result {
+                Ok(_) => (
+                    StatusCode::OK,
+                    Json(HookResponse {
+                        ok: true,
+                        message: None,
+                    }),
+                ),
+                Err(_) => (
+                    // StatusCode::INTERNAL_SERVER_ERROR,
+                    StatusCode::OK,
+                    Json(HookResponse {
+                        ok: false,
+                        message: Some("Failed to handle push event.".to_string()),
+                    }),
+                ),
+            }
         }
         HookRequest::Unrecognized(payload) => (
-            StatusCode::BAD_REQUEST,
+            // StatusCode::BAD_REQUEST,
+            StatusCode::OK,
             Json(HookResponse {
                 ok: false,
                 message: Some(format!("unrecognized event type: {payload}")),
@@ -146,9 +176,9 @@ where
 }
 
 async fn check_hash(body: Bytes, secret: String, signature: Vec<u8>) -> Result<Bytes, Response> {
-    tracing::info!("Checking signature {:02x?}", signature.as_slice());
+    tracing::debug!("Checking signature {:02x?}", signature.as_slice());
-    tracing::info!("Using secret {:?}", secret);
+    // tracing::info!("Using secret {:?}", secret);
-    tracing::info!("and body {}", general_purpose::STANDARD.encode(&body));
+    tracing::debug!("and body {}", general_purpose::STANDARD.encode(&body));
     let mut mac = HmacSha256::new_from_slice(secret.as_bytes())
         .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()).into_response())?;
     mac.update(&body);