try rustcask

it works? it's fast?

Cargo.lock

···
 
 [[package]]
 name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bincode"
 version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
···
  "pin-project-lite",
  "pin-utils",
  "slab",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.11.1+wasi-snapshot-preview1",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
 name = "proc-macro2"
 version = "1.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
 [[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.16",
+]
+
+[[package]]
 name = "rayon"
 version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 name = "repo-stream"
 version = "0.1.1"
 dependencies = [
- "bincode",
+ "bincode 2.0.1",
  "clap",
  "criterion",
  "env_logger",
···
  "multibase",
  "redb",
  "rusqlite",
+ "rustcask",
  "serde",
  "serde_bytes",
  "serde_ipld_dagcbor",
···
 version = "0.1.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace"
+
+[[package]]
+name = "rustcask"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e17ed1a2733a60fea8495ddcb42c22cabd17afec7ffa7b024b161dd662da4003"
+dependencies = [
+ "bincode 1.3.3",
+ "bytes",
+ "clap",
+ "log",
+ "rand",
+ "regex",
+ "serde",
+ "tokio",
+]
 
 [[package]]
 name = "rustix"
···
 checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
 dependencies = [
  "fastrand",
- "getrandom",
+ "getrandom 0.3.3",
  "once_cell",
  "rustix",
  "windows-sys 0.60.2",

Cargo.toml

···
 multibase = "0.9.2"
 redb = "3.1.0"
 rusqlite = "0.37.0"
+rustcask = "0.1.0"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_bytes = "0.11.19"
 serde_ipld_dagcbor = "0.6.4"

examples/disk-read-file/main.rs

···
     let mb = 2_usize.pow(20);
 
     let mut driver =
-        match repo_stream::drive::load_car(reader, |block| S(block.len()), 16 * mb).await? {
+        match repo_stream::drive::load_car(reader, |block| S(block.len()), 1 * mb).await? {
             repo_stream::drive::Vehicle::Lil(_, _) => panic!("try this on a bigger car"),
             repo_stream::drive::Vehicle::Big(big_stuff) => {
                 // let disk_store = repo_stream::disk::SqliteStore::new(tmpfile);
-                let disk_store = repo_stream::disk::RedbStore::new(tmpfile);
+                // let disk_store = repo_stream::disk::RedbStore::new(tmpfile);
+                let disk_store = repo_stream::disk::RustcaskStore::new(tmpfile);
                 let (commit, driver) = big_stuff.finish_loading(disk_store).await?;
                 log::warn!("big: {:?}", commit);
                 driver

src/disk.rs

···
     }
 }
 
-///// TODO: that other single file db thing to try
+///// rustcask??
+
+pub struct RustcaskStore {
+    path: PathBuf,
+}
+
+impl RustcaskStore {
+    pub fn new(path: PathBuf) -> Self {
+        Self { path }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum CaskError {
+    #[error(transparent)]
+    OpenError(#[from] rustcask::error::OpenError),
+    #[error(transparent)]
+    SetError(#[from] rustcask::error::SetError),
+    #[error("failed to get key: {0}")]
+    GetError(String),
+    #[error("failed to ensure directory: {0}")]
+    EnsureDirError(std::io::Error),
+}
+
+impl StorageErrorBase for CaskError {}
+
+impl DiskStore for RustcaskStore {
+    type StorageError = CaskError;
+    type Access = RustcaskAccess;
+    async fn get_access(&mut self) -> Result<RustcaskAccess, CaskError> {
+        let path = self.path.clone();
+        let db = tokio::task::spawn_blocking(move || {
+            std::fs::create_dir_all(&path).map_err(CaskError::EnsureDirError)?;
+            let db = rustcask::Rustcask::builder().open(&path)?;
+            Ok::<_, Self::StorageError>(db)
+        })
+        .await
+        .expect("join error")?;
+
+        Ok(RustcaskAccess { db })
+    }
+}
+
+pub struct RustcaskAccess {
+    db: rustcask::Rustcask,
+}
+
+impl DiskAccess for RustcaskAccess {
+    type StorageError = CaskError;
+    fn get_writer(&mut self) -> Result<impl DiskWriter<CaskError>, CaskError> {
+        Ok(RustcaskWriter { db: self.db.clone() })
+    }
+    fn get_reader(&self) -> Result<impl DiskReader<StorageError = CaskError>, CaskError> {
+        Ok(RustcaskReader { db: self.db.clone() })
+    }
+}
+
+pub struct RustcaskWriter {
+    db: rustcask::Rustcask,
+}
+
+impl DiskWriter<CaskError> for RustcaskWriter {
+    fn put(&mut self, key: Vec<u8>, val: Vec<u8>) -> Result<(), CaskError> {
+        self.db.set(key, val)?;
+        Ok(())
+    }
+}
+
+pub struct RustcaskReader {
+    db: rustcask::Rustcask,
+}
+
+impl DiskReader for RustcaskReader {
+    type StorageError = CaskError;
+    fn get(&mut self, key: Vec<u8>) -> Result<Option<Vec<u8>>, CaskError> {
+        self.db
+            .get(&key)
+            .map_err(|e| CaskError::GetError(e.to_string()))
+    }
+}

src/drive.rs

···
     DiskTripped(#[from] DiskTrip<E>),
 }
 
-// #[derive(Debug, thiserror::Error)]
-// pub enum Boooooo<E: StorageErrorBase> {
-//     #[error("disk tripped: {0}")]
-//     DiskTripped(#[from] DiskTrip<E>),
-//     #[error("dde whatever: {0}")]
-//     DiskDriveError(#[from] DiskDriveError<E>),
-// }
-
 pub trait Processable: Clone + Serialize + DeserializeOwned {
     /// the additional size taken up (not including its mem::size_of)
     fn get_size(&self) -> usize;