feat: remove functionality for cache

Author: DevBlocky

benches/benchmarks.rs

@@ -40,14 +40,12 @@ pub fn cache_write_random_key(c: &mut Criterion) {
         let (db, rt) = make_executor();
         let value = random_bytes(VALUE_SZ);
 
-        b.iter_custom(|iters| {
-            let key = random_bytes(4);
-            let start = Instant::now();
-            for _ in 0..iters {
+        b.iter_with_setup(
+            || random_bytes(4),
+            |key| {
                 rt.block_on(db.write(&key, &value)).unwrap();
-            }
-            start.elapsed()
-        });
+            },
+        );
     });
 }
 
@@ -66,6 +64,21 @@ pub fn cache_read_const_key(c: &mut Criterion) {
     });
 }
 
+pub fn cache_remove_const_key(c: &mut Criterion) {
+    c.bench_function("cache::remove_const_key", move |b| {
+        let (db, rt) = make_executor();
+        const KEY: [u8; 4] = [0xDE, 0xAD, 0xBE, 0xEF];
+        let value = random_bytes(VALUE_SZ);
+
+        b.iter_with_setup(
+            || rt.block_on(db.write(&KEY, &value)).unwrap(),
+            |_| {
+                rt.block_on(db.remove(&KEY)).unwrap();
+            },
+        );
+    });
+}
+
 pub fn cache_metadata_lookup(c: &mut Criterion) {
     c.bench_function("cache::metadata_lookup", move |b| {
         let (db, rt) = make_executor();
@@ -84,6 +97,7 @@ criterion_group!(
     cache_write_const_key,
     cache_write_random_key,
     cache_read_const_key,
+    cache_remove_const_key,
     cache_metadata_lookup
 );
 

src/cache.rs

@@ -188,6 +188,52 @@ impl Cache {
         Ok(())
     }
 
+    /// Removes an entry from the cache, returning its [`Metadata`].
+    ///
+    /// This will remove the entry from both the main cache database and the metadata database.
+    /// Please note that this will return `Error::NotFound` if either the main database *or* the
+    /// meta database didn't find the entry.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # #[tokio::main(flavor = "current_thread")]
+    /// # async fn main() {
+    /// use forceps::CacheBuilder;
+    ///
+    /// let cache = CacheBuilder::new("./cache")
+    ///     .build()
+    ///     .await
+    ///     .unwrap();
+    ///
+    /// # cache.write(b"MY_KEY", b"Hello World").await.unwrap();
+    /// let metadata = cache.remove(b"MY_KEY").await.unwrap();
+    /// assert_eq!(metadata.get_size(), b"Hello World".len() as u64);
+    /// # }
+    /// ```
+    pub async fn remove<K: AsRef<[u8]>>(&self, key: K) -> Result<Metadata> {
+        let key = key.as_ref();
+
+        let cur_path = self.path_from_key(key);
+        let tmp_path = crate::tmp::tmppath_in(&self.path);
+
+        // move then delete the file
+        //
+        // the purpose of moving then deleting is that file moves are much faster than file
+        // deletes. if we were to delete in place, and another thread starts reading, it could
+        // spell bad news.
+        afs::rename(&cur_path, &tmp_path)
+            .await
+            .map_err(|e| match e.kind() {
+                io::ErrorKind::NotFound => ForcepError::NotFound,
+                _ => ForcepError::Io(e),
+            })?;
+        afs::remove_file(&tmp_path).await.map_err(ForcepError::Io)?;
+
+        // remove the metadata for the entry
+        self.meta.remove_metadata_for(key)
+    }
+
     /// Queries the index database for metadata on the entry with the corresponding key.
     ///
     /// This will return the metadata for the associated key. For information about what metadata
@@ -337,12 +383,13 @@ mod test {
     }
 
     #[tokio::test]
-    async fn basic_write_read() {
+    async fn write_read_remove() {
         let cache = default_cache().await;
 
         cache.write(&b"CACHE_KEY", &b"Hello World").await.unwrap();
         let data = cache.read(&b"CACHE_KEY").await.unwrap();
         assert_eq!(&data, &b"Hello World");
+        cache.remove(&b"CACHE_KEY").await.unwrap();
     }
 
     #[tokio::test]

src/metadata.rs

@@ -153,6 +153,14 @@ impl MetaDb {
         Ok(meta)
     }
 
+    pub fn remove_metadata_for(&self, key: &[u8]) -> Result<Metadata> {
+        match self.db.remove(key) {
+            Ok(Some(m)) => Metadata::deserialize(&m[..]),
+            Ok(None) => Err(ForcepError::NotFound),
+            Err(e) => Err(ForcepError::MetaDb(e)),
+        }
+    }
+
     /// Iterator over the entire metadata database
     pub fn metadata_iter(&self) -> impl Iterator<Item = Result<(Vec<u8>, Metadata)>> {
         self.db.iter().map(|x| match x {