refactor: ProjectDirectory, NetworkDirectory (#8)

These encapsulate operations on files or directories within a project or network, respectively.
ProjectDirectoryStructure and NetworkDirectoryStructure continue to provide only paths.

Author: Eric Swanson

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

@@ -1,5 +1,5 @@
-use crate::commands::network::run::RunNetworkCommandError::ProjectStructureNotFound;
-use crate::project::structure::ProjectDirectoryStructure;
+use crate::commands::network::run::RunNetworkCommandError::ProjectNotFound;
+use crate::project::directory::ProjectDirectory;
 use clap::Parser;
 use icp_network::{ManagedNetworkModel, RunNetworkError, run_network};
 use snafu::Snafu;
@@ -10,21 +10,21 @@ 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().display());
+    eprintln!("Network root: {}", nd.structure().network_root().display());
 
-    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)]
     NetworkExecutionFailed { source: RunNetworkError },

bin/icp-cli/src/project.rs

@@ -1 +1,2 @@
+pub mod directory;
 pub mod structure;

bin/icp-cli/src/project/directory.rs

@@ -0,0 +1,32 @@
+use crate::project::structure::ProjectDirectoryStructure;
+use icp_network::NetworkDirectory;
+
+pub struct ProjectDirectory {
+    structure: ProjectDirectoryStructure,
+}
+
+impl ProjectDirectory {
+    pub fn find() -> Option<Self> {
+        let current_dir = std::env::current_dir().ok()?;
+        let mut path = current_dir.clone();
+        loop {
+            let structure = ProjectDirectoryStructure::new(&path);
+
+            if structure.project_yaml_path().exists() {
+                break Some(Self { structure });
+            }
+            if !path.pop() {
+                break 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)
+    }
+}

bin/icp-cli/src/project/structure.rs

@@ -1,28 +1,23 @@
-use icp_network::structure::NetworkDirectoryStructure;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 pub struct ProjectDirectoryStructure {
     root: PathBuf,
 }
 
 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: &Path) -> Self {
+        let root = root.to_path_buf();
+        Self { root }
     }
 
     pub fn root(&self) -> &PathBuf {
         &self.root
     }
 
+    pub fn project_yaml_path(&self) -> PathBuf {
+        self.root.join("icp.yaml")
+    }
+
     #[allow(dead_code)]
     pub fn network_config_path(&self, name: &str) -> PathBuf {
         self.root.join("networks").join(format!("{name}.yaml"))
@@ -32,9 +27,7 @@ impl ProjectDirectoryStructure {
         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) -> PathBuf {
+        self.work_dir().join("networks").join(network_name)
     }
 }

lib/icp-network/src/directory.rs

@@ -0,0 +1,46 @@
+use crate::structure::NetworkDirectoryStructure;
+use fd_lock::RwLock;
+use icp_fs::fs::{CreateDirAllError, create_dir_all};
+use snafu::prelude::*;
+use std::fs::{File, OpenOptions};
+use std::path::{Path, PathBuf};
+
+pub struct NetworkDirectory {
+    structure: NetworkDirectoryStructure,
+}
+
+impl NetworkDirectory {
+    pub fn new(network_root: &Path) -> 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.display(),))]
+pub struct OpenLockFileError {
+    source: std::io::Error,
+    path: PathBuf,
+}

lib/icp-network/src/lib.rs

@@ -1,9 +1,11 @@
 pub mod config;
+mod directory;
 mod managed;
 pub mod status;
 pub mod structure;
 
 pub use config::model::managed::ManagedNetworkModel;
 pub use config::model::network_config::NetworkConfig;
+pub use directory::NetworkDirectory;
 pub use managed::run::RunNetworkError;
 pub use managed::run::run_network;

lib/icp-network/src/managed/run.rs

@@ -1,15 +1,15 @@
 use crate::RunNetworkError::NoPocketIcPath;
 use crate::config::model::managed::ManagedNetworkModel;
 use crate::config::model::network_descriptor::NetworkDescriptorModel;
+use crate::directory::OpenLockFileError;
 use crate::managed::pocketic::admin::{
     CreateHttpGatewayError, CreateInstanceError, PocketIcAdminInterface,
 };
 use crate::managed::pocketic::instance::PocketIcInstance;
 use crate::managed::pocketic::native::spawn_pocketic;
 use crate::managed::run::InitializePocketicError::NoRootKey;
-use crate::status;
 use crate::structure::NetworkDirectoryStructure;
-use fd_lock::RwLock;
+use crate::{NetworkDirectory, status};
 use icp_fs::fs::{
     CreateDirAllError, RemoveDirAllError, RemoveFileError, create_dir_all, remove_dir_all,
     remove_file,
@@ -19,7 +19,7 @@ use pocket_ic::common::rest::HttpGatewayBackend;
 use reqwest::Url;
 use snafu::prelude::*;
 use std::env::var_os;
-use std::fs::{OpenOptions, read_to_string};
+use std::fs::read_to_string;
 use std::path::{Path, PathBuf};
 use std::process::ExitStatus;
 use std::time::Duration;
@@ -31,27 +31,18 @@ use uuid::Uuid;
 
 pub async fn run_network(
     config: ManagedNetworkModel,
-    nds: NetworkDirectoryStructure,
+    nd: NetworkDirectory,
 ) -> Result<(), RunNetworkError> {
     let pocketic_path = PathBuf::from(var_os("ICP_POCKET_IC_PATH").ok_or(NoPocketIcPath)?);
 
-    create_dir_all(nds.network_root())?;
+    nd.ensure_exists()?;
 
-    let mut file = RwLock::new(
-        OpenOptions::new()
-            .create(true)
-            .write(true)
-            .read(true)
-            .truncate(true)
-            .open(nds.lock_path())
-            .map_err(|source| RunNetworkError::OpenLockFile { source })?,
-    );
+    let mut file = nd.open_lock_file()?;
     let _guard = file
         .try_write()
         .map_err(|_| RunNetworkError::AlreadyRunningThisProject)?;
-    eprintln!("Holding lock on {}", nds.lock_path().display());
 
-    run_pocketic(&pocketic_path, config, nds).await?;
+    run_pocketic(&pocketic_path, config, nd.structure()).await?;
     Ok(())
 }
 
@@ -66,17 +57,17 @@ pub enum RunNetworkError {
     #[snafu(display("ICP_POCKET_IC_PATH environment variable is not set"))]
     NoPocketIcPath,
 
-    #[snafu(display("failed to open lock file"))]
-    OpenLockFile { source: std::io::Error },
+    #[snafu(transparent)]
+    OpenLockFile { source: OpenLockFileError },
 
     #[snafu(transparent)]
-    RunPocketIcError { source: RunPocketIcError },
+    RunPocketIc { source: RunPocketIcError },
 }
 
 async fn run_pocketic(
     pocketic_path: &Path,
     _config: ManagedNetworkModel,
-    nds: NetworkDirectoryStructure,
+    nds: &NetworkDirectoryStructure,
 ) -> Result<(), RunPocketIcError> {
     eprintln!("PocketIC path: {}", pocketic_path.display());
 

lib/icp-network/src/structure.rs

@@ -4,8 +4,6 @@ pub struct NetworkDirectoryStructure {
     pub network_root: PathBuf,
 }
 
-impl NetworkDirectoryStructure {}
-
 impl NetworkDirectoryStructure {
     pub fn new(network_root: &Path) -> Self {
         let network_root = network_root.to_path_buf();