Add function to get all deployment pods including terminating

Author: secus

src/handlers/logs.rs

@@ -83,6 +83,37 @@ pub async fn get_deployment_pods(
     // Found pods for deployment
     Ok(Json(PodsResponse { pods }))
 }
+
+/// Get all pods for deployment including terminating ones (for debugging)
+pub async fn get_deployment_pods_debug(
+    State(state): State<AppState>,
+    Path(deployment_id): Path<Uuid>,
+    user: AuthUser,
+) -> Result<Json<PodsResponse>, AppError> {
+    // Verify deployment ownership
+    if !verify_deployment_ownership(&state, deployment_id, user.user_id).await? {
+        error!("User {} does not own deployment {}", user.user_id, deployment_id);
+        return Err(AppError::not_found("Deployment not found"));
+    }
+
+    let k8s_service = KubernetesService::for_deployment(&deployment_id, &user.user_id).await?;
+
+    let k8s_pods: Vec<crate::services::kubernetes::PodInfo> = k8s_service.get_deployment_pods_all(&deployment_id).await?;
+    
+    // Convert from k8s PodInfo to our response PodInfo
+    let pods: Vec<PodInfo> = k8s_pods.into_iter().map(|pod| PodInfo {
+        name: pod.name,
+        status: pod.status,
+        ready: pod.ready,
+        restart_count: pod.restart_count,
+        node_name: pod.node_name,
+        created_at: pod.created_at,
+    }).collect();
+
+    // Found all pods for deployment (including terminating)
+    Ok(Json(PodsResponse { pods }))
+}
+
 pub async fn get_pod_logs(
     State(state): State<AppState>,
     Path((deployment_id, pod_name)): Path<(Uuid, String)>,

src/services/kubernetes.rs

@@ -1350,13 +1350,23 @@ async fn detect_cluster_type(&self) -> Result<String, AppError> {
 
     let mut pod_infos = Vec::new();
     for pod in pod_list.items {
+        // Skip pods that are marked for deletion (Terminating state)
+        if pod.metadata.deletion_timestamp.is_some() {
+            continue;
+        }
+
         if let Some(name) = &pod.metadata.name {
             let status = if let Some(pod_status) = &pod.status {
                 pod_status.phase.clone().unwrap_or_else(|| "Unknown".to_string())
             } else {
                 "Unknown".to_string()
             };
 
+            // Only include pods that are not in Terminating state
+            if status == "Terminating" {
+                continue;
+            }
+
             let ready = if let Some(pod_status) = &pod.status {
                 pod_status.container_statuses
                     .as_ref()
@@ -1387,6 +1397,65 @@ async fn detect_cluster_type(&self) -> Result<String, AppError> {
 
     Ok(pod_infos)
 }
+
+/// Get all pods for deployment including terminating ones (for debugging)
+pub async fn get_deployment_pods_all(&self, deployment_id: &Uuid) -> Result<Vec<PodInfo>, AppError> {
+    use k8s_openapi::api::core::v1::Pod;
+    use kube::api::{Api, ListParams};
+
+    let pods: Api<Pod> = Api::namespaced(self.client.clone(), &self.namespace);
+    let lp = ListParams::default().labels(&format!("deployment-id={}", deployment_id));
+
+    let pod_list = pods
+        .list(&lp)
+        .await
+        .map_err(|e| AppError::internal(&format!("Failed to list pods: {}", e)))?;
+
+    let mut pod_infos = Vec::new();
+    for pod in pod_list.items {
+        if let Some(name) = &pod.metadata.name {
+            let status = if let Some(pod_status) = &pod.status {
+                // Check if pod is marked for deletion
+                if pod.metadata.deletion_timestamp.is_some() {
+                    "Terminating".to_string()
+                } else {
+                    pod_status.phase.clone().unwrap_or_else(|| "Unknown".to_string())
+                }
+            } else {
+                "Unknown".to_string()
+            };
+
+            let ready = if let Some(pod_status) = &pod.status {
+                pod_status.container_statuses
+                    .as_ref()
+                    .map(|statuses| statuses.iter().all(|cs| cs.ready))
+                    .unwrap_or(false)
+            } else {
+                false
+            };
+
+            pod_infos.push(PodInfo {
+                name: name.clone(),
+                status,
+                ready,
+                restart_count: if let Some(pod_status) = &pod.status {
+                    pod_status.container_statuses
+                        .as_ref()
+                        .map(|statuses| statuses.iter().map(|cs| cs.restart_count).sum())
+                        .unwrap_or(0)
+                } else {
+                    0
+                },
+                node_name: pod.spec.as_ref().and_then(|s| s.node_name.clone()),
+                created_at: pod.metadata.creation_timestamp
+                    .map(|ts| ts.0.format("%Y-%m-%d %H:%M:%S UTC").to_string()),
+            });
+        }
+    }
+
+    Ok(pod_infos)
+}
+
 pub async fn get_pod_logs(
     &self,
     pod_name: &str,