Merge branch 'main' into spofford/identity-storage

adamspofford-dfinity · adamspofford-dfinity · commit 6ab4a17c09da · 2025-05-30T11:07:36.000-07:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/bin/icp-cli/Cargo.toml b/bin/icp-cli/Cargo.toml
@@ -9,13 +9,13 @@ name = "icp"
 path = "src/main.rs"
 
 [dependencies]
-ic-agent.workspace = true
 bip32.workspace = true
 camino.workspace = true
 clap.workspace = true
 dialoguer.workspace = true
 elliptic-curve.workspace = true
 hex.workspace = true
+ic-agent.workspace = true
 icp-dirs.workspace = true
 icp-fs.workspace = true
 icp-identity.workspace = true
diff --git a/bin/icp-cli/src/commands/network/run.rs b/bin/icp-cli/src/commands/network/run.rs
@@ -1,5 +1,8 @@
-use crate::commands::network::run::RunNetworkCommandError::ProjectStructureNotFound;
-use crate::project::structure::ProjectDirectoryStructure;
+use crate::project::directory::ProjectDirectory;
+use crate::{
+    commands::network::run::RunNetworkCommandError::ProjectNotFound,
+    project::directory::FindProjectError,
+};
 use clap::Parser;
 use icp_network::{ManagedNetworkModel, RunNetworkError, run_network};
 use snafu::Snafu;
@@ -10,21 +13,24 @@ pub struct Cmd {}
 
 pub async fn exec(_cmd: Cmd) -> Result<(), RunNetworkCommandError> {
     let config = ManagedNetworkModel::default();
-    let pds = ProjectDirectoryStructure::find().ok_or(ProjectStructureNotFound)?;
-    let nds = pds.network("local");
+    let pd = ProjectDirectory::find()?.ok_or(ProjectNotFound)?;
+    let nd = pd.network("local");
 
-    eprintln!("Project root: {}", pds.root().display());
-    eprintln!("Network root: {}", nds.network_root().display());
+    eprintln!("Project root: {}", pd.structure().root());
+    eprintln!("Network root: {}", nd.structure().network_root());
 
-    run_network(config, nds).await?;
+    run_network(config, nd).await?;
 
     Ok(())
 }
 
 #[derive(Debug, Snafu)]
 pub enum RunNetworkCommandError {
     #[snafu(display("no project (icp.yaml) found in current directory or its parents"))]
-    ProjectStructureNotFound,
+    ProjectNotFound,
+
+    #[snafu(transparent)]
+    FindProjectError { source: FindProjectError },
 
     #[snafu(transparent)]
     NetworkExecutionFailed { source: RunNetworkError },
diff --git a/bin/icp-cli/src/project.rs b/bin/icp-cli/src/project.rs
@@ -1 +1,2 @@
+pub mod directory;
 pub mod structure;
diff --git a/bin/icp-cli/src/project/directory.rs b/bin/icp-cli/src/project/directory.rs
@@ -0,0 +1,44 @@
+use crate::project::structure::ProjectDirectoryStructure;
+use camino::Utf8PathBuf;
+use icp_network::NetworkDirectory;
+use snafu::{ResultExt, Snafu};
+use std::io;
+
+pub struct ProjectDirectory {
+    structure: ProjectDirectoryStructure,
+}
+
+impl ProjectDirectory {
+    pub fn find() -> Result<Option<Self>, FindProjectError> {
+        let current_dir = Utf8PathBuf::try_from(std::env::current_dir().context(AccessSnafu)?)
+            .context(NonUtf8Snafu)?;
+        let mut path = current_dir.clone();
+        loop {
+            let structure = ProjectDirectoryStructure::new(&path);
+
+            if structure.project_yaml_path().exists() {
+                break Ok(Some(Self { structure }));
+            }
+            if !path.pop() {
+                break Ok(None);
+            }
+        }
+    }
+
+    pub fn structure(&self) -> &ProjectDirectoryStructure {
+        &self.structure
+    }
+
+    pub fn network(&self, network_name: &str) -> NetworkDirectory {
+        let network_root = self.structure.network_root(network_name);
+        NetworkDirectory::new(&network_root)
+    }
+}
+
+#[derive(Debug, Snafu)]
+pub enum FindProjectError {
+    #[snafu(display("project path is non-UTF-8"))]
+    NonUtf8 { source: camino::FromPathBufError },
+    #[snafu(display("failed to access current directory"))]
+    AccessError { source: io::Error },
+}
diff --git a/bin/icp-cli/src/project/structure.rs b/bin/icp-cli/src/project/structure.rs
@@ -1,40 +1,33 @@
-use icp_network::structure::NetworkDirectoryStructure;
-use std::path::PathBuf;
+use camino::{Utf8Path, Utf8PathBuf};
 
 pub struct ProjectDirectoryStructure {
-    root: PathBuf,
+    root: Utf8PathBuf,
 }
 
 impl ProjectDirectoryStructure {
-    pub fn find() -> Option<Self> {
-        let current_dir = std::env::current_dir().ok()?;
-        let mut path = current_dir.clone();
-        loop {
-            if path.join("icp.yaml").exists() {
-                break Some(Self { root: path });
-            }
-            if !path.pop() {
-                break None;
-            }
-        }
+    pub fn new(root: &Utf8Path) -> Self {
+        let root = root.to_path_buf();
+        Self { root }
     }
 
-    pub fn root(&self) -> &PathBuf {
+    pub fn root(&self) -> &Utf8PathBuf {
         &self.root
     }
 
+    pub fn project_yaml_path(&self) -> Utf8PathBuf {
+        self.root.join("icp.yaml")
+    }
+
     #[allow(dead_code)]
-    pub fn network_config_path(&self, name: &str) -> PathBuf {
+    pub fn network_config_path(&self, name: &str) -> Utf8PathBuf {
         self.root.join("networks").join(format!("{name}.yaml"))
     }
 
-    fn work_dir(&self) -> PathBuf {
+    fn work_dir(&self) -> Utf8PathBuf {
         self.root.join(".icp")
     }
 
-    pub fn network(&self, network_name: &str) -> NetworkDirectoryStructure {
-        let network_root = self.work_dir().join("networks").join(network_name);
-
-        NetworkDirectoryStructure::new(&network_root)
+    pub fn network_root(&self, network_name: &str) -> Utf8PathBuf {
+        self.work_dir().join("networks").join(network_name)
     }
 }
diff --git a/clippy.toml b/clippy.toml
@@ -0,0 +1,4 @@
+disallowed-types = [
+    { path = "std::path::PathBuf", replacement = "camino::Utf8PathBuf" },
+    { path = "std::path::Path", replacement = "camino::Utf8Path" },
+]
diff --git a/lib/icp-fs/Cargo.toml b/lib/icp-fs/Cargo.toml
@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+camino = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 snafu = { workspace = true }
diff --git a/lib/icp-fs/src/fs.rs b/lib/icp-fs/src/fs.rs
@@ -1,66 +1,70 @@
+use camino::{Utf8Path, Utf8PathBuf};
 use snafu::prelude::*;
-use std::path::{Path, PathBuf};
 
 #[derive(Snafu, Debug)]
-#[snafu(display("failed to create directory {} and parents", path.display()))]
+#[snafu(display("failed to create directory {path} and parents"))]
 pub struct CreateDirAllError {
-    pub path: PathBuf,
+    pub path: Utf8PathBuf,
     pub source: std::io::Error,
 }
 
-pub fn create_dir_all(path: impl AsRef<Path>) -> Result<(), CreateDirAllError> {
+pub fn create_dir_all(path: impl AsRef<Utf8Path>) -> Result<(), CreateDirAllError> {
     let path = path.as_ref();
     std::fs::create_dir_all(path).context(CreateDirAllSnafu { path })
 }
 
 #[derive(Snafu, Debug)]
-#[snafu(display("failed to read {}", path.display()))]
+#[snafu(display("failed to read {path}"))]
 pub struct ReadFileError {
-    pub path: PathBuf,
+    pub path: Utf8PathBuf,
     pub source: std::io::Error,
 }
 
-pub fn read<P: AsRef<Path>>(path: P) -> Result<Vec<u8>, ReadFileError> {
+pub fn read<P: AsRef<Utf8Path>>(path: P) -> Result<Vec<u8>, ReadFileError> {
     let path = path.as_ref();
     std::fs::read(path).context(ReadFileSnafu { path })
 }
 
-pub fn read_to_string<P: AsRef<Path>>(path: P) -> Result<String, ReadFileError> {
+pub fn read_to_string<P: AsRef<Utf8Path>>(path: P) -> Result<String, ReadFileError> {
     let path = path.as_ref();
     std::fs::read_to_string(path).context(ReadFileSnafu { path })
 }
 
 #[derive(Snafu, Debug)]
-#[snafu(display("failed to remove directory {} and contents", path.display()))]
+#[snafu(display("failed to remove directory {path} and contents"))]
 pub struct RemoveDirAllError {
-    pub path: PathBuf,
+    pub path: Utf8PathBuf,
     pub source: std::io::Error,
 }
 
-pub fn remove_dir_all(path: &Path) -> Result<(), RemoveDirAllError> {
+pub fn remove_dir_all(path: impl AsRef<Utf8Path>) -> Result<(), RemoveDirAllError> {
+    let path = path.as_ref();
     std::fs::remove_dir_all(path).context(RemoveDirAllSnafu { path })
 }
 
 #[derive(Snafu, Debug)]
-#[snafu(display("failed to remove file {}", path.display()))]
+#[snafu(display("failed to remove file {path}"))]
 pub struct RemoveFileError {
-    pub path: PathBuf,
+    pub path: Utf8PathBuf,
     pub source: std::io::Error,
 }
 
-pub fn remove_file<P: AsRef<Path>>(path: P) -> Result<(), RemoveFileError> {
+pub fn remove_file<P: AsRef<Utf8Path>>(path: P) -> Result<(), RemoveFileError> {
     let path = path.as_ref();
     std::fs::remove_file(path).context(RemoveFileSnafu { path })
 }
 
 #[derive(Snafu, Debug)]
-#[snafu(display("failed to write {}", path.display()))]
+#[snafu(display("failed to write {path}"))]
 pub struct WriteFileError {
-    pub path: PathBuf,
+    pub path: Utf8PathBuf,
     pub source: std::io::Error,
 }
 
-pub fn write<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) -> Result<(), WriteFileError> {
+pub fn write<P: AsRef<Utf8Path>, C: AsRef<[u8]>>(
+    path: P,
+    contents: C,
+) -> Result<(), WriteFileError> {
     let path = path.as_ref();
     std::fs::write(path, contents).context(WriteFileSnafu { path })
 }
diff --git a/lib/icp-fs/src/json.rs b/lib/icp-fs/src/json.rs
@@ -1,13 +1,13 @@
 use crate::fs::{ReadFileError, WriteFileError, read};
+use camino::{Utf8Path, Utf8PathBuf};
 use serde::Serialize;
 use snafu::prelude::*;
-use std::path::{Path, PathBuf};
 
 #[derive(Snafu, Debug)]
 pub enum LoadJsonFileError {
-    #[snafu(display("failed to parse {} as json", path.display()))]
+    #[snafu(display("failed to parse {path} as json"))]
     Parse {
-        path: PathBuf,
+        path: Utf8PathBuf,
         source: serde_json::Error,
     },
 
@@ -16,7 +16,7 @@ pub enum LoadJsonFileError {
 }
 
 pub fn load_json_file<T: for<'a> serde::de::Deserialize<'a>>(
-    path: impl AsRef<Path>,
+    path: impl AsRef<Utf8Path>,
 ) -> Result<T, LoadJsonFileError> {
     let path = path.as_ref();
     let content = read(path)?;
@@ -26,9 +26,9 @@ pub fn load_json_file<T: for<'a> serde::de::Deserialize<'a>>(
 
 #[derive(Snafu, Debug)]
 pub enum SaveJsonFileError {
-    #[snafu(display("failed to serialize json for {}", path.display()))]
+    #[snafu(display("failed to serialize json for {path}"))]
     Serialize {
-        path: PathBuf,
+        path: Utf8PathBuf,
         source: serde_json::Error,
     },
 
@@ -37,7 +37,7 @@ pub enum SaveJsonFileError {
 }
 
 pub fn save_json_file<T: Serialize>(
-    path: impl AsRef<Path>,
+    path: impl AsRef<Utf8Path>,
     value: &T,
 ) -> Result<(), SaveJsonFileError> {
     let path = path.as_ref();
diff --git a/lib/icp-network/Cargo.toml b/lib/icp-network/Cargo.toml
@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+camino = { workspace = true }
 candid = { workspace = true }
 fd-lock = { workspace = true }
 hex = { workspace = true }
diff --git a/lib/icp-network/src/config/model/network_descriptor.rs b/lib/icp-network/src/config/model/network_descriptor.rs
@@ -1,12 +1,12 @@
+use camino::Utf8PathBuf;
 use serde::{Deserialize, Serialize};
-use std::path::PathBuf;
 use uuid::Uuid;
 
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct NetworkDescriptorModel {
     pub id: Uuid,
-    pub path: PathBuf,
+    pub path: Utf8PathBuf,
     pub gateway_port: Option<u16>,
     pub pid: Option<u32>,
     pub root_key: String,
diff --git a/lib/icp-network/src/directory.rs b/lib/icp-network/src/directory.rs
@@ -0,0 +1,46 @@
+use crate::structure::NetworkDirectoryStructure;
+use camino::{Utf8Path, Utf8PathBuf};
+use fd_lock::RwLock;
+use icp_fs::fs::{CreateDirAllError, create_dir_all};
+use snafu::prelude::*;
+use std::fs::{File, OpenOptions};
+
+pub struct NetworkDirectory {
+    structure: NetworkDirectoryStructure,
+}
+
+impl NetworkDirectory {
+    pub fn new(network_root: &Utf8Path) -> Self {
+        let structure = NetworkDirectoryStructure::new(network_root);
+        Self { structure }
+    }
+
+    pub fn structure(&self) -> &NetworkDirectoryStructure {
+        &self.structure
+    }
+
+    pub fn ensure_exists(&self) -> Result<(), CreateDirAllError> {
+        create_dir_all(self.structure.network_root())
+    }
+
+    pub fn open_lock_file(&self) -> Result<RwLock<File>, OpenLockFileError> {
+        let path = self.structure.lock_path();
+        let rwlock = RwLock::new(
+            OpenOptions::new()
+                .create(true)
+                .write(true)
+                .read(true)
+                .truncate(true)
+                .open(&path)
+                .context(OpenLockFileSnafu { path })?,
+        );
+        Ok(rwlock)
+    }
+}
+
+#[derive(Debug, Snafu)]
+#[snafu(display("failed to open lock file at {path}"))]
+pub struct OpenLockFileError {
+    source: std::io::Error,
+    path: Utf8PathBuf,
+}
diff --git a/lib/icp-network/src/lib.rs b/lib/icp-network/src/lib.rs
diff --git a/lib/icp-network/src/managed/pocketic/admin.rs b/lib/icp-network/src/managed/pocketic/admin.rs
diff --git a/lib/icp-network/src/managed/pocketic/native.rs b/lib/icp-network/src/managed/pocketic/native.rs
diff --git a/lib/icp-network/src/managed/run.rs b/lib/icp-network/src/managed/run.rs
diff --git a/lib/icp-network/src/structure.rs b/lib/icp-network/src/structure.rs

Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
	`1`	`+pub mod directory;`
`1`	`2`	`pub mod structure;`