Bump dependencies

Author: Barre

zerofs/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "zerofs"
-version = "1.0.5"
+version = "1.0.6"
 edition = "2024"
 description = "A high-performance filesystem that makes S3 your primary storage with NFS, 9P, and NBD support"
 license = "AGPL-3.0"
@@ -30,7 +30,7 @@ vendored-protoc = ["dep:protobuf-src"]
 
 [dependencies]
 console-subscriber = { version = "0.5", optional = true }
-slatedb = { git = "https://github.com/Barre/slatedb.git", rev = "da3a3a52958a5ba32a34d4cfc5d47569f6440373", features = [
+slatedb = { git = "https://github.com/Barre/slatedb.git", rev = "491de682bd6b029676601d10f6e3cfee4d6e80bf", features = [
     "wal_disable",
 ] }
 fastant = "0.1.11"

zerofs/Cargo.toml

@@ -21,7 +21,7 @@ use slatedb::config::{
     ObjectStoreCacheOptions,
 };
 use slatedb::object_store::path::Path;
-use slatedb::{BlockTransformer, DbBuilder, DbReader};
+use slatedb::{BlockTransformer, CompactorBuilder, DbBuilder, DbReader};
 use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Duration;
@@ -448,21 +448,12 @@ pub async fn build_slatedb(
 
     let wal_enabled = lsm_config.map(|c| c.wal_enabled()).unwrap_or(true);
 
-    let compactor_options = if disable_compactor {
-        None
-    } else {
-        Some(slatedb::config::CompactorOptions {
-            max_concurrent_compactions,
-            max_sst_size: 256 * 1024 * 1024,
-            ..Default::default()
-        })
-    };
-
     let settings = slatedb::config::Settings {
         wal_enabled,
         l0_max_ssts,
         l0_sst_size_bytes: 128 * 1024 * 1024,
         filter_bits_per_key: 10,
+        compactor_options: None,
         object_store_cache_options: ObjectStoreCacheOptions {
             root_folder: Some(cache_config.root_folder.clone()),
             max_cache_size_bytes: Some(slatedb_object_cache_bytes),
@@ -471,7 +462,6 @@ pub async fn build_slatedb(
         },
         flush_interval: Some(std::time::Duration::from_secs(30)),
         max_unflushed_bytes,
-        compactor_options,
         compression_codec: None, // Disable compression - we handle it in encryption layer
         garbage_collector_options: Some(GarbageCollectorOptions {
             wal_options: Some(GarbageCollectorDirectoryOptions {
@@ -519,19 +509,27 @@ pub async fn build_slatedb(
                 info!("Opening database in read-write mode");
             }
 
-            let mut builder = DbBuilder::new(db_path, object_store)
+            let mut builder = DbBuilder::new(db_path.clone(), object_store.clone())
                 .with_settings(settings)
                 .with_gc_runtime(runtime_handle.clone())
                 .with_sst_block_size(slatedb::SstBlockSize::Block4Kib)
-                .with_memory_cache(cache)
+                .with_db_cache(cache)
                 .with_block_transformer(block_transformer);
 
             if let Some(wal_store) = wal_object_store {
                 builder = builder.with_wal_object_store(wal_store);
             }
 
             if !disable_compactor {
-                builder = builder.with_compaction_runtime(runtime_handle.clone());
+                let compactor = CompactorBuilder::new(db_path, object_store)
+                    .with_runtime(runtime_handle.clone())
+                    .with_options(slatedb::config::CompactorOptions {
+                        max_concurrent_compactions,
+                        max_sst_size: 256 * 1024 * 1024,
+                        ..Default::default()
+                    });
+
+                builder = builder.with_compactor_builder(compactor);
             }
 
             let slatedb = Arc::new(builder.build().await?);

zerofs/src/cli/server.rs

@@ -286,18 +286,9 @@ impl ZeroFS {
         let block_transformer: Arc<dyn BlockTransformer> =
             ZeroFsBlockTransformer::new_arc(&test_key, CompressionConfig::default());
 
-        let settings = slatedb::config::Settings {
-            compression_codec: None,
-            compactor_options: Some(slatedb::config::CompactorOptions {
-                ..Default::default()
-            }),
-            ..Default::default()
-        };
-
         let db_path = Path::from("test_slatedb");
         let slatedb = Arc::new(
             DbBuilder::new(db_path, object_store)
-                .with_settings(settings)
                 .with_block_transformer(block_transformer)
                 .build()
                 .await?,
@@ -2878,18 +2869,9 @@ mod tests {
         let block_transformer: Arc<dyn BlockTransformer> =
             ZeroFsBlockTransformer::new_arc(&test_key, CompressionConfig::default());
 
-        let settings = slatedb::config::Settings {
-            compression_codec: None,
-            compactor_options: Some(slatedb::config::CompactorOptions {
-                ..Default::default()
-            }),
-            ..Default::default()
-        };
-
         let db_path = Path::from("test_slatedb");
         let slatedb = Arc::new(
             DbBuilder::new(db_path.clone(), object_store.clone())
-                .with_settings(settings)
                 .with_block_transformer(block_transformer)
                 .build()
                 .await

zerofs/src/fs/mod.rs

@@ -44,16 +44,9 @@ impl CrashTestContext {
 
     /// Create a new filesystem instance
     async fn create_fs(&self) -> Arc<ZeroFS> {
-        let settings = Settings {
-            compression_codec: None,
-            compactor_options: Some(slatedb::config::CompactorOptions::default()),
-            ..Default::default()
-        };
-
         let db_path = Path::from("slatedb");
         let slatedb = Arc::new(
             DbBuilder::new(db_path, Arc::clone(&self.object_store))
-                .with_settings(settings)
                 .build()
                 .await
                 .unwrap(),