Update lifecycle for compaction, truncate, improve bftree file management

.github/workflows/ci.yml

@@ -93,6 +93,11 @@ jobs:
         uses: actions/setup-dotnet@v4
       - name: Setup Rust toolchain
         uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          # Garnet's only Cargo workspace is the bftree native binding; the repo root has no
+          # Cargo.toml, so the action's default `cache-workspaces: ". -> target"` causes
+          # rust-cache's `cargo metadata` to fail with "could not find Cargo.toml" (exit 101).
+          cache-workspaces: libs/native/bftree-garnet
       - name: Install dependencies
         run: dotnet restore
       - name: Build Garnet

libs/host/GarnetServer.cs

@@ -308,8 +308,21 @@ private GarnetDatabase CreateDatabase(int dbId, GarnetServerOptions serverOption
             CustomCommandManager customCommandManager)
         {
             var removeOutdated = !serverOptions.EnableCluster;
-            var rangeIndexDataDir = Path.Combine(serverOptions.CheckpointBaseDirectory, GarnetServerOptions.GetCheckpointDirectoryName(dbId));
-            var rangeIndexManager = new RangeIndexManager(serverOptions.EnableRangeIndexPreview, rangeIndexDataDir,
+
+            // Two-roots layout for RangeIndex files:
+            //  riLogRoot — log-tied (working file + per-flush snapshots), co-located with hlog.
+            //              Falls back through LogDir → CheckpointDir → cwd, mirroring Tsavorite's
+            //              CheckpointBaseDirectory chain so RangeIndex works without storage tier.
+            //  cprDir    — checkpoint-tied (per-token snapshots live under <token>/rangeindex/),
+            //              alongside Tsavorite's cpr-checkpoints/<token>/info.dat etc.
+            var logRootBase = serverOptions.LogDir
+                              ?? serverOptions.CheckpointDir
+                              ?? Directory.GetCurrentDirectory();
+            var riLogRoot = Path.Combine(logRootBase ?? string.Empty, "Store", "rangeindex");
+            var cprDir = Path.Combine(serverOptions.GetStoreCheckpointDirectory(dbId), "cpr-checkpoints");
+
+            var rangeIndexManager = new RangeIndexManager(serverOptions.EnableRangeIndexPreview,
+                riLogRoot: riLogRoot, cprDir: cprDir,
                 removeOutdatedCheckpoints: removeOutdated, loggerFactory?.CreateLogger("RangeIndexManager"));
             var store = CreateStore(dbId, clusterFactory, customCommandManager, storeEpoch, rangeIndexManager, out var stateMachineDriver, out var sizeTracker, out var kvSettings);
             var aof = CreateAOF(dbId);

libs/native/bftree-garnet/BfTreeService.cs

@@ -501,7 +501,35 @@ public void Snapshot(string snapshotPath = null)
         }
 
         /// <summary>
-        /// Snapshot the BfTree to a specified target file for flush persistence.
+        /// Snapshot a disk-backed BfTree to a target file, given only its native handle (no managed wrapper).
+        /// Used by RangeIndex's <c>OnFlush</c> path which has direct access to the stub's TreeHandle but not
+        /// the managed <see cref="BfTreeService"/> instance.
+        /// <para>Mirrors instance <see cref="SnapshotToFile"/>: invokes <c>bftree_snapshot(handle)</c> to drain
+        /// the circular buffer to the data file, then <c>System.IO.File.Copy</c> from
+        /// <paramref name="dataPath"/> to <paramref name="targetPath"/>.</para>
+        /// </summary>
+        /// <param name="handle">Native BfTree pointer (from the stub's <c>TreeHandle</c>).</param>
+        /// <param name="dataPath">Path of the live working file used by the BfTree
+        /// (e.g. <c>{root}/&lt;hash&gt;.data.bftree</c>).</param>
+        /// <param name="targetPath">Destination path for the snapshot copy.</param>
+        public static void SnapshotToFileByPtr(nint handle, string dataPath, string targetPath)
+        {
+            if (handle == nint.Zero)
+                throw new ArgumentException("Native handle is null.", nameof(handle));
+            if (string.IsNullOrEmpty(dataPath))
+                throw new ArgumentException("dataPath is required.", nameof(dataPath));
+            if (string.IsNullOrEmpty(targetPath))
+                throw new ArgumentException("targetPath is required.", nameof(targetPath));
+
+            int result = NativeBfTreeMethods.bftree_snapshot(handle);
+            if (result != 0)
+                throw new InvalidOperationException("Failed to snapshot disk-backed BfTree before file copy.");
+
+            System.IO.File.Copy(dataPath, targetPath, overwrite: true);
+        }
+
+        /// <summary>
+        /// Snapshot a BfTree to a specified target file for flush persistence.
         /// For disk-backed trees: performs in-place snapshot, then copies the data file to <paramref name="targetPath"/>.
         /// For memory-only trees: serializes directly to <paramref name="targetPath"/>.
         /// </summary>