chore: Clean up cloud-unsafe-op logic in admin-cli

crates/admin-cli/src/cfg/runtime.rs

@@ -18,6 +18,7 @@
 use rpc::admin_cli::OutputFormat;
 
 use crate::cfg::cli_options::SortField;
+use crate::errors::CarbideCliError;
 use crate::rpc::ApiClient;
 
 // RuntimeContext is context passed to all subcommand
@@ -36,6 +37,15 @@ pub struct RuntimeConfig {
     pub format: OutputFormat,
     pub page_size: usize,
     pub extended: bool,
-    pub cloud_unsafe_op_enabled: bool,
+    pub cloud_unsafe_op: Option<String>,
     pub sort_by: SortField,
 }
+
+impl RuntimeContext {
+    pub fn assert_cloud_unsafe_op_message(&self) -> Result<&str, CarbideCliError> {
+        self.config
+            .cloud_unsafe_op
+            .as_deref()
+            .ok_or(CarbideCliError::CloudUnsafeOp)
+    }
+}

crates/admin-cli/src/errors.rs

@@ -36,6 +36,9 @@ pub enum CarbideCliError {
     #[error("Generic Error: {0}")]
     GenericError(String),
 
+    #[error("Operation not allowed due to potential inconsistencies with cloud database.")]
+    CloudUnsafeOp,
+
     #[error("Cannot specify both {0} and {1}. Please provide only one.")]
     ChooseOneError(&'static str, &'static str),
 

crates/admin-cli/src/instance/allocate/cmd.rs

@@ -18,22 +18,17 @@
 use std::collections::VecDeque;
 
 use super::args::Args;
+use crate::cfg::runtime::RuntimeContext;
 use crate::errors::{CarbideCliError, CarbideCliResult};
-use crate::instance::common::GlobalOptions;
 use crate::machine;
 use crate::rpc::ApiClient;
 
 pub async fn allocate(
     api_client: &ApiClient,
     allocate_request: Args,
-    opts: GlobalOptions<'_>,
+    ctx: &RuntimeContext,
 ) -> CarbideCliResult<()> {
-    if opts.cloud_unsafe_op.is_none() {
-        return Err(CarbideCliError::GenericError(
-            "Operation not allowed due to potential inconsistencies with cloud database."
-                .to_owned(),
-        ));
-    }
+    let unsafe_op_msg = ctx.assert_cloud_unsafe_op_message()?;
 
     let number = allocate_request.number.unwrap_or(1);
 
@@ -87,7 +82,7 @@ pub async fn allocate(
                     machine,
                     &allocate_request,
                     &format!("{}_{}", allocate_request.prefix_name, i),
-                    opts.cloud_unsafe_op.clone(),
+                    Some(unsafe_op_msg.to_string()),
                 )
                 .await?;
             requests.push(request);
@@ -127,7 +122,7 @@ pub async fn allocate(
                     machine,
                     &allocate_request,
                     &format!("{}_{}", allocate_request.prefix_name, i),
-                    opts.cloud_unsafe_op.clone(),
+                    Some(unsafe_op_msg.to_string()),
                 )
                 .await
             {

crates/admin-cli/src/instance/allocate/mod.rs

@@ -20,24 +20,13 @@ pub mod cmd;
 
 pub use args::Args;
 
-use super::common::GlobalOptions;
 use crate::cfg::run::Run;
 use crate::cfg::runtime::RuntimeContext;
 use crate::errors::CarbideCliResult;
 
 impl Run for Args {
     async fn run(self, ctx: &mut RuntimeContext) -> CarbideCliResult<()> {
-        let opts = GlobalOptions {
-            format: ctx.config.format,
-            page_size: ctx.config.page_size,
-            sort_by: &ctx.config.sort_by,
-            cloud_unsafe_op: if ctx.config.cloud_unsafe_op_enabled {
-                Some("enabled".to_string())
-            } else {
-                None
-            },
-        };
-        cmd::allocate(&ctx.api_client, self, opts).await?;
+        cmd::allocate(&ctx.api_client, self, ctx).await?;
         Ok(())
     }
 }

crates/admin-cli/src/instance/mod.rs

@@ -16,7 +16,6 @@
  */
 
 mod allocate;
-pub(crate) mod common;
 mod reboot;
 mod release;
 mod show;

crates/admin-cli/src/instance/release/cmd.rs

@@ -19,21 +19,16 @@ use ::rpc::forge::InstanceReleaseRequest;
 use carbide_uuid::instance::InstanceId;
 
 use super::args::Args;
+use crate::cfg::runtime::RuntimeContext;
 use crate::errors::{CarbideCliError, CarbideCliResult};
-use crate::instance::common::GlobalOptions;
 use crate::rpc::ApiClient;
 
 pub async fn release(
     api_client: &ApiClient,
     release_request: Args,
-    opts: GlobalOptions<'_>,
+    ctx: &RuntimeContext,
 ) -> CarbideCliResult<()> {
-    if opts.cloud_unsafe_op.is_none() {
-        return Err(CarbideCliError::GenericError(
-            "Operation not allowed due to potential inconsistencies with cloud database."
-                .to_owned(),
-        ));
-    }
+    ctx.assert_cloud_unsafe_op_message()?;
 
     let mut instance_ids: Vec<InstanceId> = Vec::new();
 
@@ -64,7 +59,7 @@ pub async fn release(
                     Some(key),
                     release_request.label_value,
                     None,
-                    opts.page_size,
+                    ctx.config.page_size,
                 )
                 .await?;
             if instances.instances.is_empty() {

crates/admin-cli/src/instance/release/mod.rs

@@ -20,24 +20,13 @@ pub mod cmd;
 
 pub use args::Args;
 
-use super::common::GlobalOptions;
 use crate::cfg::run::Run;
 use crate::cfg::runtime::RuntimeContext;
 use crate::errors::CarbideCliResult;
 
 impl Run for Args {
     async fn run(self, ctx: &mut RuntimeContext) -> CarbideCliResult<()> {
-        let opts = GlobalOptions {
-            format: ctx.config.format,
-            page_size: ctx.config.page_size,
-            sort_by: &ctx.config.sort_by,
-            cloud_unsafe_op: if ctx.config.cloud_unsafe_op_enabled {
-                Some("enabled".to_string())
-            } else {
-                None
-            },
-        };
-        cmd::release(&ctx.api_client, self, opts).await?;
+        cmd::release(&ctx.api_client, self, ctx).await?;
         Ok(())
     }
 }

crates/admin-cli/src/instance/show/cmd.rs

@@ -28,6 +28,7 @@ use prettytable::{Table, row};
 
 use super::args::Args;
 use crate::cfg::cli_options::SortField;
+use crate::cfg::runtime::RuntimeContext;
 use crate::errors::{CarbideCliError, CarbideCliResult};
 use crate::rpc::ApiClient;
 use crate::{async_write, async_writeln, invalid_machine_id};
@@ -484,27 +485,21 @@ async fn show_instance_details(
     Ok(())
 }
 
-pub async fn handle_show(
-    args: Args,
-    output_file: &mut Box<dyn tokio::io::AsyncWrite + Unpin>,
-    output_format: &OutputFormat,
-    api_client: &ApiClient,
-    page_size: usize,
-    sort_by: &SortField,
-) -> CarbideCliResult<()> {
+pub async fn handle_show(args: Args, ctx: &mut RuntimeContext) -> CarbideCliResult<()> {
     if args.id.is_empty() {
-        let mut all_instances = api_client
+        let mut all_instances = ctx
+            .api_client
             .get_all_instances(
                 args.tenant_org_id,
                 args.vpc_id,
                 args.label_key,
                 args.label_value,
                 args.instance_type_id,
-                page_size,
+                ctx.config.page_size,
             )
             .await?;
 
-        match sort_by {
+        match ctx.config.sort_by {
             SortField::PrimaryId => all_instances.instances.sort_by_key(|instance| instance.id),
             SortField::State => all_instances.instances.sort_by(|i1, i2| {
                 let tenant_status1 = i1
@@ -524,17 +519,17 @@ pub async fn handle_show(
                 tenant_status1.cmp(&tenant_status2)
             }),
         }
-        match output_format {
+        match ctx.config.format {
             OutputFormat::Json => {
                 async_writeln!(
-                    output_file,
+                    ctx.output_file,
                     "{}",
                     serde_json::to_string_pretty(&all_instances)?
                 )?;
             }
             OutputFormat::AsciiTable => {
                 let table = convert_instances_to_nice_table(all_instances);
-                async_write!(output_file, "{}", table)?;
+                async_write!(ctx.output_file, "{}", table)?;
             }
             OutputFormat::Csv => {
                 return Err(CarbideCliError::NotImplemented(
@@ -551,9 +546,9 @@ pub async fn handle_show(
     }
     show_instance_details(
         args.id,
-        output_file,
-        output_format,
-        api_client,
+        &mut ctx.output_file,
+        &ctx.config.format,
+        &ctx.api_client,
         args.extrainfo,
     )
     .await?;

crates/admin-cli/src/instance/show/mod.rs

@@ -20,32 +20,13 @@ pub mod cmd;
 
 pub use args::Args;
 
-use super::common::GlobalOptions;
 use crate::cfg::run::Run;
 use crate::cfg::runtime::RuntimeContext;
 use crate::errors::CarbideCliResult;
 
 impl Run for Args {
     async fn run(self, ctx: &mut RuntimeContext) -> CarbideCliResult<()> {
-        let opts = GlobalOptions {
-            format: ctx.config.format,
-            page_size: ctx.config.page_size,
-            sort_by: &ctx.config.sort_by,
-            cloud_unsafe_op: if ctx.config.cloud_unsafe_op_enabled {
-                Some("enabled".to_string())
-            } else {
-                None
-            },
-        };
-        cmd::handle_show(
-            self,
-            &mut ctx.output_file,
-            &opts.format,
-            &ctx.api_client,
-            opts.page_size,
-            opts.sort_by,
-        )
-        .await?;
+        cmd::handle_show(self, ctx).await?;
         Ok(())
     }
 }

crates/admin-cli/src/instance/update_ib_config/cmd.rs

@@ -14,23 +14,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 use super::args::Args;
-use crate::errors::{CarbideCliError, CarbideCliResult};
-use crate::instance::common::GlobalOptions;
+use crate::cfg::runtime::RuntimeContext;
+use crate::errors::CarbideCliResult;
 use crate::rpc::ApiClient;
 
 pub async fn update_ib_config(
     api_client: &ApiClient,
     update_request: Args,
-    opts: GlobalOptions<'_>,
+    ctx: &RuntimeContext,
 ) -> CarbideCliResult<()> {
-    if opts.cloud_unsafe_op.is_none() {
-        return Err(CarbideCliError::GenericError(
-            "Operation not allowed due to potential inconsistencies with cloud database."
-                .to_owned(),
-        ));
-    }
+    let unsafe_op_msg = ctx.assert_cloud_unsafe_op_message()?;
 
     match api_client
         .update_instance_config_with(
@@ -39,7 +33,7 @@ pub async fn update_ib_config(
                 config.infiniband = Some(update_request.config);
             },
             |_metadata| {},
-            opts.cloud_unsafe_op,
+            Some(unsafe_op_msg.to_string()),
         )
         .await
     {

crates/admin-cli/src/instance/update_ib_config/mod.rs

@@ -20,24 +20,13 @@ pub mod cmd;
 
 pub use args::Args;
 
-use super::common::GlobalOptions;
 use crate::cfg::run::Run;
 use crate::cfg::runtime::RuntimeContext;
 use crate::errors::CarbideCliResult;
 
 impl Run for Args {
     async fn run(self, ctx: &mut RuntimeContext) -> CarbideCliResult<()> {
-        let opts = GlobalOptions {
-            format: ctx.config.format,
-            page_size: ctx.config.page_size,
-            sort_by: &ctx.config.sort_by,
-            cloud_unsafe_op: if ctx.config.cloud_unsafe_op_enabled {
-                Some("enabled".to_string())
-            } else {
-                None
-            },
-        };
-        cmd::update_ib_config(&ctx.api_client, self, opts).await?;
+        cmd::update_ib_config(&ctx.api_client, self, ctx).await?;
         Ok(())
     }
 }