Fix rollback cleanup for safepoint-flushed buffers

Port the LiteDB PR litedb-org#2657 change that avoids discarding snapshot buffers after they have already been transitioned out of writable state by a safepoint/WAL flush.

Update TransactionService rollback/dispose cleanup to discard only buffers whose ShareCounter is still BUFFER_WRITABLE. This covers the async rollback, sync rollback, and dispose paths.

Add focused regression tests for readable dirty collection-page buffers to verify rollback and disposal no longer fail after safepoint-style buffer transitions.

Validated with targeted transaction tests, engine tests, and the full LiteDbX.Tests suite. 290 passing tests.

Author: surgicalcoder

LiteDBX.Tests/Engine/Transactions_Tests.cs

@@ -13,6 +13,28 @@ public class Transactions_Tests
 {
     private static readonly TimeSpan CoordinationTimeout = TimeSpan.FromSeconds(5);
 
+    private static async Task<(LiteTransaction transaction, TransactionService service)> CreateTransactionWithReadableDirtyCollectionPage(
+        LiteDatabase db,
+        string collectionName,
+        string indexName)
+    {
+        var collection = db.GetCollection<Person>(collectionName);
+        await collection.Insert(new Person { Id = 1, Name = "seed" });
+
+        var transaction = (LiteTransaction)await db.BeginTransaction();
+        var service = transaction.Service;
+        var snapshot = await service.CreateSnapshotAsync(LockMode.Write, collectionName, addIfNotExists: false);
+
+        snapshot.CollectionPage.InsertCollectionIndex(indexName, "$.Name", unique: false);
+        snapshot.CollectionPage.IsDirty.Should().BeTrue();
+
+        // Simulate a safepoint-flushed page buffer: the page is still tracked by the snapshot,
+        // but the underlying buffer is no longer writable.
+        snapshot.CollectionPage.Buffer.ShareCounter = 0;
+
+        return (transaction, service);
+    }
+
     private static Task RunIsolated(Func<Task> action)
     {
         using (ExecutionContext.SuppressFlow())
@@ -242,4 +264,55 @@ public async Task Test_Transaction_Rollback_On_Dispose()
 
         (await col.Count()).Should().Be(0);
     }
+
+    [Fact]
+    public async Task Transaction_RollbackAsync_Ignores_Readable_Safepoint_Buffers()
+    {
+        await using var db = new LiteDatabase(new MemoryStream());
+        var (transaction, service) = await CreateTransactionWithReadableDirtyCollectionPage(db, "rollback_async", "idx_async");
+
+        try
+        {
+            await FluentActions.Invoking(() => service.RollbackAsync().AsTask()).Should().NotThrowAsync();
+            service.State.Should().Be(TransactionState.Aborted);
+        }
+        finally
+        {
+            await transaction.DisposeAsync();
+        }
+    }
+
+    [Fact]
+    public async Task Transaction_Rollback_Ignores_Readable_Safepoint_Buffers()
+    {
+        await using var db = new LiteDatabase(new MemoryStream());
+        var (transaction, service) = await CreateTransactionWithReadableDirtyCollectionPage(db, "rollback_sync", "idx_sync");
+
+        try
+        {
+            service.Invoking(x => x.Rollback()).Should().NotThrow();
+            service.State.Should().Be(TransactionState.Aborted);
+        }
+        finally
+        {
+            await transaction.DisposeAsync();
+        }
+    }
+
+    [Fact]
+    public async Task Transaction_Dispose_Ignores_Readable_Safepoint_Buffers()
+    {
+        await using var db = new LiteDatabase(new MemoryStream());
+        var (transaction, service) = await CreateTransactionWithReadableDirtyCollectionPage(db, "rollback_dispose", "idx_dispose");
+
+        try
+        {
+            service.Invoking(x => x.Dispose()).Should().NotThrow();
+            service.State.Should().Be(TransactionState.Disposed);
+        }
+        finally
+        {
+            await transaction.DisposeAsync();
+        }
+    }
 }

LiteDBX/Engine/Services/TransactionService.cs

@@ -385,6 +385,14 @@ public void Commit()
         State = TransactionState.Committed;
     }
 
+    private static IEnumerable<PageBuffer> GetStillWritableBuffers(Snapshot snapshot, bool dirty)
+    {
+        return snapshot
+            .GetWritablePages(dirty, true)
+            .Select(x => x.Buffer)
+            .Where(x => x.ShareCounter == BUFFER_WRITABLE);
+    }
+
     /// <summary>
     /// Asynchronously rollback the transaction: discard dirty pages, return new pages, dispose snapshots.
     ///
@@ -403,8 +411,8 @@ public async ValueTask RollbackAsync(CancellationToken ct = default)
         {
             if (snapshot.Mode == LockMode.Write)
             {
-                _disk.DiscardDirtyPages(snapshot.GetWritablePages(true, true).Select(x => x.Buffer));
-                _disk.DiscardCleanPages(snapshot.GetWritablePages(false, true).Select(x => x.Buffer));
+                _disk.DiscardDirtyPages(GetStillWritableBuffers(snapshot, true));
+                _disk.DiscardCleanPages(GetStillWritableBuffers(snapshot, false));
             }
 
             snapshot.Dispose();
@@ -430,8 +438,8 @@ public void Rollback()
         {
             if (snapshot.Mode == LockMode.Write)
             {
-                _disk.DiscardDirtyPages(snapshot.GetWritablePages(true, true).Select(x => x.Buffer));
-                _disk.DiscardCleanPages(snapshot.GetWritablePages(false, true).Select(x => x.Buffer));
+                _disk.DiscardDirtyPages(GetStillWritableBuffers(snapshot, true));
+                _disk.DiscardCleanPages(GetStillWritableBuffers(snapshot, false));
             }
 
             snapshot.Dispose();
@@ -577,8 +585,8 @@ protected virtual void Dispose(bool dispose)
             {
                 if (snapshot.Mode == LockMode.Write)
                 {
-                    _disk.DiscardDirtyPages(snapshot.GetWritablePages(true, true).Select(x => x.Buffer));
-                    _disk.DiscardCleanPages(snapshot.GetWritablePages(false, true).Select(x => x.Buffer));
+                    _disk.DiscardDirtyPages(GetStillWritableBuffers(snapshot, true));
+                    _disk.DiscardCleanPages(GetStillWritableBuffers(snapshot, false));
                 }
 
                 // Always dispose snapshots so write snapshots release collection locks.