Add handle delete prefix

go/cpossum/c-possum.go

@@ -264,3 +264,7 @@ func WriterRename(w Writer, v Value, newKey []byte) {
 func HandleMovePrefix(h *Handle, from, to []byte) error {
 	return mapError(C.possum_handle_move_prefix(h, BufFromBytes(from), BufFromBytes(to)))
 }
+
+func HandleDeletePrefix(h *Handle, prefix []byte) error {
+	return mapError(C.possum_handle_delete_prefix(h, BufFromBytes(prefix)))
+}

go/cpossum/possum.h

@@ -129,3 +129,5 @@ PossumError possum_single_delete(const Handle *handle, PossumBuf key, PossumStat
 PossumError possum_reader_new(const Handle *handle, PossumReader **reader);
 
 PossumError possum_handle_move_prefix(Handle *handle, PossumBuf from, PossumBuf to);
+
+PossumError possum_handle_delete_prefix(Handle *handle, PossumBuf prefix);

go/handle.go

@@ -83,3 +83,7 @@ func (me Handle) CleanupSnapshots() error {
 func (me Handle) MovePrefix(from, to []byte) error {
 	return possumC.HandleMovePrefix(me.cHandle, from, to)
 }
+
+func (me Handle) DeletePrefix(prefix []byte) error {
+	return possumC.HandleDeletePrefix(me.cHandle, prefix)
+}

go/justfile

@@ -0,0 +1,4 @@
+test:
+	cargo build
+	make -C ..
+	CGO_LDFLAGS=../target/debug/libpossum.a go test -race ./...

go/resource/resource.go

@@ -21,6 +21,10 @@ func (p Provider) NewInstance(s string) (resource.Instance, error) {
 	}, nil
 }
 
+func (p Provider) DeletePrefix(prefix string) error {
+	return p.Handle.DeletePrefix([]byte(prefix))
+}
+
 var _ resource.Provider = Provider{}
 
 type instance struct {

src/c_api/ext_fns/handle.rs

@@ -173,3 +173,16 @@ pub extern "C" fn possum_handle_move_prefix(
             .map_err(Into::into)
     })
 }
+
+#[no_mangle]
+pub extern "C" fn possum_handle_delete_prefix(
+    handle: *mut Handle,
+    prefix: PossumBuf,
+) -> PossumError {
+    let handle = unsafe { &mut *handle };
+    with_residual(|| {
+        handle
+            .delete_prefix(prefix.as_ref())
+            .map_err(Into::into)
+    })
+}

src/handle.rs

@@ -304,7 +304,7 @@ impl Handle {
         // Maybe it's okay just to commit anyway, since we have a deferred transaction and sqlite
         // might know nothing has changed.
         if deleted.is_some() {
-            tx.commit(())?.complete()?;
+            tx.commit(())?.complete();
         }
         Ok(deleted)
     }
@@ -321,7 +321,7 @@ impl Handle {
     pub fn rename_item(&mut self, from: &[u8], to: &[u8]) -> PubResult<Timestamp> {
         let mut tx = self.start_immediate_transaction()?;
         let last_used = tx.rename_item(from, to)?;
-        Ok(tx.commit(last_used)?.complete()?)
+        Ok(tx.commit(last_used)?.complete())
     }
 
     /// Walks the underlying files in the possum directory.
@@ -455,7 +455,17 @@ impl Handle {
             to_vec.extend_from_slice(item.key.strip_prefix(from).unwrap());
             tx.rename_item(&item.key, &to_vec)?;
         }
-        tx.commit(())?.complete()
+        tx.commit(())?.complete();
+        Ok(())
+    }
+
+    pub fn delete_prefix(&self, prefix: &[u8]) -> PubResult<()> {
+        let mut tx = self.start_deferred_transaction()?;
+        for item in tx.read().list_items(prefix)? {
+            tx.delete_key(&item.key)?;
+        }
+        tx.commit(())?.complete();
+        Ok(())
     }
 }
 

src/lib.rs

@@ -349,7 +349,7 @@ impl<'handle> BatchWriter<'handle> {
             .context("commit transaction")?;
 
         self.flush_exclusive_files();
-        work.complete()
+        Ok(work.complete())
     }
 
     /// Flush Writer's exclusive files and return them to the Handle pool.

src/reader.rs

@@ -18,7 +18,7 @@ impl<'a> Reader<'a> {
                     file_offset,
                     length,
                     file_id,
-                }) = value.location.clone()
+                }) = value.location
                 {
                     let file = self.reads.entry(file_id);
                     file.or_default().insert(ReadExtent {
@@ -39,7 +39,7 @@ impl<'a> Reader<'a> {
         self.owned_tx
             .commit(())
             .context("committing transaction")?
-            .complete()?;
+            .complete();
         Ok(Snapshot { file_clones })
     }
 

src/testing/torrent_storage.rs

@@ -154,7 +154,7 @@ fn torrent_storage_inner_run(inner: &TorrentStorageInner) -> anyhow::Result<()>
             |offset| format!("verified/{piece_data_hash:016x}/{offset}").into_bytes();
         if opts.rename_values {
             for (offset, value) in values {
-                snapshot.value(value.clone()).view(|bytes| {
+                snapshot.value(value).view(|bytes| {
                     stored_hash.write(bytes);
                     compare_reads(bytes, io::repeat(byte).take(chunk_size as u64)).unwrap();
                     writer.rename_value(value, make_verified_key(offset))

src/tx.rs

@@ -147,7 +147,7 @@ where
 }
 
 impl<'h, T> PostCommitWork<'h, T> {
-    pub fn complete(self) -> Result<T> {
+    pub fn complete(self) -> T {
         // This has to happen after exclusive files are flushed or there's a tendency for hole
         // punches to not persist. It doesn't fix the problem, but it significantly reduces it.
         if !self.handle.instance_limits.disable_hole_punching {
@@ -157,7 +157,7 @@ impl<'h, T> PostCommitWork<'h, T> {
         for file_id in self.altered_files {
             self.handle.clones.lock().unwrap().remove(&file_id);
         }
-        Ok(self.reward)
+        self.reward
     }
 }