Merge pull request #160 from nookat-io/colima_engine_settings

[feat]: colima engine stop feature

Author: Almaz-KG

src-tauri/src/entities/engine/mod.rs

@@ -98,6 +98,14 @@ pub struct InstallationProgress {
     pub logs: Vec<String>,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ColimaEngineStopProgress {
+    pub step: String,
+    pub message: String,
+    pub percentage: u8,
+    pub logs: Vec<String>,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ColimaConfig {
     pub cpu: u8,

src-tauri/src/handlers/system/engine.rs

@@ -1,6 +1,6 @@
 use crate::entities::EngineStatus;
 use crate::entities::{ColimaConfig, InstallationMethod};
-use crate::services::engine::{install_colima, start_colima_vm};
+use crate::services::engine::{install_colima, start_colima_vm, stop_colima_vm};
 use crate::services::shell::{is_colima_available, is_homebrew_available};
 use crate::state::SharedEngineState;
 use tauri::State;
@@ -44,6 +44,13 @@ pub async fn start_colima_vm_command(
     start_colima_vm(&app, config).await
 }
 
+#[tauri::command]
+#[instrument(skip_all, err)]
+pub async fn stop_colima_vm_command(app: tauri::AppHandle) -> Result<(), String> {
+    info!("Stopping Colima VM");
+    stop_colima_vm(&app).await
+}
+
 #[tauri::command]
 #[instrument(skip_all, err)]
 pub async fn check_colima_availability(app: tauri::AppHandle) -> Result<bool, String> {

src-tauri/src/lib.rs

@@ -54,6 +54,7 @@ use crate::handlers::{
     start_colima_vm_command,
     start_container,
     start_engine_state_monitoring,
+    stop_colima_vm_command,
     stop_container,
     unpause_container,
     update_language,
@@ -197,6 +198,7 @@ pub fn run() {
             check_colima_availability,
             install_colima_command,
             start_colima_vm_command,
+            stop_colima_vm_command,
         ])
         .setup(|app| {
             let engine_state = SharedEngineState::new(app.app_handle().clone());

src-tauri/src/services/engine/linux.rs

@@ -23,6 +23,10 @@ pub async fn start_colima_vm(_app: &AppHandle, _config: ColimaConfig) -> Result<
     todo!("Colima is only implemented on macOS for now, other platforms are not supported yet");
 }
 
+pub async fn stop_colima_vm(app_handle: &AppHandle) -> Result<(), String> {
+    todo!("Colima is only implemented on macOS for now, other platforms are not supported yet");
+}
+
 #[instrument(skip_all, err)]
 pub async fn is_colima_available(_app: &AppHandle) -> Result<bool, String> {
     // Colima is only implemented on macOS for now, other platforms are not supported yet

src-tauri/src/services/engine/macos.rs

@@ -1,7 +1,9 @@
-use crate::entities::{ColimaConfig, InstallationMethod, InstallationProgress};
+use crate::entities::{
+    ColimaConfig, ColimaEngineStopProgress, InstallationMethod, InstallationProgress,
+};
 use crate::services::shell::{
     check_colima_status, get_docker_context_endpoints, install_packages_via_homebrew,
-    start_colima_with_config, validate_colima_startup,
+    start_colima_with_config, stop_colima, validate_colima_startup,
 };
 use bollard::Docker;
 use tauri::{AppHandle, Emitter};
@@ -225,6 +227,109 @@ pub async fn start_colima_vm(app_handle: &AppHandle, config: ColimaConfig) -> Re
     result
 }
 
+#[instrument(skip_all, err)]
+pub async fn stop_colima_vm(app_handle: &AppHandle) -> Result<(), String> {
+    debug!("Stopping Colima VM");
+
+    // Create a channel for progress updates
+    let (tx, mut rx) = mpsc::channel::<ColimaEngineStopProgress>(100);
+
+    // Clone the sender for the background task
+    let tx_clone = tx.clone();
+
+    // Clone the app_handle for use in the background task
+    let app_handle_clone = app_handle.clone();
+    let app_handle_for_events = app_handle.clone();
+
+    // Spawn the VM startup task
+    let vm_handle = tokio::spawn(async move {
+        let mut progress = ColimaEngineStopProgress {
+            step: "Stopping Colima VM...".to_string(),
+            message: "Stopping Colima virtual machine".to_string(),
+            percentage: 10,
+            logs: vec![],
+        };
+
+        // Send initial progress
+        let _ = tx_clone.send(progress.clone()).await;
+
+        // Step 1: Check if Colima is already running
+        progress.step = "Checking Colima status...".to_string();
+        progress.message = "Verifying current VM status".to_string();
+        progress.percentage = 20;
+        progress
+            .logs
+            .push("[INFO] Checking Colima status".to_string());
+        let _ = tx_clone.send(progress.clone()).await;
+
+        let status_result = check_colima_status(&app_handle_clone).await;
+        if let Ok(true) = status_result {
+            progress.step = "Colima VM is running".to_string();
+            progress.message = "Colima VM is running".to_string();
+            progress.percentage = 30;
+            progress
+                .logs
+                .push("[INFO] Colima VM is running".to_string());
+            let _ = tx_clone.send(progress.clone()).await;
+            return Ok(());
+        }
+
+        // Step 2: Stop Colima VM
+        progress.step = "Stopping VM...".to_string();
+        progress.message = "Stopping Colima virtual machine".to_string();
+        progress.percentage = 40;
+        progress.logs.push("[INFO] Stopping Colima VM".to_string());
+        let _ = tx_clone.send(progress.clone()).await;
+
+        let stop_result = stop_colima(&app_handle_clone).await;
+        if let Err(e) = &stop_result {
+            progress.step = "VM stop failed".to_string();
+            progress.message = format!("Failed to stop Colima VM: {}", e);
+            progress.percentage = 100;
+            progress.logs.push(format!("[ERROR] {}", e));
+            let _ = tx_clone.send(progress.clone()).await;
+            return Err(e.clone());
+        }
+        // Wait a bit for the VM to fully stop
+        tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
+
+        progress.step = "VM stop complete".to_string();
+        progress.message = "Colima VM is stopped successfully".to_string();
+        progress.percentage = 100;
+        progress
+            .logs
+            .push("[INFO] Colima VM stopped successfully".to_string());
+        let _ = tx_clone.send(progress.clone()).await;
+
+        Ok(())
+    });
+
+    // Handle progress updates and send them to the frontend
+    let app_handle_for_progress = app_handle.clone();
+    let _progress_handle = tokio::spawn(async move {
+        while let Some(progress) = rx.recv().await {
+            let _ = app_handle_for_progress.emit("vm-stop-progress", progress);
+        }
+    });
+
+    // Wait for VM stop to complete
+    let result = vm_handle
+        .await
+        .map_err(|e| format!("VM stop task failed: {}", e))?;
+
+    // Send completion event
+    match &result {
+        Ok(_) => {
+            let _ = app_handle_for_events.emit("vm-stop-complete", ());
+        }
+        Err(e) => {
+            let _ = app_handle_for_events.emit("vm-stop-error", e);
+        }
+    }
+
+    result
+}
+
 #[instrument(skip_all, err)]
 pub async fn connect_to_docker_using_different_contexts(app: &AppHandle) -> Result<Docker, String> {
     debug!("Trying to connect to Docker via different contexts");

src-tauri/src/services/engine/windows.rs

@@ -21,6 +21,10 @@ pub async fn start_colima_vm(_app: &AppHandle, _config: ColimaConfig) -> Result<
     todo!("Colima is only implemented on macOS for now, other platforms are not supported yet");
 }
 
+pub async fn stop_colima_vm(app_handle: &AppHandle) -> Result<(), String> {
+    todo!("Colima is only implemented on macOS for now, other platforms are not supported yet");
+}
+
 #[instrument(skip_all, err)]
 pub async fn is_colima_available(_app: &AppHandle) -> Result<bool, String> {
     // Colima is only implemented on macOS for now, other platforms are not supported yet

src-tauri/src/services/shell/macos.rs

@@ -211,6 +211,28 @@ pub async fn check_colima_status(app: &AppHandle) -> Result<bool, String> {
     Ok(status_text.contains("Running"))
 }
 
+#[instrument(skip_all, err)]
+pub async fn stop_colima(app: &AppHandle) -> Result<(), String> {
+    debug!("Stopping Colima");
+    debug!("Executing: colima stop");
+
+    let output = app
+        .shell()
+        .command("zsh")
+        .args(["-l", "-c", "colima stop"])
+        .output()
+        .await
+        .map_err(|e| format!("Failed to stop Colima: {}", e))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(format!("Failed to stop Colima: {}", stderr));
+    }
+
+    debug!("Colima stopped successfully");
+    Ok(())
+}
+
 /// Start Colima VM with configuration
 #[instrument(skip_all, err)]
 pub async fn start_colima_with_config(