feat: remove the last bits of arc-swap (#1464)

I noticed there was one remaining component using arc-swap. This change
replaces it with a standard Mutex. And, removes the dependency on
arc-swap.

Author: demosdemon

Cargo.lock

@@ -32,7 +32,6 @@ sha2.workspace = true
 smallvec.workspace = true
 thiserror.workspace = true
 # Regular dependencies
-arc-swap = "1.7.1"
 bitfield = "0.19.3"
 bitflags = "2.10.0"
 derive-where = "1.6.0"

storage/Cargo.toml

@@ -49,8 +49,6 @@ pub(crate) mod primitives;
 use crate::linear::OffsetReader;
 use crate::logger::trace;
 use crate::node::branch::ReadSerializable as _;
-use arc_swap::ArcSwap;
-use arc_swap::access::DynAccess;
 use smallvec::SmallVec;
 use std::fmt::Debug;
 use std::io::{Error, ErrorKind, Read};
@@ -236,17 +234,7 @@ impl<S> NodeStore<Arc<ImmutableProposal>, S> {
     /// When an immutable proposal commits, we need to reparent any proposal that
     /// has the committed proposal as it's parent
     pub fn commit_reparent(&self, other: &NodeStore<Arc<ImmutableProposal>, S>) {
-        match *other.kind.parent.load() {
-            NodeStoreParent::Proposed(ref parent) => {
-                if Arc::ptr_eq(&self.kind, parent) {
-                    other
-                        .kind
-                        .parent
-                        .store(NodeStoreParent::Committed(self.kind.root_hash()).into());
-                }
-            }
-            NodeStoreParent::Committed(_) => {}
-        }
+        other.kind.commit_reparent(&self.kind);
     }
 }
 
@@ -469,7 +457,7 @@ pub struct ImmutableProposal {
     /// Nodes that have been deleted in this proposal.
     deleted: Box<[MaybePersistedNode]>,
     /// The parent of this proposal.
-    parent: Arc<ArcSwap<NodeStoreParent>>,
+    parent: Arc<std::sync::Mutex<NodeStoreParent>>,
     /// The root of the trie in this proposal.
     root: Option<Child>,
 }
@@ -478,15 +466,20 @@ impl ImmutableProposal {
     /// Returns true if the parent of this proposal is committed and has the given hash.
     #[must_use]
     fn parent_hash_is(&self, hash: Option<TrieHash>) -> bool {
-        match <Arc<ArcSwap<NodeStoreParent>> as arc_swap::access::DynAccess<Arc<_>>>::load(
-            &self.parent,
-        )
-        .as_ref()
-        {
+        match &*self.parent.lock().expect("poisoned lock") {
             NodeStoreParent::Committed(root_hash) => *root_hash == hash,
             NodeStoreParent::Proposed(_) => false,
         }
     }
+
+    fn commit_reparent(self: &Arc<Self>, committing: &Arc<Self>) {
+        let mut guard = self.parent.lock().expect("poisoned lock");
+        if let NodeStoreParent::Proposed(ref parent) = *guard
+            && Arc::ptr_eq(parent, committing)
+        {
+            *guard = NodeStoreParent::Committed(committing.root_hash());
+        }
+    }
 }
 
 /// Contains the state of a revision of a merkle trie.
@@ -605,7 +598,7 @@ impl<S: ReadableStorage> TryFrom<NodeStore<MutableProposal, S>>
             header,
             kind: Arc::new(ImmutableProposal {
                 deleted: kind.deleted.into(),
-                parent: Arc::new(ArcSwap::new(Arc::new(kind.parent))),
+                parent: Arc::new(std::sync::Mutex::new(kind.parent)),
                 root: None,
             }),
             storage,
@@ -874,7 +867,6 @@ mod tests {
 
     use crate::LeafNode;
     use crate::linear::memory::MemStore;
-    use arc_swap::access::DynGuard;
 
     use super::*;
     use primitives::area_size_iter;
@@ -923,21 +915,25 @@ mod tests {
         // create an empty r1, check that it's parent is the empty committed version
         let r1 = NodeStore::new(&base).unwrap();
         let r1: NodeStore<Arc<ImmutableProposal>, _> = r1.try_into().unwrap();
-        let parent: DynGuard<Arc<NodeStoreParent>> = r1.kind.parent.load();
-        assert!(matches!(**parent, NodeStoreParent::Committed(None)));
+        {
+            let parent = r1.kind.parent.lock().expect("poisoned lock");
+            assert!(matches!(*parent, NodeStoreParent::Committed(None)));
+        }
 
         // create an empty r2, check that it's parent is the proposed version r1
         let r2: NodeStore<MutableProposal, _> = NodeStore::new(&r1).unwrap();
         let r2: NodeStore<Arc<ImmutableProposal>, _> = r2.try_into().unwrap();
-        let parent: DynGuard<Arc<NodeStoreParent>> = r2.kind.parent.load();
-        assert!(matches!(**parent, NodeStoreParent::Proposed(_)));
+        {
+            let parent = r2.kind.parent.lock().expect("poisoned lock");
+            assert!(matches!(*parent, NodeStoreParent::Proposed(_)));
+        }
 
         // reparent r2
         r1.commit_reparent(&r2);
 
         // now check r2's parent, should match the hash of r1 (which is still None)
-        let parent: DynGuard<Arc<NodeStoreParent>> = r2.kind.parent.load();
-        if let NodeStoreParent::Committed(hash) = &**parent {
+        let parent = r2.kind.parent.lock().expect("poisoned lock");
+        if let NodeStoreParent::Committed(hash) = &*parent {
             assert_eq!(*hash, r1.root_hash());
             assert_eq!(*hash, None);
         } else {