fix: ensure PipelineRun deletion in all scenarios

Author: wangeguo

src/handler/webhook.rs

@@ -15,16 +15,15 @@
 use axum::{Json, extract::State, http::StatusCode, response::IntoResponse};
 use gitea_client::types::Event;
 use std::sync::Arc;
-use uuid::Uuid;
-
 use tracing::{debug, error, info};
+use uuid::Uuid;
 
 use crate::{
     context::Context,
     errors::{ApiError, Result},
     repository::CourseRepository,
     request::event::PipelineEvent,
-    service::{PipelineService, RepoService, StageService},
+    service::{PipelineCleanupGuard, RepoService, StageService},
     utils::crypto,
 };
 
@@ -55,24 +54,25 @@ pub async fn handle_tekton_webhook(
     debug!("Received pipeline event: {:?}", event);
     let PipelineEvent { name, status, repo, course, stage, secret, tasks } = &event;
 
+    // Create cleanup guard - will delete pipeline when this function exits
+    let _cleanup_guard = PipelineCleanupGuard::new(ctx.clone(), name);
+
     // Verify HMAC signature to prevent request forgery
     let auth_secret = &ctx.config.auth_secret;
     let payload = format!("{}{}{}", repo, course, stage);
+
     if crypto::hmac_sha256_verify(&payload, auth_secret, secret)? {
         error!("Received pipeline event with invalid signature");
         return Err(ApiError::Unauthorized("Invalid signature".into()));
     }
 
     // Check overall pipeline status first
     if status != "Succeeded" {
-        error!("Pipeline run failed, please check it.");
+        error!("Pipeline run failed, please check it");
         return Ok(StatusCode::OK);
     }
 
-    // Process the pipeline event based on test task status:
-    // - If succeeded: mark the stage as complete for the user
-    // - If failed: log error (TODO: collect error details from Tekton and save to database)
-    // - Other states: log and ignore non-terminal states
+    // Process the pipeline event based on test task status
     match tasks.test.status.as_str() {
         "Succeeded" => {
             // Look up the course to get the user_id
@@ -85,21 +85,14 @@ pub async fn handle_tekton_webhook(
         }
         "Failed" => {
             info!("Test task failed: reason={}, stage={}", tasks.test.reason, stage);
-            return Ok(StatusCode::OK);
         }
         _ => {
             error!(
                 "Test task in non-terminal state: status={}, reason={}",
                 tasks.test.status, tasks.test.reason
             );
-            return Ok(StatusCode::OK);
         }
     }
 
-    // Delete the PipelineRun after successful processing
-    if let Err(e) = PipelineService::new(ctx.clone()).delete(name).await {
-        error!("Failed to delete PipelineRun {}: {}", name, e);
-    }
-
     Ok(StatusCode::OK)
 }

src/service/mod.rs

@@ -23,7 +23,7 @@ mod storage;
 // Re-exports
 pub use course::CourseService;
 pub use extension::ExtensionService;
-pub use pipeline::PipelineService;
+pub use pipeline::{PipelineCleanupGuard, PipelineService};
 pub use registry::RegistryService;
 pub use repository::RepoService;
 pub use stage::StageService;

src/service/pipeline.rs

@@ -19,7 +19,7 @@ use kube::{
     api::{ApiResource, DeleteParams, DynamicObject, GroupVersionKind, PostParams},
 };
 use serde_json::{Error as JsonError, Value, json};
-use tracing::debug;
+use tracing::{debug, error};
 use uuid::Uuid;
 
 use crate::{
@@ -183,3 +183,30 @@ where
 
     serde_json::from_value(resource)
 }
+
+// RAII guard to ensure PipelineRun deletion
+pub struct PipelineCleanupGuard<'a> {
+    name: &'a str,
+    ctx: Arc<Context>,
+}
+
+impl<'a> PipelineCleanupGuard<'a> {
+    /// Creates a new PipelineCleanupGuard
+    pub fn new(ctx: Arc<Context>, name: &'a str) -> Self {
+        Self { name, ctx }
+    }
+}
+
+impl<'a> Drop for PipelineCleanupGuard<'a> {
+    fn drop(&mut self) {
+        let name = self.name.to_string();
+        let ctx = self.ctx.clone();
+
+        // Use tokio::spawn to handle async code in Drop
+        tokio::spawn(async move {
+            if let Err(e) = PipelineService::new(ctx).delete(&name).await {
+                error!("Failed to delete PipelineRun {}: {}", name, e);
+            }
+        });
+    }
+}