refine, tests

Author: Eric Swanson

.github/workflows/fmt.yml

@@ -4,6 +4,7 @@ on:
   push:
     branches:
       - main
+      - ens/sdk-2108-local-network
   pull_request:
 
 jobs:

.github/workflows/lint.yml

@@ -4,6 +4,7 @@ on:
   push:
     branches:
       - main
+      - ens/sdk-2108-local-network
   pull_request:
 
 jobs:

.github/workflows/test.yml

@@ -4,8 +4,17 @@ on:
   push:
     branches:
       - main
+      - ens/sdk-2108-local-network
   pull_request:
 
+env:
+  # When getting Rust dependencies, retry on network error:
+  CARGO_NET_RETRY: 10
+  # Use the local .curlrc
+  CURL_HOME: .
+  # Disable DFX telemetry
+  DFX_TELEMETRY: 'off'
+
 jobs:
   test:
     name: ${{ matrix.test }} on ${{ matrix.os }}

Cargo.lock

@@ -9,10 +9,11 @@ name = "icp"
 path = "src/main.rs"
 
 [dependencies]
-clap = { version = "4.5.38", features = ["derive"] }
+clap = { version = "4.5.35", features = ["derive"] }
 directories = { workspace = true }
 icp-network = { path = "../../lib/icp-network" }
 icp-support = { path = "../../lib/icp-support" }
+snafu = { workspace = true }
 tokio = { workspace = true }
 
 [dev-dependencies]

bin/icp-cli/Cargo.toml

@@ -1,4 +1,6 @@
+use crate::commands::network::NetworkCommandError;
 use clap::{Parser, Subcommand};
+use snafu::Snafu;
 
 mod network;
 
@@ -13,8 +15,15 @@ pub enum Subcmd {
     Network(network::Cmd),
 }
 
-pub async fn exec(cli: Cli) {
+#[derive(Debug, Snafu)]
+pub enum DispatchError {
+    #[snafu(transparent)]
+    Network { source: NetworkCommandError },
+}
+
+pub async fn dispatch(cli: Cli) -> Result<(), DispatchError> {
     match cli.subcommand {
-        Subcmd::Network(opts) => network::exec(opts).await,
+        Subcmd::Network(opts) => network::dispatch(opts).await?,
     }
+    Ok(())
 }

bin/icp-cli/src/commands.rs

@@ -1,5 +1,6 @@
-use crate::commands::{Cli, network};
+use crate::commands::network::run::RunNetworkError;
 use clap::{Parser, Subcommand};
+use snafu::Snafu;
 
 mod run;
 mod start;
@@ -13,12 +14,16 @@ pub struct Cmd {
 #[derive(Subcommand, Debug)]
 pub enum Subcmd {
     Run(run::Cmd),
-    Start(start::Cmd),
 }
 
-pub async fn exec(cmd: Cmd) {
+#[derive(Debug, Snafu)]
+pub enum NetworkCommandError {
+    #[snafu(transparent)]
+    Run { source: RunNetworkError },
+}
+pub async fn dispatch(cmd: Cmd) -> Result<(), NetworkCommandError> {
     match cmd.subcmd {
-        Subcmd::Run(cmd) => run::exec(cmd).await,
-        Subcmd::Start(cmd) => todo!(), // start::exec(cmd).await,
+        Subcmd::Run(cmd) => run::exec(cmd).await?,
     }
+    Ok(())
 }

bin/icp-cli/src/commands/network.rs

@@ -1,23 +1,38 @@
 use crate::project::structure::ProjectStructure;
 use clap::Parser;
 use icp_network::structure::NetworkDirectoryStructure;
-use icp_network::{ManagedNetworkModel, run_local_network};
-use icp_support::fs::create_dir_all;
+use icp_network::{ManagedNetworkModel, StartLocalNetworkError, run_local_network};
+use icp_support::fs::{CreateDirAllError, create_dir_all};
+use snafu::Snafu;
 
 #[derive(Parser, Debug)]
 pub struct Cmd {}
 
-pub async fn exec(cmd: Cmd) {
+#[derive(Debug, Snafu)]
+pub enum RunNetworkError {
+    #[snafu(display("Could not determine project structure"))]
+    ProjectStructureNotFound,
+
+    #[snafu(transparent)]
+    CreateDirFailed { source: CreateDirAllError },
+
+    #[snafu(transparent)]
+    NetworkExecutionFailed { source: StartLocalNetworkError },
+}
+
+pub async fn exec(cmd: Cmd) -> Result<(), RunNetworkError> {
     println!("Running network command");
 
     let config = ManagedNetworkModel::default();
-    let ps = ProjectStructure::find().unwrap();
+    let ps = ProjectStructure::find().ok_or(RunNetworkError::ProjectStructureNotFound)?;
     eprintln!("Project structure root: {}", ps.root().display());
     let network_root = ps.network_root("local");
-    create_dir_all(&network_root).unwrap();
+    create_dir_all(&network_root)?;
 
     eprintln!("Network root: {}", network_root.display());
 
     let nds = NetworkDirectoryStructure::new(&network_root);
-    run_local_network(config, nds).await.unwrap();
+    run_local_network(config, nds).await?;
+
+    Ok(())
 }

bin/icp-cli/src/commands/network/run.rs

@@ -11,5 +11,5 @@ async fn main() {
     println!("Hello, world!");
     let ps = ProjectStructure::find();
 
-    commands::exec(Cli::parse()).await;
+    commands::dispatch(Cli::parse()).await;
 }

bin/icp-cli/src/main.rs

@@ -1,5 +1,5 @@
-mod test_env;
-mod os;
 pub mod guard;
+mod os;
+mod test_env;
 
 pub use test_env::TestEnv;