feat: add Start/Stop workspaces command

Author: batleforc

apps/dev_cli/src/workspace/mod.rs

@@ -4,6 +4,9 @@ use helper::Helper;
 pub mod get;
 pub mod get_container;
 pub mod list;
+pub mod restart;
+pub mod start;
+pub mod stop;
 
 #[derive(Debug, Clone, ValueEnum)]
 pub enum Format {
@@ -37,9 +40,17 @@ pub enum Workspace {
         format: Option<Format>,
     },
     /// Start a workspace by name
-    Start {},
+    Start {
+        /// Wait for the workspace to be started
+        #[arg(long)]
+        wait: bool,
+    },
     /// Stop a workspace by name
-    Stop {},
+    Stop {
+        /// Wait for the workspace to be stopped
+        #[arg(long)]
+        wait: bool,
+    },
     /// Restart a workspace by name
     Restart {
         /// Wait for the workspace to be started
@@ -67,14 +78,14 @@ impl Workspace {
             Workspace::List { format } => {
                 self::Workspace::list(info, format.clone()).await;
             }
-            Workspace::Start {} => {
-                println!("Start workspace");
+            Workspace::Start { wait } => {
+                self::Workspace::start(info, *wait).await;
             }
-            Workspace::Stop {} => {
-                println!("Stop workspace");
+            Workspace::Stop { wait } => {
+                self::Workspace::stop(info, *wait).await;
             }
             Workspace::Restart { wait } => {
-                println!("Restart workspace");
+                self::Workspace::restart(*wait, info).await;
             }
         }
     }

apps/dev_cli/src/workspace/restart.rs

@@ -0,0 +1,70 @@
+use crd::dev_work_space::DevWorkspace;
+use devfile::lifecycle::{start_stop::start_stop_devworkspace, wait_for_status::wait_for_status};
+use helper::{base_info::BaseInfo, Helper};
+
+use super::Workspace;
+impl Workspace {
+    #[tracing::instrument(level = "trace")]
+    pub async fn restart(wait: bool, base_info: BaseInfo) {
+        tracing::info!("Restarting workspace");
+        let client = match Helper::get_client().await {
+            Some(iencli) => iencli,
+            None => return,
+        };
+        if start_stop_devworkspace(
+            client.clone(),
+            base_info.workspace_name.clone().unwrap(),
+            base_info.namespace.clone(),
+            false,
+        )
+        .await
+        .is_none()
+        {
+            tracing::error!("Could not restart workspace");
+            return;
+        }
+        tracing::info!("Waiting for workspace to stop");
+        let devworkspace_api =
+            Helper::get_api::<DevWorkspace>(client.clone(), base_info.namespace.clone());
+        if wait_for_status(
+            devworkspace_api.clone(),
+            base_info.workspace_name.clone().unwrap(),
+            "Stopped".to_string(),
+            2000,
+            150, // Fail after 5 minutes
+        )
+        .await
+        .is_none()
+        {
+            return;
+        }
+        if start_stop_devworkspace(
+            client.clone(),
+            base_info.workspace_name.clone().unwrap(),
+            base_info.namespace.clone(),
+            true,
+        )
+        .await
+        .is_some()
+        {
+            tracing::info!("Workspace restarting");
+        } else {
+            return;
+        }
+        if wait
+            && wait_for_status(
+                devworkspace_api.clone(),
+                base_info.workspace_name.clone().unwrap(),
+                "Running".to_string(),
+                2000,
+                150, // Fail after 5 minutes
+            )
+            .await
+            .is_some()
+        {
+            tracing::info!("Workspace restarted");
+        } else if !wait {
+            tracing::info!("Not Waiting for restart");
+        }
+    }
+}

apps/dev_cli/src/workspace/start.rs

@@ -0,0 +1,48 @@
+use crd::dev_work_space::DevWorkspace;
+use devfile::lifecycle::{start_stop::start_stop_devworkspace, wait_for_status::wait_for_status};
+use helper::{base_info::BaseInfo, Helper};
+
+use super::Workspace;
+
+impl Workspace {
+    #[tracing::instrument(level = "trace")]
+    pub async fn start(base_info: BaseInfo, wait: bool) {
+        tracing::info!("Starting workspace");
+        let client = match Helper::get_client().await {
+            Some(iencli) => iencli,
+            None => return,
+        };
+        if start_stop_devworkspace(
+            client.clone(),
+            base_info.workspace_name.clone().unwrap(),
+            base_info.namespace.clone(),
+            true,
+        )
+        .await
+        .is_some()
+        {
+            tracing::info!("Workspace starting");
+        } else {
+            return;
+        }
+        let devworkspace_api =
+            Helper::get_api::<DevWorkspace>(client.clone(), base_info.namespace.clone());
+        if wait
+            && wait_for_status(
+                devworkspace_api.clone(),
+                base_info.workspace_name.clone().unwrap(),
+                "Running".to_string(),
+                2000,
+                150, // Fail after 5 minutes
+            )
+            .await
+            .is_some()
+        {
+            tracing::info!("Workspace started");
+        } else if wait {
+            tracing::error!("Workspace did not start");
+        } else {
+            tracing::info!("Not waiting for workspace to start");
+        }
+    }
+}

apps/dev_cli/src/workspace/stop.rs

@@ -0,0 +1,48 @@
+use crd::dev_work_space::DevWorkspace;
+use devfile::lifecycle::{start_stop::start_stop_devworkspace, wait_for_status::wait_for_status};
+use helper::{base_info::BaseInfo, Helper};
+
+use super::Workspace;
+
+impl Workspace {
+    #[tracing::instrument(level = "trace")]
+    pub async fn stop(base_info: BaseInfo, wait: bool) {
+        tracing::info!("Stopping workspace");
+        let client = match Helper::get_client().await {
+            Some(iencli) => iencli,
+            None => return,
+        };
+        if start_stop_devworkspace(
+            client.clone(),
+            base_info.workspace_name.clone().unwrap(),
+            base_info.namespace.clone(),
+            false,
+        )
+        .await
+        .is_some()
+        {
+            tracing::info!("Workspace stopping");
+        } else {
+            return;
+        }
+        let devworkspace_api =
+            Helper::get_api::<DevWorkspace>(client.clone(), base_info.namespace.clone());
+        if wait
+            && wait_for_status(
+                devworkspace_api.clone(),
+                base_info.workspace_name.clone().unwrap(),
+                "Stopped".to_string(),
+                2000,
+                150, // Fail after 5 minutes
+            )
+            .await
+            .is_some()
+        {
+            tracing::info!("Workspace stopped");
+        } else if wait {
+            tracing::error!("Workspace did not stop");
+        } else {
+            tracing::info!("Not waiting for workspace to stop");
+        }
+    }
+}