feat: canister show works in global mode (#174)

Author: raymondk

crates/icp-cli/src/commands/args.rs

@@ -18,6 +18,11 @@ pub(crate) enum ArgValidationError {
     ))]
     AmbiguousCanisterName,
 
+    #[snafu(transparent)]
+    EnvironmentError {
+        source: crate::commands::GetEnvironmentError,
+    },
+
     #[snafu(transparent)]
     GetAgentForEnv {
         source: crate::commands::GetAgentForEnvError,
@@ -39,21 +44,62 @@ pub(crate) enum ArgValidationError {
     },
 }
 
+#[derive(Args, Debug)]
+pub(crate) struct CanisterEnvironmentArgs {
+    /// Name or principal of canister to target
+    /// When using a name an environment must be specified
+    pub(crate) canister: Canister,
+
+    /// Name of the target environment
+    #[arg(long)]
+    pub(crate) environment: Option<Environment>,
+}
+
 #[derive(Args, Debug)]
 pub(crate) struct CanisterCommandArgs {
-    /// Name of canister to target
+    // Note: Could have flattened CanisterEnvironmentArg to avoid adding child field
+    /// Name or principal of canister to target
+    /// When using a name an environment must be specified
     pub(crate) canister: Canister,
 
+    /// Name of the network to target
     #[arg(long)]
     pub(crate) network: Option<Network>,
 
+    /// Name of the target environment
     #[arg(long)]
     pub(crate) environment: Option<Environment>,
 
+    /// The identity to use for this request
     #[command(flatten)]
     pub(crate) identity: IdentityOpt,
 }
 
+impl CanisterEnvironmentArgs {
+    pub async fn get_cid_for_environment(
+        &self,
+        ctx: &Context,
+    ) -> Result<Principal, ArgValidationError> {
+        let arg_canister = self.canister.clone();
+        let arg_environment = self.environment.clone().unwrap_or_default();
+        let environment_name = arg_environment.name();
+
+        let principal = match arg_canister {
+            Canister::Name(canister_name) => {
+                ctx.get_canister_id_for_env(&canister_name, environment_name)
+                    .await?
+            }
+            Canister::Principal(principal) => {
+                // Make sure a valid environment was requested
+                let _ = ctx.get_environment(environment_name).await?;
+                principal
+            }
+        };
+
+        Ok(principal)
+    }
+}
+
 impl CanisterCommandArgs {
     pub async fn get_cid_and_agent(
         &self,
@@ -123,6 +169,15 @@ impl From<&str> for Canister {
     }
 }
 
+impl Display for Canister {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Canister::Name(n) => f.write_str(n),
+            Canister::Principal(principal) => f.write_str(&principal.to_string()),
+        }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub(crate) enum Network {
     Name(String),
@@ -176,7 +231,11 @@ impl Display for Environment {
 mod tests {
     use candid::Principal;
 
-    use crate::commands::args::{Canister, Network};
+    use super::*;
+    use icp::MockProjectLoader;
+    use std::sync::Arc;
+
+    use crate::{commands::args::Environment, store_id::MockInMemoryIdStore};
 
     #[test]
     fn canister_by_name() {
@@ -213,4 +272,49 @@ mod tests {
             Network::Url("http://www.example.com".to_string()),
         );
     }
+
+    #[tokio::test]
+    async fn test_get_cid_for_environment() {
+        use crate::store_id::{Access as IdAccess, Key};
+        use candid::Principal;
+
+        let ids_store = Arc::new(MockInMemoryIdStore::new());
+
+        // Register a canister ID for the dev environment
+        let canister_id = Principal::from_text("rrkah-fqaaa-aaaaa-aaaaq-cai").unwrap();
+        ids_store
+            .register(
+                &Key {
+                    network: "local".to_string(),
+                    environment: "dev".to_string(),
+                    canister: "backend".to_string(),
+                },
+                &canister_id,
+            )
+            .unwrap();
+
+        let ctx = Context {
+            project: Arc::new(MockProjectLoader::complex()),
+            ids: ids_store,
+            ..Context::mocked()
+        };
+
+        let args = CanisterEnvironmentArgs {
+            canister: Canister::Name("backend".to_string()),
+            environment: Some(Environment::Name("dev".to_string())),
+        };
+
+        assert!(matches!(args.get_cid_for_environment(&ctx).await, Ok(id) if id == canister_id));
+
+        let args = CanisterEnvironmentArgs {
+            canister: Canister::Name("INVALID".to_string()),
+            environment: Some(Environment::Name("dev".to_string())),
+        };
+
+        let res = args.get_cid_for_environment(&ctx).await;
+        assert!(
+            res.is_err(),
+            "An invalid canister name should result in an error"
+        );
+    }
 }

crates/icp-cli/src/commands/canister/mod.rs

@@ -16,19 +16,39 @@ pub(crate) mod top_up;
 
 #[derive(Debug, Subcommand)]
 pub(crate) enum Command {
+    /// Make a canister call
     Call(call::CallArgs),
+
+    /// Create a canister on a network
     Create(create::CreateArgs),
+
+    /// Delete a canister from a network
     Delete(delete::DeleteArgs),
+
+    /// Display a canister's information
     Info(info::InfoArgs),
+
+    /// Install a built WASM to a canister on a network
     Install(install::InstallArgs),
+
+    /// List the canisters in an environment
     List(list::ListArgs),
 
     #[command(subcommand)]
     Settings(settings::Command),
 
+    /// Show a canister's details
     Show(show::ShowArgs),
+
+    /// Start a canister on a network
     Start(start::StartArgs),
+
+    /// Show the status of a canister
     Status(status::StatusArgs),
+
+    /// Stop a canister on a network
     Stop(stop::StopArgs),
+
+    /// Top up a canister with cycles
     TopUp(top_up::TopUpArgs),
 }

crates/icp-cli/src/commands/canister/show.rs

@@ -1,66 +1,26 @@
 use clap::Args;
 
-use crate::{
-    commands::Context,
-    options::EnvironmentOpt,
-    store_id::{Key, LookupError as LookupIdError},
+use crate::commands::{
+    Context,
+    args::{ArgValidationError, CanisterEnvironmentArgs},
 };
 
 #[derive(Debug, Args)]
 pub(crate) struct ShowArgs {
-    /// The name of the canister within the current project
-    pub(crate) name: String,
-
     #[command(flatten)]
-    environment: EnvironmentOpt,
+    pub(crate) cmd_args: CanisterEnvironmentArgs,
 }
 
 #[derive(Debug, thiserror::Error)]
 pub(crate) enum CommandError {
     #[error(transparent)]
-    Project(#[from] icp::LoadError),
-
-    #[error("project does not contain an environment named '{name}'")]
-    EnvironmentNotFound { name: String },
-
-    #[error("environment '{environment}' does not include canister '{canister}'")]
-    EnvironmentCanister {
-        environment: String,
-        canister: String,
-    },
-
-    #[error(transparent)]
-    LookupCanisterId(#[from] LookupIdError),
+    Shared(#[from] ArgValidationError),
 }
 
 pub(crate) async fn exec(ctx: &Context, args: &ShowArgs) -> Result<(), CommandError> {
-    // Load project
-    let p = ctx.project.load().await?;
-
-    // Load target environment
-    let env =
-        p.environments
-            .get(args.environment.name())
-            .ok_or(CommandError::EnvironmentNotFound {
-                name: args.environment.name().to_owned(),
-            })?;
-
-    // Ensure canister is included in the environment
-    if !env.canisters.contains_key(&args.name) {
-        return Err(CommandError::EnvironmentCanister {
-            environment: env.name.to_owned(),
-            canister: args.name.to_owned(),
-        });
-    }
-
-    // Lookup the canister id
-    let cid = ctx.ids.lookup(&Key {
-        network: env.network.name.to_owned(),
-        environment: env.name.to_owned(),
-        canister: args.name.to_owned(),
-    })?;
+    let cid = args.cmd_args.get_cid_for_environment(ctx).await?;
 
-    println!("{cid} => {}", args.name);
+    println!("{cid} => {}", args.cmd_args.canister);
 
     // TODO(or.ricon): Show canister details
     //  Things we might want to show (do we need to sub-command this?)