protected virtual async Task <bool> CommitEventsAsync(IImmutableList <IBusinessEvent> events, string regionId, string streamId, long?lastPositionHydrated)
{
if (events.Count > 0)
{
var commitEvents = new List <CommitEvent>();
foreach (var businessEvent in events)
{
if (!_resolver.CanUnresolve(businessEvent))
{
throw new InvalidOperationException("Unable to unresolve business event.");
}
var unresolvedEvent = _resolver.Unresolve(businessEvent);
commitEvents.Add(new CommitEvent(unresolvedEvent.EventType, unresolvedEvent.Data));
}
var client = _streamClientFactory.Create(regionId); // Assuming caller will take care of disposing if necessary.
var result = await client.CommitEventsToStreamAsync(streamId, lastPositionHydrated, commitEvents);
if (result != CommitResult.Success)
{
return(false);
}
}
return(true);
}
protected virtual async Task HydrateFromCheckpointAsync(TState state, string regionId, string streamId, CancellationToken cancellationToken)
{
var streamClient = _streamClientFactory.Create(regionId);
var fromPosition = state.StreamPositionCheckpoint.GetValueOrDefault(streamClient.FirstPositionInStream - 1) + 1;
var callCount = 1;
await streamClient.LoadStreamEventsAsync(
streamId, fromPosition,
async se =>
{
await state.ApplyStreamEventAsync(se, cancellationToken);
if (callCount % _saveBatchSize == 0)
{
await state.SaveChangesAsync(cancellationToken);
}
callCount++;
},
cancellationToken
);
}
// Thread safe, can be called in parallel by one caller to load events from multiple subscription sources.
public async Task ListenAsync(string regionId, string subscriptionStreamId, CancellationToken cancellationToken)
{
try
{
using (var streamClient = _streamClientFactory.Create(regionId))
{
var listenerTask = streamClient.SubscribeToStreamAsync(
subscriptionStreamId, streamClient.FirstPositionInStream,
(se) => _resolutionManager.ReceiveStreamEventAsync(regionId, se, streamClient.FirstPositionInStream, cancellationToken),
cancellationToken
);
await Task.WhenAny(new[] { listenerTask, cancellationToken.WaitHandle.AsTask() });
}
}
catch (Exception ex)
{
_logger.LogError(ex, $"Exception while listening on regional subscription ({regionId}) stream {subscriptionStreamId}.");
throw;
}
}
public async Task <IDictionary <string, long?> > GetRegionalEndsOfSubscriptionAsync()
{
try
{
var ends = new Dictionary <string, long?>();
foreach (var subStreamId in _options.SubscriptionStreamIds)
{
using (var streamClient = _streamClientFactory.Create(subStreamId.RegionId))
{
var position = await streamClient.GetLastPositionInStreamAsync(subStreamId.StreamId);
ends.Add(subStreamId.RegionId, position);
}
}
return(ends);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error while clearing stream state errors.");
throw;
}
}
protected virtual async Task HydrateFromCheckpointAsync(TState state, string regionId, string streamId, CancellationToken cancellationToken)
{
var streamClient = _streamClientFactory.Create(regionId);
var fromPosition = state.StreamPositionCheckpoint.GetValueOrDefault(streamClient.FirstPositionInStream - 1) + 1;
await streamClient.LoadStreamEventsAsync(streamId, fromPosition, se => state.ApplyStreamEventAsync(se, cancellationToken), cancellationToken);
}
