Remove lock refs, use scope closures instead

Author: adamspofford-dfinity

crates/icp-cli/src/store_artifact.rs

@@ -61,30 +61,31 @@ impl ArtifactStore {
 
 impl ArtifactStore {
     pub(crate) async fn save(&self, name: &str, wasm: &[u8]) -> Result<(), SaveError> {
-        // Lock Artifact Store
-        let lock = self.lock.write_ref().await?;
-
-        // Store artifact
-        write(&lock.artifact_by_name(name), wasm).context(SaveWriteFileSnafu)?;
-
-        Ok(())
+        self.lock
+            .with_write(async |store| {
+                // Save artifact
+                write(&store.artifact_by_name(name), wasm).context(SaveWriteFileSnafu)?;
+                Ok(())
+            })
+            .await?
     }
 
     pub(crate) async fn lookup(&self, name: &str) -> Result<Vec<u8>, LookupError> {
-        // Lock Artifact Store
-        let lock = self.lock.read_ref().await?;
-
-        let artifact = lock.artifact_by_name(name);
-        // Not Found
-        if !artifact.exists() {
-            return Err(LookupError::LookupArtifactNotFound {
-                name: name.to_owned(),
-            });
-        }
-
-        // Load artifact
-        let wasm = read(&artifact).context(LookupReadFileSnafu)?;
-
-        Ok(wasm)
+        self.lock
+            .with_read(async |store| {
+                let artifact = store.artifact_by_name(name);
+                // Not Found
+                if !artifact.exists() {
+                    return Err(LookupError::LookupArtifactNotFound {
+                        name: name.to_owned(),
+                    });
+                }
+
+                // Load artifact
+                let wasm = read(&artifact).context(LookupReadFileSnafu)?;
+
+                Ok(wasm)
+            })
+            .await?
     }
 }

crates/icp/src/fs/lock.rs

@@ -1,10 +1,7 @@
 use crate::prelude::*;
 use snafu::{ResultExt, Snafu};
 use std::{fs::File, io, ops::Deref};
-use tokio::{
-    sync::{RwLock, RwLockReadGuard, RwLockWriteGuard},
-    task::spawn_blocking,
-};
+use tokio::{sync::RwLock, task::spawn_blocking};
 
 pub struct DirectoryStructureLock<T: PathsAccess> {
     paths_access: T,
@@ -58,8 +55,7 @@ impl<T: PathsAccess> DirectoryStructureLock<T> {
         .await
         .unwrap()
     }
-
-    pub async fn read_ref(&self) -> Result<DirectoryStructureGuardReadRef<'_, T>, LockError> {
+    pub async fn with_read<R>(&self, f: impl AsyncFnOnce(&T) -> R) -> Result<R, LockError> {
         let guard = self.lock_file.read().await;
         let lock_file = guard.try_clone().context(HandleCloneFailedSnafu {
             path: &self.lock_path,
@@ -70,14 +66,14 @@ impl<T: PathsAccess> DirectoryStructureLock<T> {
             .context(LockFailedSnafu {
                 lock_path: &self.lock_path,
             })?;
-
-        Ok(DirectoryStructureGuardReadRef {
-            paths_access: &self.paths_access,
-            guard,
-        })
+        let ret = f(&self.paths_access).await;
+        guard.unlock().context(LockFailedSnafu {
+            lock_path: &self.lock_path,
+        })?;
+        Ok(ret)
     }
 
-    pub async fn write_ref(&self) -> Result<DirectoryStructureGuardWriteRef<'_, T>, LockError> {
+    pub async fn with_write<R>(&self, f: impl AsyncFnOnce(&T) -> R) -> Result<R, LockError> {
         let guard = self.lock_file.write().await;
         let lock_file = guard.try_clone().context(HandleCloneFailedSnafu {
             path: &self.lock_path,
@@ -88,11 +84,11 @@ impl<T: PathsAccess> DirectoryStructureLock<T> {
             .context(LockFailedSnafu {
                 lock_path: &self.lock_path,
             })?;
-
-        Ok(DirectoryStructureGuardWriteRef {
-            paths_access: &self.paths_access,
-            guard,
-        })
+        let ret = f(&self.paths_access).await;
+        guard.unlock().context(LockFailedSnafu {
+            lock_path: &self.lock_path,
+        })?;
+        Ok(ret)
     }
 }
 
@@ -111,44 +107,6 @@ pub enum LockError {
     HandleCloneFailed { source: io::Error, path: PathBuf },
 }
 
-pub struct DirectoryStructureGuardReadRef<'a, T> {
-    paths_access: &'a T,
-    guard: RwLockReadGuard<'a, File>,
-}
-
-impl<'a, T> Deref for DirectoryStructureGuardReadRef<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        self.paths_access
-    }
-}
-
-impl<'a, T> Drop for DirectoryStructureGuardReadRef<'a, T> {
-    fn drop(&mut self) {
-        _ = self.guard.unlock();
-    }
-}
-
-pub struct DirectoryStructureGuardWriteRef<'a, T> {
-    paths_access: &'a T,
-    guard: RwLockWriteGuard<'a, File>,
-}
-
-impl<'a, T> Deref for DirectoryStructureGuardWriteRef<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        self.paths_access
-    }
-}
-
-impl<'a, T> Drop for DirectoryStructureGuardWriteRef<'a, T> {
-    fn drop(&mut self) {
-        _ = self.guard.unlock();
-    }
-}
-
 pub struct DirectoryStructureGuardOwned<T> {
     paths_access: T,
     guard: File,