From 790708441104affafe3f20a1158f4ce68bb7e394 Mon Sep 17 00:00:00 2001 From: Alessandro Giorgetti Date: Tue, 17 Nov 2026 10:50:57 +0100 Subject: [PATCH 1/3] fix: align async Mongo exception boundaries with sync reads Co-authored-by: Alessandro Giorgetti Co-authored-by: Codex (OpenAI) --- Changelog.md | 6 + .../Issues/Issue108AsyncExceptionOrigin.cs | 340 ++++++++++++++++++ .../Issues/Issue86CancellationTests.Async.cs | 5 +- .../MongoPersistenceEngine.Async.cs | 223 ++++++------ .../MongoPersistenceOptions.cs | 8 + 5 files changed, 463 insertions(+), 119 deletions(-) create mode 100644 src/NEventStore.Persistence.MongoDB.Tests/AcceptanceTests/Issues/Issue108AsyncExceptionOrigin.cs diff --git a/Changelog.md b/Changelog.md index f95ac5f..1f2a0e8 100644 --- a/Changelog.md +++ b/Changelog.md @@ -28,6 +28,10 @@ ### Breaking Changes +- Async observer reads now use `EnumerateMongoAsync` to translate only cursor acquisition and advancement errors, matching synchronous `EnumerateMongo`. Mongo exceptions from application deserializers, `OnNextAsync`, and cursor disposal reach `OnErrorAsync` unchanged instead of being wrapped as storage failures. Driver errors still retain the original exception as `InnerException`. No public observer signatures change. [#108](https://github.com/NEventStore/NEventStore.Persistence.MongoDB/issues/108) + +- Default async observer reads invoke the protected `Task`-returning (non-result) `TryMongoAsync` guard for acquisition and each batch advance, with no observer argument, rather than once around the whole read. The existing result-returning guard overload is not used by these observer reads. Overrides no longer encompass application callbacks or cleanup. Per-batch calls enforce disposed-engine checks like sync enumeration. Cursor disposal remains unconditional and outside translation, like sync `using`; a cleanup failure may replace an earlier error under normal `using` semantics. [#108](https://github.com/NEventStore/NEventStore.Persistence.MongoDB/issues/108) + - `EmptyRecycleBin()` and `EmptyRecycleBinAsync(...)` now translate checkpoint-read driver failures to `StorageException` or `StorageUnavailableException` (for `MongoConnectionException`), retaining the original inner exception. Consumers catching raw driver exceptions must handle the persistence exceptions instead. The existing protected virtual guard is still invoked once, but its callback now includes checkpoint acquisition and iteration before deletion. Non-driver exceptions and cancellation retain their identity. [#107](https://github.com/NEventStore/NEventStore.Persistence.MongoDB/issues/107) - Synchronous reads reuse one cursor `MoveNext` callback per enumeration. Both protected virtual `TryMongo` overloads are still called for cursor acquisition and every batch attempt, including completion. Source and binary APIs are unchanged, but overrides that inspect callback reference identity now observe the same callback within an enumeration. [#91](https://github.com/NEventStore/NEventStore.Persistence.MongoDB/issues/91) @@ -42,6 +46,8 @@ ### Migration notes +- For async observer reads, handle application Mongo exceptions directly in `OnErrorAsync`. Set `MongoPersistenceOptions.WrapAsyncApplicationExceptions = true` to select the legacy whole-read guard once per operation, restoring legacy application/cleanup wrapping and protected guard scope. The option is read once per read and does not alter other async operations. Subclasses relying on whole-read timing, retries or interception should opt out or adapt to the new driver-operation scope. Cancellation, early-stop completion and terminal callback failures retain their observer contract. [#108](https://github.com/NEventStore/NEventStore.Persistence.MongoDB/issues/108) + - `Initialize()` now creates `GetFrom_RecycleBin_Index` on existing databases. No data backfill or old-index replacement is required, but deployments must budget index build time and disk/I/O costs and retain index-creation permission. Operators can pre-create the documented definition to move build work out of startup. See [recycle-bin rollout and indexing](docs/Recycle-Bin.md#recycle-lookup-index-and-deployment). [#87](https://github.com/NEventStore/NEventStore.Persistence.MongoDB/issues/87) ## 12.1.0 diff --git a/src/NEventStore.Persistence.MongoDB.Tests/AcceptanceTests/Issues/Issue108AsyncExceptionOrigin.cs b/src/NEventStore.Persistence.MongoDB.Tests/AcceptanceTests/Issues/Issue108AsyncExceptionOrigin.cs new file mode 100644 index 0000000..ab27aa5 --- /dev/null +++ b/src/NEventStore.Persistence.MongoDB.Tests/AcceptanceTests/Issues/Issue108AsyncExceptionOrigin.cs @@ -0,0 +1,340 @@ +#if NUNIT +using FakeItEasy; +using FluentAssertions; +using MongoDB.Bson; +using MongoDB.Driver; +using NEventStore.Persistence.AcceptanceTests; +using NEventStore.Persistence.AcceptanceTests.BDD; +using NEventStore.Serialization; +using NUnit.Framework; + +namespace NEventStore.Persistence.MongoDB.Tests.AcceptanceTests.Issues +{ + // Application failures must not be misidentified as event-store outages. + [TestFixtureSource(nameof(Cases))] + public class when_Issue108_an_async_read_fails(int path, string stage, string kind, bool legacy) : SpecificationBase + { + public static IEnumerable Cases => + from path in Enumerable.Range(0, 7) + from stage in new[] { "serializer", "observer throw", "observer task", "observer delayed", "early stop", "find", "later batch", "dispose" } + where path != 5 || stage != "serializer" + from kind in new[] { "mongo", "connection", "other" } + where stage != "early stop" || kind == "other" + from legacy in new[] { false, true } + select new object[] { path, stage, kind, legacy }; + + private readonly CancellationTokenSource _cancellation = new(); + private readonly IAsyncCursor _cursor = A.Fake>(); + private ProbeEngine _engine = null!; + private Exception _failure = null!; + private Exception? _reported; + private Exception? _escaped; + private readonly TaskCompletionSource _resume = new(TaskCreationOptions.RunContinuationsAsynchronously); + private int _nextCalls; + private int _errors; + private int _completions; + + protected override void Context() + { + _failure = EnumerationProbe.Failure(kind); + var database = A.Fake(); + var collection = A.Fake>(); + var serializer = A.Fake(); + A.CallTo(() => collection.Settings).Returns(new MongoCollectionSettings()); + A.CallTo(() => collection.WithWriteConcern(A._)).Returns(collection); + A.CallTo(() => database.GetCollection(A._, A._)).Returns(collection); + A.CallTo(() => serializer.Deserialize(A._)).Throws(_failure); + A.CallTo(() => collection.FindAsync(A>._, + A>._, _cancellation.Token)) + .ReturnsLazily(() => stage == "find" + ? Task.FromException>(_failure) + : Task.FromResult(_cursor)); + int batch = 0; + A.CallTo(() => _cursor.MoveNextAsync(_cancellation.Token)).ReturnsLazily(() => + { + batch++; + return batch == 2 && stage == "later batch" + ? Task.FromException(_failure) : Task.FromResult(batch == 1); + }); + A.CallTo(() => _cursor.Current).Returns(new[] { Document(path == 5 ? 7 : 0, 1, stage == "serializer") }); + if (stage == "dispose") A.CallTo(() => _cursor.Dispose()).Throws(_failure); + _engine = new ProbeEngine(database, serializer, legacy); + } + + private IAsyncObserver Observer() + { + var observer = A.Fake>(); + A.CallTo(() => observer.OnNextAsync(A._, _cancellation.Token)).ReturnsLazily(() => + { + _nextCalls++; + if (stage == "observer throw") throw _failure; + if (stage == "observer delayed") return FailAfterResumeAsync(); + if (stage == "early stop") return Task.FromResult(false); + return stage == "observer task" ? Task.FromException(_failure) : Task.FromResult(true); + }); + A.CallTo(() => observer.OnErrorAsync(A._, _cancellation.Token)) + .ReturnsLazily((Exception error, CancellationToken token) => + { + _reported = error; + _errors++; + return Task.CompletedTask; + }); + A.CallTo(() => observer.OnCompletedAsync(_cancellation.Token)).ReturnsLazily(() => + { + _completions++; + return Task.CompletedTask; + }); + return observer; + } + + private async Task FailAfterResumeAsync() + { + await _resume.Task.ConfigureAwait(false); + throw _failure; + } + + protected override async Task BecauseAsync() + { + var observer = Observer(); + var operation = Catch.ExceptionAsync(() => path switch + { + 0 => _engine.GetFromAsync("bucket", "stream", 0, int.MaxValue, observer, _cancellation.Token), + 1 => _engine.GetFromAsync("bucket", 0L, observer, _cancellation.Token), + 2 => _engine.GetFromToAsync("bucket", 0L, long.MaxValue, observer, _cancellation.Token), + 3 => _engine.GetFromAsync(0L, observer, _cancellation.Token), + 4 => _engine.GetFromToAsync(0L, long.MaxValue, observer, _cancellation.Token), + 5 => _engine.GetStreamsToSnapshotAsync("bucket", 0, Observer(), _cancellation.Token), + _ => _engine.GetDeletedCommitsAsync(observer, _cancellation.Token) + }); + if (stage == "observer delayed") operation.IsCompleted.Should().BeFalse(); + _resume.TrySetResult(true); + _escaped = await operation.ConfigureAwait(false); + } + + [Fact] + public void Should_translate_only_storage_failures_unless_legacy_behavior_is_requested() + { + _escaped.Should().BeNull(); + if (stage == "early stop") + { + _reported.Should().BeNull(); + return; + } + if (stage == "observer delayed") + _failure.StackTrace.Should().Contain(nameof(FailAfterResumeAsync)); + if (kind == "other" || (!legacy && (stage == "dispose" || stage == "serializer" || stage.StartsWith("observer")))) _reported.Should().BeSameAs(_failure); + else + { + _reported.Should().BeOfType(kind == "connection" ? typeof(StorageUnavailableException) : typeof(StorageException)); + _reported!.InnerException.Should().BeSameAs(_failure); + } + } + + [Fact] + public void Should_preserve_notification_and_resource_contracts() + { + // Driver guards never enclose application work in the default mode. + if (stage == "find" || stage == "later batch" || (legacy && stage != "early stop")) + _engine.CallbackFailure.Should().BeSameAs(_failure); + else + _engine.CallbackFailure.Should().BeNull(); + _engine.WrapperCalls.Should().Be(legacy ? 1 : stage == "find" ? 1 : stage == "later batch" || stage == "dispose" ? 3 : 2); + _engine.Token.Should().Be(_cancellation.Token); + _errors.Should().Be(stage == "early stop" ? 0 : 1); + _completions.Should().Be(stage == "early stop" ? 1 : 0); + _nextCalls.Should().Be(stage == "find" || stage == "serializer" ? 0 : 1); + if (stage == "find") A.CallTo(() => _cursor.Dispose()).MustNotHaveHappened(); + else A.CallTo(() => _cursor.Dispose()).MustHaveHappenedOnceExactly(); + if (stage == "early stop") + A.CallTo(() => _cursor.MoveNextAsync(_cancellation.Token)).MustHaveHappenedOnceExactly(); + } + + protected override void Cleanup() + { + _engine.Dispose(); + _cancellation.Dispose(); + } + + private sealed class ProbeEngine(IMongoDatabase database, IDocumentSerializer serializer, bool legacy) + : MongoPersistenceEngine(database, serializer, new MongoPersistenceOptions { WrapAsyncApplicationExceptions = legacy }) + { + public Exception? CallbackFailure { get; private set; } + public int WrapperCalls { get; private set; } + public CancellationToken Token { get; private set; } + protected override Task TryMongoAsync(Func callbackAsync, CancellationToken cancellationToken, IAsyncObserver? asyncObserver = null) + { + WrapperCalls++; + Token = cancellationToken; + return base.TryMongoAsync(async () => + { + try { await callbackAsync().ConfigureAwait(false); } + catch (Exception error) { CallbackFailure = error; throw; } + }, cancellationToken, asyncObserver); + } + } + private static BsonDocument Document(int path, int batch, bool serializedPayload) + { + if (path == 7) + return new BsonDocument + { + { MongoStreamHeadFields.Id, new BsonDocument + { + { MongoStreamHeadFields.BucketId, "bucket" }, + { MongoStreamHeadFields.StreamId, "stream" } + } + }, + { MongoStreamHeadFields.HeadRevision, batch }, + { MongoStreamHeadFields.SnapshotRevision, 0 } + }; + return new BsonDocument + { + { MongoCommitFields.CheckpointNumber, (long)batch }, + { MongoCommitFields.BucketId, "bucket" }, + { MongoCommitFields.StreamId, "stream" }, + { MongoCommitFields.StreamRevisionFrom, batch }, + { MongoCommitFields.StreamRevisionTo, batch }, + { MongoCommitFields.CommitSequence, batch }, + { MongoCommitFields.CommitStamp, new BsonDateTime(DateTime.UtcNow) }, + { MongoCommitFields.Headers, new BsonArray() }, + { MongoCommitFields.Events, serializedPayload + ? new BsonArray { new BsonDocument(MongoCommitFields.Payload, new BsonBinaryData(new byte[] { 1 })) } + : new BsonArray() + } + }; + } + + } + // Application failures must not be misidentified as event-store outages. + [TestFixtureSource(nameof(Cases))] + public class when_Issue108_an_async_read_notifies(int path, string stage, bool legacy) : SpecificationBase + { + public static IEnumerable Cases => + from path in Enumerable.Range(0, 7) + from stage in new[] { "cancel", "active cancellation", "complete failure", "error failure" } + from legacy in new[] { false, true } + select new object[] { path, stage, legacy }; + + private readonly CancellationTokenSource _cancellation = new(); + private readonly IAsyncCursor _cursor = A.Fake>(); + private MongoPersistenceEngine _engine = null!; + private Exception _failure = null!; + private Exception? _reported; + private Exception? _escaped; + private readonly Exception _terminalFailure = new MongoException("terminal callback failure"); + private int _nextCalls; + private int _errors; + private int _completions; + + protected override void Context() + { + _failure = new OperationCanceledException(_cancellation.Token); + var database = A.Fake(); + var collection = A.Fake>(); + var serializer = A.Fake(); + A.CallTo(() => collection.Settings).Returns(new MongoCollectionSettings()); + A.CallTo(() => collection.WithWriteConcern(A._)).Returns(collection); + A.CallTo(() => database.GetCollection(A._, A._)).Returns(collection); + A.CallTo(() => collection.FindAsync(A>._, + A>._, _cancellation.Token)) + .Returns(Task.FromResult(_cursor)); + int batch = 0; + A.CallTo(() => _cursor.MoveNextAsync(_cancellation.Token)) + .ReturnsLazily(() => Task.FromResult(++batch == 1)); + A.CallTo(() => _cursor.Current).Returns(new[] { Document(path == 5) }); + _engine = new MongoPersistenceEngine(database, serializer, + new MongoPersistenceOptions { WrapAsyncApplicationExceptions = legacy }); + } + + private IAsyncObserver Observer() + { + var observer = A.Fake>(); + A.CallTo(() => observer.OnNextAsync(A._, _cancellation.Token)).ReturnsLazily(() => + { + _nextCalls++; + if (stage == "cancel") _cancellation.Cancel(); + if (stage != "complete failure") return Task.FromException(_failure); + + return Task.FromResult(true); + }); + A.CallTo(() => observer.OnErrorAsync(A._, _cancellation.Token)) + .ReturnsLazily((Exception error, CancellationToken token) => + { + _reported = error; + _errors++; + return stage == "error failure" ? Task.FromException(_terminalFailure) : Task.CompletedTask; + }); + A.CallTo(() => observer.OnCompletedAsync(_cancellation.Token)).ReturnsLazily(() => + { + _completions++; + return stage == "complete failure" ? Task.FromException(_terminalFailure) : Task.CompletedTask; + }); + return observer; + } + + protected override async Task BecauseAsync() + { + var observer = Observer(); + var operation = Catch.ExceptionAsync(() => path switch + { + 0 => _engine.GetFromAsync("bucket", "stream", 0, int.MaxValue, observer, _cancellation.Token), + 1 => _engine.GetFromAsync("bucket", 0L, observer, _cancellation.Token), + 2 => _engine.GetFromToAsync("bucket", 0L, long.MaxValue, observer, _cancellation.Token), + 3 => _engine.GetFromAsync(0L, observer, _cancellation.Token), + 4 => _engine.GetFromToAsync(0L, long.MaxValue, observer, _cancellation.Token), + 5 => _engine.GetStreamsToSnapshotAsync("bucket", 0, Observer(), _cancellation.Token), + _ => _engine.GetDeletedCommitsAsync(observer, _cancellation.Token) + }); + _escaped = await operation.ConfigureAwait(false); + } + + [Fact] + public void Should_notify_once_without_reclassifying_terminal_failures() + { + bool error = stage == "active cancellation" || stage == "error failure"; + _errors.Should().Be(error ? 1 : 0); + _completions.Should().Be(error ? 0 : 1); + if (error) _reported.Should().BeSameAs(_failure); + else _reported.Should().BeNull(); + if (stage.EndsWith("failure")) _escaped.Should().BeSameAs(_terminalFailure); + else _escaped.Should().BeNull(); + _nextCalls.Should().Be(1); + A.CallTo(() => _cursor.Dispose()).MustHaveHappenedOnceExactly(); + } + + protected override void Cleanup() + { + _engine.Dispose(); + _cancellation.Dispose(); + } + + private static BsonDocument Document(bool streamHead) + { + if (streamHead) + return new BsonDocument + { + { MongoStreamHeadFields.Id, new BsonDocument + { + { MongoStreamHeadFields.BucketId, "bucket" }, + { MongoStreamHeadFields.StreamId, "stream" } + } + }, + { MongoStreamHeadFields.HeadRevision, 1 }, + { MongoStreamHeadFields.SnapshotRevision, 0 } + }; + return new BsonDocument + { + { MongoCommitFields.CheckpointNumber, (long)1 }, + { MongoCommitFields.BucketId, "bucket" }, + { MongoCommitFields.StreamId, "stream" }, + { MongoCommitFields.StreamRevisionFrom, 1 }, + { MongoCommitFields.StreamRevisionTo, 1 }, + { MongoCommitFields.CommitSequence, 1 }, + { MongoCommitFields.CommitStamp, new BsonDateTime(DateTime.UtcNow) }, + { MongoCommitFields.Headers, new BsonArray() }, + { MongoCommitFields.Events, new BsonArray() } + }; + } + + } +} +#endif diff --git a/src/NEventStore.Persistence.MongoDB.Tests/AcceptanceTests/Issues/Issue86CancellationTests.Async.cs b/src/NEventStore.Persistence.MongoDB.Tests/AcceptanceTests/Issues/Issue86CancellationTests.Async.cs index 85400c8..6abe931 100644 --- a/src/NEventStore.Persistence.MongoDB.Tests/AcceptanceTests/Issues/Issue86CancellationTests.Async.cs +++ b/src/NEventStore.Persistence.MongoDB.Tests/AcceptanceTests/Issues/Issue86CancellationTests.Async.cs @@ -459,7 +459,10 @@ public void Should_await_the_terminal_callback_and_preserve_the_original_token() [Fact] public void Should_deliver_exactly_one_terminal_notification() { - Engine.WrapperCalls.Should().Be(1, "observer reads must still dispatch through the protected virtual wrapper"); + int expectedDriverCalls = _mode == "canceled" ? 1 + : _mode == "success" || _mode.StartsWith("completion-", StringComparison.Ordinal) ? 3 : 2; + Engine.WrapperCalls.Should().Be(expectedDriverCalls, + "default reads guard acquisition and each batch advance, not application callbacks"); bool unrelatedCancellation = _mode.StartsWith("next-unrelated-", StringComparison.Ordinal) || _mode == "next-tokenless-operation-canceled"; bool dataError = _mode == "next-error" || unrelatedCancellation || _mode.StartsWith("error-callback-", StringComparison.Ordinal); _completed.Should().Be(dataError ? 0 : 1); diff --git a/src/NEventStore.Persistence.MongoDB/MongoPersistenceEngine.Async.cs b/src/NEventStore.Persistence.MongoDB/MongoPersistenceEngine.Async.cs index ceb1b27..df99a05 100644 --- a/src/NEventStore.Persistence.MongoDB/MongoPersistenceEngine.Async.cs +++ b/src/NEventStore.Persistence.MongoDB/MongoPersistenceEngine.Async.cs @@ -15,7 +15,7 @@ public Task GetFromAsync(string bucketId, string streamId, int minRevision, int { MongoPersistenceEngineLogMessages.GettingAllCommitsBetween(Logger, streamId, bucketId, minRevision, maxRevision); - return ObserveMongoAsync(async () => + return ObserveMongoAsync(async legacy => { var filters = new List>() { @@ -37,23 +37,13 @@ public Task GetFromAsync(string bucketId, string streamId, int minRevision, int var query = Builders.Filter.And(filters); - using var cursor = await PersistedCommits + await EnumerateMongoAsync( + () => PersistedCommits .Find(query) .Sort(SortByAscendingStreamRevisionFrom) - .ToCursorAsync(cancellationToken) - .ConfigureAwait(false); - - while (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false)) - { - foreach (var doc in cursor.Current) - { - var res = await observer.OnNextAsync(doc.ToCommit(_serializer), cancellationToken).ConfigureAwait(false); - if (!res) - { - return; - } - } - } + .ToCursorAsync(cancellationToken), + doc => observer.OnNextAsync(doc.ToCommit(_serializer), cancellationToken), + legacy, cancellationToken).ConfigureAwait(false); }, observer, cancellationToken); } @@ -63,7 +53,7 @@ public Task GetFromAsync(string bucketId, long checkpointToken, IAsyncObserver + return ObserveMongoAsync(async legacy => { var query = Builders.Filter.Eq(MongoCommitFields.BucketId, bucketId); if (checkpointToken > 0) @@ -73,22 +63,13 @@ public Task GetFromAsync(string bucketId, long checkpointToken, IAsyncObserver.Filter.Gt(MongoCommitFields.CheckpointNumber, checkpointToken) ); } - using var cursor = await PersistedCommits + await EnumerateMongoAsync( + () => PersistedCommits .Find(query) .Sort(SortByAscendingCheckpointNumber) - .ToCursorAsync(cancellationToken) - .ConfigureAwait(false); - while (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false)) - { - foreach (var doc in cursor.Current) - { - var res = await asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken).ConfigureAwait(false); - if (!res) - { - return; - } - } - } + .ToCursorAsync(cancellationToken), + doc => asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken), + legacy, cancellationToken).ConfigureAwait(false); }, asyncObserver, cancellationToken); @@ -99,7 +80,7 @@ public Task GetFromToAsync(string bucketId, long fromCheckpointToken, long toChe { MongoPersistenceEngineLogMessages.GettingCommitsFromBucketAndFromToCheckpoint(Logger, bucketId, fromCheckpointToken, toCheckpointToken); - return ObserveMongoAsync(async () => + return ObserveMongoAsync(async legacy => { var filters = new List>() { @@ -118,22 +99,13 @@ public Task GetFromToAsync(string bucketId, long fromCheckpointToken, long toChe ); } var query = Builders.Filter.And(filters); - using var cursor = await PersistedCommits + await EnumerateMongoAsync( + () => PersistedCommits .Find(query) .Sort(SortByAscendingCheckpointNumber) - .ToCursorAsync(cancellationToken) - .ConfigureAwait(false); - while (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false)) - { - foreach (var doc in cursor.Current) - { - var res = await asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken).ConfigureAwait(false); - if (!res) - { - return; - } - } - } + .ToCursorAsync(cancellationToken), + doc => asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken), + legacy, cancellationToken).ConfigureAwait(false); }, asyncObserver, cancellationToken); @@ -144,7 +116,7 @@ public Task GetFromAsync(long checkpointToken, IAsyncObserver asyncObse { MongoPersistenceEngineLogMessages.GettingAllCommitsFromCheckpoint(Logger, checkpointToken); - return ObserveMongoAsync(async () => + return ObserveMongoAsync(async legacy => { var query = Builders.Filter.Ne(MongoCommitFields.BucketId, MongoSystemBuckets.RecycleBin); if (checkpointToken > 0) @@ -154,22 +126,13 @@ public Task GetFromAsync(long checkpointToken, IAsyncObserver asyncObse Builders.Filter.Gt(MongoCommitFields.CheckpointNumber, checkpointToken) ); } - using var cursor = await PersistedCommits + await EnumerateMongoAsync( + () => PersistedCommits .Find(query) .Sort(SortByAscendingCheckpointNumber) - .ToCursorAsync(cancellationToken) - .ConfigureAwait(false); - while (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false)) - { - foreach (var doc in cursor.Current) - { - var res = await asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken).ConfigureAwait(false); - if (!res) - { - return; - } - } - } + .ToCursorAsync(cancellationToken), + doc => asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken), + legacy, cancellationToken).ConfigureAwait(false); }, asyncObserver, cancellationToken); @@ -180,7 +143,7 @@ public Task GetFromToAsync(long fromCheckpointToken, long toCheckpointToken, IAs { MongoPersistenceEngineLogMessages.GettingCommitsFromToCheckpoint(Logger, fromCheckpointToken, toCheckpointToken); - return ObserveMongoAsync(async () => + return ObserveMongoAsync(async legacy => { var filters = new List>() { @@ -200,22 +163,13 @@ public Task GetFromToAsync(long fromCheckpointToken, long toCheckpointToken, IAs } var query = Builders.Filter.And(filters); - using var cursor = await PersistedCommits + await EnumerateMongoAsync( + () => PersistedCommits .Find(query) .Sort(SortByAscendingCheckpointNumber) - .ToCursorAsync(cancellationToken) - .ConfigureAwait(false); - while (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false)) - { - foreach (var doc in cursor.Current) - { - var res = await asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken).ConfigureAwait(false); - if (!res) - { - return; - } - } - } + .ToCursorAsync(cancellationToken), + doc => asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken), + legacy, cancellationToken).ConfigureAwait(false); }, asyncObserver, cancellationToken); @@ -338,29 +292,19 @@ public Task GetStreamsToSnapshotAsync(string bucketId, int maxThreshold, IAsyncO MongoPersistenceEngineLogMessages.GettingStreamsToSnapshot(Logger); - return ObserveMongoAsync(async () => + return ObserveMongoAsync(async legacy => { var query = Builders.Filter.And( Builders.Filter.Eq(MongoStreamHeadFields.FullQualifiedBucketId, bucketId), Builders.Filter.Gte(MongoStreamHeadFields.Unsnapshotted, maxThreshold) ); - using var cursor = await PersistedStreamHeads + await EnumerateMongoAsync( + () => PersistedStreamHeads .Find(query) .Sort(Builders.Sort.Descending(MongoStreamHeadFields.Unsnapshotted)) - .ToCursorAsync(cancellationToken) - .ConfigureAwait(false); - - while (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false)) - { - foreach (var doc in cursor.Current) - { - var res = await asyncObserver.OnNextAsync(doc.ToStreamHead(), cancellationToken).ConfigureAwait(false); - if (!res) - { - return; - } - } - } + .ToCursorAsync(cancellationToken), + doc => asyncObserver.OnNextAsync(doc.ToStreamHead(), cancellationToken), + legacy, cancellationToken).ConfigureAwait(false); }, asyncObserver, cancellationToken); } @@ -623,22 +567,74 @@ protected virtual async Task TryMongoAsync(Func callbackAsync, Cancella } } - // Successful observer completion must run outside TryMongoAsync's guarded operation. - // Otherwise an OnCompletedAsync failure would be caught and sent to OnErrorAsync, - // notifying the observer a second time. Keep the protected virtual guard's success behavior unchanged. - private async Task ObserveMongoAsync(Func callbackAsync, IAsyncObserver asyncObserver, CancellationToken cancellationToken) + // Like EnumerateMongo, only driver acquisition and advancement are translated. + // Plain using deliberately gives cursor disposal the same semantics as sync reads. + private async Task EnumerateMongoAsync(Func>> acquireCursorAsync, + Func> onDocumentAsync, bool legacy, CancellationToken cancellationToken) { - bool completed = false; - await TryMongoAsync(async () => + using var cursor = legacy + ? await acquireCursorAsync().ConfigureAwait(false) + : await TryMongoAsync(acquireCursorAsync, cancellationToken).ConfigureAwait(false); + Func> moveNextAsync = () => cursor.MoveNextAsync(cancellationToken); + while (legacy + ? await moveNextAsync().ConfigureAwait(false) + : await TryMongoAsync(moveNextAsync, cancellationToken).ConfigureAwait(false)) { - await callbackAsync().ConfigureAwait(false); - completed = true; - }, cancellationToken, asyncObserver).ConfigureAwait(false); + foreach (var document in cursor.Current) + { + if (!await onDocumentAsync(document).ConfigureAwait(false)) + return; + } + } + } + + // Preserve the existing protected guard for driver operations, with the request token. + private async Task TryMongoAsync(Func> callbackAsync, CancellationToken cancellationToken) + { + T? result = default; + await TryMongoAsync(async () => { result = await callbackAsync().ConfigureAwait(false); }, + cancellationToken, asyncObserver: null).ConfigureAwait(false); + return result!; + } - if (completed) + // Notification is separate from translation. Terminal callbacks are outside the + // read's catch so their exceptions escape without a second notification. + private async Task ObserveMongoAsync(Func callbackAsync, IAsyncObserver asyncObserver, CancellationToken cancellationToken) + { + if (_options.WrapAsyncApplicationExceptions) { - await asyncObserver.OnCompletedAsync(cancellationToken).ConfigureAwait(false); + bool completed = false; + await TryMongoAsync(async () => + { + await callbackAsync(true).ConfigureAwait(false); + completed = true; + }, cancellationToken, asyncObserver).ConfigureAwait(false); + if (completed) + await asyncObserver.OnCompletedAsync(cancellationToken).ConfigureAwait(false); + return; + } + + if (IsDisposed) + throw new ObjectDisposedException("Attempt to use storage after it has been disposed."); + + Exception? failure = null; + try + { + await callbackAsync(false).ConfigureAwait(false); + } + catch (OperationCanceledException ex) when (cancellationToken.IsCancellationRequested) + { + MongoPersistenceEngineLogMessages.TaskWasCancelled(Logger, ex); + } + catch (Exception ex) + { + failure = ex; } + + if (failure != null) + await asyncObserver.OnErrorAsync(failure, cancellationToken).ConfigureAwait(false); + else + await asyncObserver.OnCompletedAsync(cancellationToken).ConfigureAwait(false); } private async Task GetLastCommittedCheckPointNumberAsync(CancellationToken cancellationToken) @@ -682,24 +678,15 @@ await PersistedCommits.DeleteManyAsync(Builders.Filter.And( /// public Task GetDeletedCommitsAsync(IAsyncObserver asyncObserver, CancellationToken cancellationToken) { - return ObserveMongoAsync(async () => + return ObserveMongoAsync(async legacy => { - using var cursor = await PersistedCommits + await EnumerateMongoAsync( + () => PersistedCommits .Find(Builders.Filter.Eq(MongoCommitFields.BucketId, MongoSystemBuckets.RecycleBin)) .Sort(SortByAscendingCheckpointNumber) - .ToCursorAsync(cancellationToken) - .ConfigureAwait(false); - while (await cursor.MoveNextAsync(cancellationToken).ConfigureAwait(false)) - { - foreach (var doc in cursor.Current) - { - var res = await asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken).ConfigureAwait(false); - if (!res) - { - return; - } - } - } + .ToCursorAsync(cancellationToken), + doc => asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken), + legacy, cancellationToken).ConfigureAwait(false); }, asyncObserver, cancellationToken); diff --git a/src/NEventStore.Persistence.MongoDB/MongoPersistenceOptions.cs b/src/NEventStore.Persistence.MongoDB/MongoPersistenceOptions.cs index f816a37..cacbce9 100644 --- a/src/NEventStore.Persistence.MongoDB/MongoPersistenceOptions.cs +++ b/src/NEventStore.Persistence.MongoDB/MongoPersistenceOptions.cs @@ -170,6 +170,14 @@ public virtual IMongoDatabase ConnectToDatabase(string connectionString) /// public Boolean DisableSnapshotSupport { get; set; } + /// + /// Restores legacy whole-read exception translation and protected guard invocation + /// for async observer reads. Defaults to false: only cursor acquisition and + /// advancement are translated; application and cursor disposal errors retain their types. + /// + public Boolean WrapAsyncApplicationExceptions { get; set; } + + /// /// The default behavior when using snapshot is to persist the stream heads in /// a background threads, but this way it can be hard to test if the heads and snapshots From 606a417afbf3f683592b6bd9af9e405275d2bd28 Mon Sep 17 00:00:00 2001 From: Alessandro Giorgetti Date: Tue, 17 Nov 2026 14:15:40 +0100 Subject: [PATCH 2/3] refactor: remove async read forwarding lambdas Co-authored-by: Alessandro Giorgetti Co-authored-by: Codex (OpenAI) --- .../Issues/Issue108AsyncExceptionOrigin.cs | 12 +++--- .../MongoPersistenceEngine.Async.cs | 42 +++++++++---------- 2 files changed, 27 insertions(+), 27 deletions(-) diff --git a/src/NEventStore.Persistence.MongoDB.Tests/AcceptanceTests/Issues/Issue108AsyncExceptionOrigin.cs b/src/NEventStore.Persistence.MongoDB.Tests/AcceptanceTests/Issues/Issue108AsyncExceptionOrigin.cs index ab27aa5..1bddef8 100644 --- a/src/NEventStore.Persistence.MongoDB.Tests/AcceptanceTests/Issues/Issue108AsyncExceptionOrigin.cs +++ b/src/NEventStore.Persistence.MongoDB.Tests/AcceptanceTests/Issues/Issue108AsyncExceptionOrigin.cs @@ -16,7 +16,7 @@ public class when_Issue108_an_async_read_fails(int path, string stage, string ki { public static IEnumerable Cases => from path in Enumerable.Range(0, 7) - from stage in new[] { "serializer", "observer throw", "observer task", "observer delayed", "early stop", "find", "later batch", "dispose" } + from stage in new[] { "serializer", "observer throw", "observer task", "observer delayed", "early stop", "find", "find throw", "later batch", "dispose" } where path != 5 || stage != "serializer" from kind in new[] { "mongo", "connection", "other" } where stage != "early stop" || kind == "other" @@ -46,7 +46,7 @@ protected override void Context() A.CallTo(() => serializer.Deserialize(A._)).Throws(_failure); A.CallTo(() => collection.FindAsync(A>._, A>._, _cancellation.Token)) - .ReturnsLazily(() => stage == "find" + .ReturnsLazily(() => stage == "find throw" ? throw _failure : stage == "find" ? Task.FromException>(_failure) : Task.FromResult(_cursor)); int batch = 0; @@ -134,16 +134,16 @@ public void Should_translate_only_storage_failures_unless_legacy_behavior_is_req public void Should_preserve_notification_and_resource_contracts() { // Driver guards never enclose application work in the default mode. - if (stage == "find" || stage == "later batch" || (legacy && stage != "early stop")) + if (stage.StartsWith("find") || stage == "later batch" || (legacy && stage != "early stop")) _engine.CallbackFailure.Should().BeSameAs(_failure); else _engine.CallbackFailure.Should().BeNull(); - _engine.WrapperCalls.Should().Be(legacy ? 1 : stage == "find" ? 1 : stage == "later batch" || stage == "dispose" ? 3 : 2); + _engine.WrapperCalls.Should().Be(legacy ? 1 : stage.StartsWith("find") ? 1 : stage == "later batch" || stage == "dispose" ? 3 : 2); _engine.Token.Should().Be(_cancellation.Token); _errors.Should().Be(stage == "early stop" ? 0 : 1); _completions.Should().Be(stage == "early stop" ? 1 : 0); - _nextCalls.Should().Be(stage == "find" || stage == "serializer" ? 0 : 1); - if (stage == "find") A.CallTo(() => _cursor.Dispose()).MustNotHaveHappened(); + _nextCalls.Should().Be(stage.StartsWith("find") || stage == "serializer" ? 0 : 1); + if (stage.StartsWith("find")) A.CallTo(() => _cursor.Dispose()).MustNotHaveHappened(); else A.CallTo(() => _cursor.Dispose()).MustHaveHappenedOnceExactly(); if (stage == "early stop") A.CallTo(() => _cursor.MoveNextAsync(_cancellation.Token)).MustHaveHappenedOnceExactly(); diff --git a/src/NEventStore.Persistence.MongoDB/MongoPersistenceEngine.Async.cs b/src/NEventStore.Persistence.MongoDB/MongoPersistenceEngine.Async.cs index df99a05..0ea7552 100644 --- a/src/NEventStore.Persistence.MongoDB/MongoPersistenceEngine.Async.cs +++ b/src/NEventStore.Persistence.MongoDB/MongoPersistenceEngine.Async.cs @@ -15,7 +15,7 @@ public Task GetFromAsync(string bucketId, string streamId, int minRevision, int { MongoPersistenceEngineLogMessages.GettingAllCommitsBetween(Logger, streamId, bucketId, minRevision, maxRevision); - return ObserveMongoAsync(async legacy => + return ObserveMongoAsync(legacy => { var filters = new List>() { @@ -37,13 +37,13 @@ public Task GetFromAsync(string bucketId, string streamId, int minRevision, int var query = Builders.Filter.And(filters); - await EnumerateMongoAsync( + return EnumerateMongoAsync( () => PersistedCommits .Find(query) .Sort(SortByAscendingStreamRevisionFrom) .ToCursorAsync(cancellationToken), doc => observer.OnNextAsync(doc.ToCommit(_serializer), cancellationToken), - legacy, cancellationToken).ConfigureAwait(false); + legacy, cancellationToken); }, observer, cancellationToken); } @@ -53,7 +53,7 @@ public Task GetFromAsync(string bucketId, long checkpointToken, IAsyncObserver + return ObserveMongoAsync(legacy => { var query = Builders.Filter.Eq(MongoCommitFields.BucketId, bucketId); if (checkpointToken > 0) @@ -63,13 +63,13 @@ public Task GetFromAsync(string bucketId, long checkpointToken, IAsyncObserver.Filter.Gt(MongoCommitFields.CheckpointNumber, checkpointToken) ); } - await EnumerateMongoAsync( + return EnumerateMongoAsync( () => PersistedCommits .Find(query) .Sort(SortByAscendingCheckpointNumber) .ToCursorAsync(cancellationToken), doc => asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken), - legacy, cancellationToken).ConfigureAwait(false); + legacy, cancellationToken); }, asyncObserver, cancellationToken); @@ -80,7 +80,7 @@ public Task GetFromToAsync(string bucketId, long fromCheckpointToken, long toChe { MongoPersistenceEngineLogMessages.GettingCommitsFromBucketAndFromToCheckpoint(Logger, bucketId, fromCheckpointToken, toCheckpointToken); - return ObserveMongoAsync(async legacy => + return ObserveMongoAsync(legacy => { var filters = new List>() { @@ -99,13 +99,13 @@ public Task GetFromToAsync(string bucketId, long fromCheckpointToken, long toChe ); } var query = Builders.Filter.And(filters); - await EnumerateMongoAsync( + return EnumerateMongoAsync( () => PersistedCommits .Find(query) .Sort(SortByAscendingCheckpointNumber) .ToCursorAsync(cancellationToken), doc => asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken), - legacy, cancellationToken).ConfigureAwait(false); + legacy, cancellationToken); }, asyncObserver, cancellationToken); @@ -116,7 +116,7 @@ public Task GetFromAsync(long checkpointToken, IAsyncObserver asyncObse { MongoPersistenceEngineLogMessages.GettingAllCommitsFromCheckpoint(Logger, checkpointToken); - return ObserveMongoAsync(async legacy => + return ObserveMongoAsync(legacy => { var query = Builders.Filter.Ne(MongoCommitFields.BucketId, MongoSystemBuckets.RecycleBin); if (checkpointToken > 0) @@ -126,13 +126,13 @@ public Task GetFromAsync(long checkpointToken, IAsyncObserver asyncObse Builders.Filter.Gt(MongoCommitFields.CheckpointNumber, checkpointToken) ); } - await EnumerateMongoAsync( + return EnumerateMongoAsync( () => PersistedCommits .Find(query) .Sort(SortByAscendingCheckpointNumber) .ToCursorAsync(cancellationToken), doc => asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken), - legacy, cancellationToken).ConfigureAwait(false); + legacy, cancellationToken); }, asyncObserver, cancellationToken); @@ -143,7 +143,7 @@ public Task GetFromToAsync(long fromCheckpointToken, long toCheckpointToken, IAs { MongoPersistenceEngineLogMessages.GettingCommitsFromToCheckpoint(Logger, fromCheckpointToken, toCheckpointToken); - return ObserveMongoAsync(async legacy => + return ObserveMongoAsync(legacy => { var filters = new List>() { @@ -163,13 +163,13 @@ public Task GetFromToAsync(long fromCheckpointToken, long toCheckpointToken, IAs } var query = Builders.Filter.And(filters); - await EnumerateMongoAsync( + return EnumerateMongoAsync( () => PersistedCommits .Find(query) .Sort(SortByAscendingCheckpointNumber) .ToCursorAsync(cancellationToken), doc => asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken), - legacy, cancellationToken).ConfigureAwait(false); + legacy, cancellationToken); }, asyncObserver, cancellationToken); @@ -292,19 +292,19 @@ public Task GetStreamsToSnapshotAsync(string bucketId, int maxThreshold, IAsyncO MongoPersistenceEngineLogMessages.GettingStreamsToSnapshot(Logger); - return ObserveMongoAsync(async legacy => + return ObserveMongoAsync(legacy => { var query = Builders.Filter.And( Builders.Filter.Eq(MongoStreamHeadFields.FullQualifiedBucketId, bucketId), Builders.Filter.Gte(MongoStreamHeadFields.Unsnapshotted, maxThreshold) ); - await EnumerateMongoAsync( + return EnumerateMongoAsync( () => PersistedStreamHeads .Find(query) .Sort(Builders.Sort.Descending(MongoStreamHeadFields.Unsnapshotted)) .ToCursorAsync(cancellationToken), doc => asyncObserver.OnNextAsync(doc.ToStreamHead(), cancellationToken), - legacy, cancellationToken).ConfigureAwait(false); + legacy, cancellationToken); }, asyncObserver, cancellationToken); } @@ -678,15 +678,15 @@ await PersistedCommits.DeleteManyAsync(Builders.Filter.And( /// public Task GetDeletedCommitsAsync(IAsyncObserver asyncObserver, CancellationToken cancellationToken) { - return ObserveMongoAsync(async legacy => + return ObserveMongoAsync(legacy => { - await EnumerateMongoAsync( + return EnumerateMongoAsync( () => PersistedCommits .Find(Builders.Filter.Eq(MongoCommitFields.BucketId, MongoSystemBuckets.RecycleBin)) .Sort(SortByAscendingCheckpointNumber) .ToCursorAsync(cancellationToken), doc => asyncObserver.OnNextAsync(doc.ToCommit(_serializer), cancellationToken), - legacy, cancellationToken).ConfigureAwait(false); + legacy, cancellationToken); }, asyncObserver, cancellationToken); From be126f07b067aa858d0283060c60c2a98d2852c6 Mon Sep 17 00:00:00 2001 From: Alessandro Giorgetti Date: Tue, 17 Nov 2026 15:43:36 +0100 Subject: [PATCH 3/3] removed compilation warnings: passing cancellationTokens and set default value for cancellationToken in async methods --- .../MongoPersistenceEngine.Async.cs | 30 +++++++++---------- .../MongoPersistenceOptions.cs | 3 +- 2 files changed, 16 insertions(+), 17 deletions(-) diff --git a/src/NEventStore.Persistence.MongoDB/MongoPersistenceEngine.Async.cs b/src/NEventStore.Persistence.MongoDB/MongoPersistenceEngine.Async.cs index 0ea7552..8875152 100644 --- a/src/NEventStore.Persistence.MongoDB/MongoPersistenceEngine.Async.cs +++ b/src/NEventStore.Persistence.MongoDB/MongoPersistenceEngine.Async.cs @@ -11,7 +11,7 @@ namespace NEventStore.Persistence.MongoDB public partial class MongoPersistenceEngine : IPersistStreams { /// - public Task GetFromAsync(string bucketId, string streamId, int minRevision, int maxRevision, IAsyncObserver observer, CancellationToken cancellationToken) + public Task GetFromAsync(string bucketId, string streamId, int minRevision, int maxRevision, IAsyncObserver observer, CancellationToken cancellationToken = default) { MongoPersistenceEngineLogMessages.GettingAllCommitsBetween(Logger, streamId, bucketId, minRevision, maxRevision); @@ -49,7 +49,7 @@ public Task GetFromAsync(string bucketId, string streamId, int minRevision, int } /// - public Task GetFromAsync(string bucketId, long checkpointToken, IAsyncObserver asyncObserver, CancellationToken cancellationToken) + public Task GetFromAsync(string bucketId, long checkpointToken, IAsyncObserver asyncObserver, CancellationToken cancellationToken = default) { MongoPersistenceEngineLogMessages.GettingAllCommitsFromBucketAndCheckpoint(Logger, bucketId, checkpointToken); @@ -76,7 +76,7 @@ public Task GetFromAsync(string bucketId, long checkpointToken, IAsyncObserver - public Task GetFromToAsync(string bucketId, long fromCheckpointToken, long toCheckpointToken, IAsyncObserver asyncObserver, CancellationToken cancellationToken) + public Task GetFromToAsync(string bucketId, long fromCheckpointToken, long toCheckpointToken, IAsyncObserver asyncObserver, CancellationToken cancellationToken = default) { MongoPersistenceEngineLogMessages.GettingCommitsFromBucketAndFromToCheckpoint(Logger, bucketId, fromCheckpointToken, toCheckpointToken); @@ -112,7 +112,7 @@ public Task GetFromToAsync(string bucketId, long fromCheckpointToken, long toChe } /// - public Task GetFromAsync(long checkpointToken, IAsyncObserver asyncObserver, CancellationToken cancellationToken) + public Task GetFromAsync(long checkpointToken, IAsyncObserver asyncObserver, CancellationToken cancellationToken = default) { MongoPersistenceEngineLogMessages.GettingAllCommitsFromCheckpoint(Logger, checkpointToken); @@ -139,7 +139,7 @@ public Task GetFromAsync(long checkpointToken, IAsyncObserver asyncObse } /// - public Task GetFromToAsync(long fromCheckpointToken, long toCheckpointToken, IAsyncObserver asyncObserver, CancellationToken cancellationToken) + public Task GetFromToAsync(long fromCheckpointToken, long toCheckpointToken, IAsyncObserver asyncObserver, CancellationToken cancellationToken = default) { MongoPersistenceEngineLogMessages.GettingCommitsFromToCheckpoint(Logger, fromCheckpointToken, toCheckpointToken); @@ -176,7 +176,7 @@ public Task GetFromToAsync(long fromCheckpointToken, long toCheckpointToken, IAs } /// - public async Task CommitAsync(CommitAttempt attempt, CancellationToken cancellationToken) + public async Task CommitAsync(CommitAttempt attempt, CancellationToken cancellationToken = default) { MongoPersistenceEngineLogMessages.AttemptingToCommit(Logger, attempt.Events.Count, attempt.StreamId, attempt.CommitSequence); @@ -241,7 +241,7 @@ public Task GetFromToAsync(long fromCheckpointToken, long toCheckpointToken, IAs .FindAsync(attempt.ToMongoCommitIdQuery(), cancellationToken: cancellationToken) .ConfigureAwait(false); var bsonSavedCommit = await asyncCursor - .FirstOrDefaultAsync() + .FirstOrDefaultAsync(cancellationToken) .ConfigureAwait(false); if (bsonSavedCommit != null) { @@ -262,7 +262,7 @@ public Task GetFromToAsync(long fromCheckpointToken, long toCheckpointToken, IAs } return commitDoc.ToCommit(_serializer); - }).ConfigureAwait(false); + }, cancellationToken).ConfigureAwait(false); } private async Task FillHoleAsync(CommitAttempt attempt, Int64 checkpointId, CancellationToken cancellationToken) @@ -286,7 +286,7 @@ private async Task FillHoleAsync(CommitAttempt attempt, Int64 checkpointId, Canc } /// - public Task GetStreamsToSnapshotAsync(string bucketId, int maxThreshold, IAsyncObserver asyncObserver, CancellationToken cancellationToken) + public Task GetStreamsToSnapshotAsync(string bucketId, int maxThreshold, IAsyncObserver asyncObserver, CancellationToken cancellationToken = default) { CheckIfSnapshotEnabled(); @@ -310,7 +310,7 @@ public Task GetStreamsToSnapshotAsync(string bucketId, int maxThreshold, IAsyncO } /// - public Task GetSnapshotAsync(string bucketId, string streamId, int maxRevision, CancellationToken cancellationToken) + public Task GetSnapshotAsync(string bucketId, string streamId, int maxRevision, CancellationToken cancellationToken = default) { CheckIfSnapshotEnabled(); @@ -329,11 +329,11 @@ public Task GetStreamsToSnapshotAsync(string bucketId, int maxThreshold, IAsyncO var snapshot = await cursor.FirstOrDefaultAsync(cancellationToken).ConfigureAwait(false); return snapshot?.ToSnapshot(_serializer) as ISnapshot; - }); + }, cancellationToken); } /// - public async Task AddSnapshotAsync(ISnapshot snapshot, CancellationToken cancellationToken) + public async Task AddSnapshotAsync(ISnapshot snapshot, CancellationToken cancellationToken = default) { CheckIfSnapshotEnabled(); @@ -385,7 +385,7 @@ await PersistedStreamHeads.UpdateOneAsync( } /// - public Task PurgeAsync(CancellationToken cancellationToken) + public Task PurgeAsync(CancellationToken cancellationToken = default) { MongoPersistenceEngineLogMessages.PurgingStorage(Logger); @@ -399,7 +399,7 @@ public Task PurgeAsync(CancellationToken cancellationToken) } /// - public Task PurgeAsync(string bucketId, CancellationToken cancellationToken) + public Task PurgeAsync(string bucketId, CancellationToken cancellationToken = default) { MongoPersistenceEngineLogMessages.PurgingBucket(Logger, bucketId); @@ -413,7 +413,7 @@ public Task PurgeAsync(string bucketId, CancellationToken cancellationToken) } /// - public Task DeleteStreamAsync(string bucketId, string streamId, CancellationToken cancellationToken) + public Task DeleteStreamAsync(string bucketId, string streamId, CancellationToken cancellationToken = default) { MongoPersistenceEngineLogMessages.DeletingStream(Logger, streamId, bucketId); diff --git a/src/NEventStore.Persistence.MongoDB/MongoPersistenceOptions.cs b/src/NEventStore.Persistence.MongoDB/MongoPersistenceOptions.cs index cacbce9..d87e3e4 100644 --- a/src/NEventStore.Persistence.MongoDB/MongoPersistenceOptions.cs +++ b/src/NEventStore.Persistence.MongoDB/MongoPersistenceOptions.cs @@ -1,5 +1,5 @@ using NEventStore.Persistence.MongoDB.Support; -using global::MongoDB.Driver; +using MongoDB.Driver; namespace NEventStore.Persistence.MongoDB { @@ -177,7 +177,6 @@ public virtual IMongoDatabase ConnectToDatabase(string connectionString) /// public Boolean WrapAsyncApplicationExceptions { get; set; } - /// /// The default behavior when using snapshot is to persist the stream heads in /// a background threads, but this way it can be hard to test if the heads and snapshots