Add helpers for set and update

Author: rklaehn

src/store/fs/bao_file.rs

@@ -21,21 +21,17 @@ use bytes::{Bytes, BytesMut};
 use derive_more::Debug;
 use irpc::channel::mpsc;
 use tokio::sync::watch;
-use tracing::{debug, error, info, trace, Span};
+use tracing::{debug, error, info, trace};
 
 use super::{
     entry_state::{DataLocation, EntryState, OutboardLocation},
-    meta::Update,
     options::{Options, PathOptions},
     BaoFilePart,
 };
 use crate::{
     api::blobs::Bitfield,
     store::{
-        fs::{
-            meta::{raw_outboard_size, Set},
-            TaskContext,
-        },
+        fs::{meta::raw_outboard_size, TaskContext},
         util::{
             read_checksummed_and_truncate, write_checksummed, FixedSize, MemOrFile,
             PartialMemStorage, SizeInfo, SparseMemFile, DD,
@@ -644,21 +640,7 @@ impl BaoFileHandle {
             let size = storage.bitfield.size;
             let (storage, entry_state) = storage.into_complete(size, &options)?;
             debug!("File was reconstructed as complete");
-            let (tx, rx) = crate::util::channel::oneshot::channel();
-            ctx.db
-                .sender
-                .send(
-                    Set {
-                        hash,
-                        state: entry_state,
-                        tx,
-                        span: Span::current(),
-                    }
-                    .into(),
-                )
-                .await
-                .map_err(|_| io::Error::other("send update"))?;
-            rx.await.map_err(|_| io::Error::other("receive update"))??;
+            ctx.db.set(hash, entry_state).await?;
             storage.into()
         } else {
             storage.into()
@@ -796,19 +778,7 @@ impl BaoFileHandle {
             true
         });
         if let Some(update) = res? {
-            ctx.db
-                .sender
-                .send(
-                    Update {
-                        hash: self.hash,
-                        state: update,
-                        tx: None,
-                        span: Span::current(),
-                    }
-                    .into(),
-                )
-                .await
-                .map_err(|_| io::Error::other("send update"))?;
+            ctx.db.update(self.hash, update).await?;
         }
         Ok(())
     }

src/store/fs/meta.rs

@@ -34,7 +34,7 @@ mod proto;
 pub use proto::*;
 pub(crate) mod tables;
 use tables::{ReadOnlyTables, ReadableTables, Tables};
-use tracing::{debug, error, info_span, trace};
+use tracing::{debug, error, info_span, trace, Span};
 
 use super::{
     delete_set::DeleteHandle,
@@ -88,14 +88,49 @@ pub type ActorResult<T> = Result<T, ActorError>;
 
 #[derive(Debug, Clone)]
 pub struct Db {
-    pub sender: tokio::sync::mpsc::Sender<Command>,
+    sender: tokio::sync::mpsc::Sender<Command>,
 }
 
 impl Db {
     pub fn new(sender: tokio::sync::mpsc::Sender<Command>) -> Self {
         Self { sender }
     }
 
+    /// Update the entry state for a hash, without awaiting completion.
+    pub async fn update(&self, hash: Hash, state: EntryState<Bytes>) -> io::Result<()> {
+        self.sender
+            .send(
+                Update {
+                    hash,
+                    state,
+                    tx: None,
+                    span: Span::current(),
+                }
+                .into(),
+            )
+            .await
+            .map_err(|_| io::Error::other("send update"))
+    }
+
+    /// Set the entry state and await completion.
+    pub async fn set(&self, hash: Hash, entry_state: EntryState<Bytes>) -> io::Result<()> {
+        let (tx, rx) = oneshot::channel();
+        self.sender
+            .send(
+                Set {
+                    hash,
+                    state: entry_state,
+                    tx,
+                    span: Span::current(),
+                }
+                .into(),
+            )
+            .await
+            .map_err(|_| io::Error::other("send update"))?;
+        rx.await.map_err(|_| io::Error::other("receive update"))??;
+        Ok(())
+    }
+
     /// Get the entry state for a hash, if any.
     pub async fn get(&self, hash: Hash) -> anyhow::Result<Option<EntryState<Bytes>>> {
         let (tx, rx) = oneshot::channel();