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..1bddef8 --- /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", "find throw", "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 throw" ? throw _failure : 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.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.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.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(); + } + + 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..8875152 100644 --- a/src/NEventStore.Persistence.MongoDB/MongoPersistenceEngine.Async.cs +++ b/src/NEventStore.Persistence.MongoDB/MongoPersistenceEngine.Async.cs @@ -11,11 +11,11 @@ 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); - return ObserveMongoAsync(async () => + return ObserveMongoAsync(legacy => { var filters = new List>() { @@ -37,33 +37,23 @@ public Task GetFromAsync(string bucketId, string streamId, int minRevision, int var query = Builders.Filter.And(filters); - using var cursor = await PersistedCommits + return 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); }, observer, cancellationToken); } /// - 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); - return ObserveMongoAsync(async () => + return ObserveMongoAsync(legacy => { var query = Builders.Filter.Eq(MongoCommitFields.BucketId, bucketId); if (checkpointToken > 0) @@ -73,33 +63,24 @@ public Task GetFromAsync(string bucketId, long checkpointToken, IAsyncObserver.Filter.Gt(MongoCommitFields.CheckpointNumber, checkpointToken) ); } - using var cursor = await PersistedCommits + return 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); }, asyncObserver, cancellationToken); } /// - 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); - return ObserveMongoAsync(async () => + return ObserveMongoAsync(legacy => { var filters = new List>() { @@ -118,33 +99,24 @@ public Task GetFromToAsync(string bucketId, long fromCheckpointToken, long toChe ); } var query = Builders.Filter.And(filters); - using var cursor = await PersistedCommits + return 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); }, asyncObserver, cancellationToken); } /// - public Task GetFromAsync(long checkpointToken, IAsyncObserver asyncObserver, CancellationToken cancellationToken) + public Task GetFromAsync(long checkpointToken, IAsyncObserver asyncObserver, CancellationToken cancellationToken = default) { MongoPersistenceEngineLogMessages.GettingAllCommitsFromCheckpoint(Logger, checkpointToken); - return ObserveMongoAsync(async () => + return ObserveMongoAsync(legacy => { var query = Builders.Filter.Ne(MongoCommitFields.BucketId, MongoSystemBuckets.RecycleBin); if (checkpointToken > 0) @@ -154,33 +126,24 @@ public Task GetFromAsync(long checkpointToken, IAsyncObserver asyncObse Builders.Filter.Gt(MongoCommitFields.CheckpointNumber, checkpointToken) ); } - using var cursor = await PersistedCommits + return 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); }, asyncObserver, cancellationToken); } /// - 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); - return ObserveMongoAsync(async () => + return ObserveMongoAsync(legacy => { var filters = new List>() { @@ -200,29 +163,20 @@ public Task GetFromToAsync(long fromCheckpointToken, long toCheckpointToken, IAs } var query = Builders.Filter.And(filters); - using var cursor = await PersistedCommits + return 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); }, asyncObserver, cancellationToken); } /// - 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); @@ -287,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) { @@ -308,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) @@ -332,41 +286,31 @@ 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(); MongoPersistenceEngineLogMessages.GettingStreamsToSnapshot(Logger); - return ObserveMongoAsync(async () => + return ObserveMongoAsync(legacy => { var query = Builders.Filter.And( Builders.Filter.Eq(MongoStreamHeadFields.FullQualifiedBucketId, bucketId), Builders.Filter.Gte(MongoStreamHeadFields.Unsnapshotted, maxThreshold) ); - using var cursor = await PersistedStreamHeads + return 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); }, asyncObserver, cancellationToken); } /// - public Task GetSnapshotAsync(string bucketId, string streamId, int maxRevision, CancellationToken cancellationToken) + public Task GetSnapshotAsync(string bucketId, string streamId, int maxRevision, CancellationToken cancellationToken = default) { CheckIfSnapshotEnabled(); @@ -385,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(); @@ -441,7 +385,7 @@ await PersistedStreamHeads.UpdateOneAsync( } /// - public Task PurgeAsync(CancellationToken cancellationToken) + public Task PurgeAsync(CancellationToken cancellationToken = default) { MongoPersistenceEngineLogMessages.PurgingStorage(Logger); @@ -455,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); @@ -469,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); @@ -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(legacy => { - using var cursor = await PersistedCommits + return 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); }, asyncObserver, cancellationToken); diff --git a/src/NEventStore.Persistence.MongoDB/MongoPersistenceOptions.cs b/src/NEventStore.Persistence.MongoDB/MongoPersistenceOptions.cs index f816a37..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 { @@ -170,6 +170,13 @@ 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