private void Unsubscribe()
{
if (currentSubscription != null)
{
currentSubscription.StopAsync().Forget();
currentSubscription = null;
}
}
private void Subscribe(string position)
{
if (currentSubscription == null)
{
currentSubscription?.StopAsync().Forget();
currentSubscription = CreateSubscription(eventStore, eventConsumer.EventsFilter, position);
}
}
private Task UnsubscribeThisAsync()
{
if (eventSubscription != null)
{
eventSubscription.StopAsync().Forget();
eventSubscription = null;
}
return(TaskHelper.Done);
}
private void Subscribe(string?position)
{
if (currentSubscription == null)
{
currentSubscription?.StopAsync().Forget();
currentSubscription = CreateSubscription(eventConsumer !.EventsFilter, position);
}
else
{
currentSubscription.WakeUp();
}
}
public async Task Should_reopen_subscription_once_when_exception_is_retrieved()
{
await OnErrorAsync(eventSubscription, new InvalidOperationException());
await Task.Delay(1000);
await sut.StopAsync();
A.CallTo(() => eventSubscription.StopAsync())
.MustHaveHappened(2, Times.Exactly);
A.CallTo(() => eventStore.CreateSubscription(A <IEventSubscriber> .Ignored, A <string> .Ignored, A <string> .Ignored))
.MustHaveHappened(2, Times.Exactly);
A.CallTo(() => eventSubscriber.OnErrorAsync(A <IEventSubscription> .Ignored, A <Exception> .Ignored))
.MustNotHaveHappened();
}
public async Task Should_stop_subscription_when_stopped()
{
await OnSubscribeAsync();
sutActor.Tell(new StopConsumerMessage());
sutActor.Tell(new StopConsumerMessage());
sut.Dispose();
A.CallTo(() => eventConsumerInfoRepository.SetAsync(consumerName, consumerInfo.Position, false, null))
.MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => eventConsumerInfoRepository.SetAsync(consumerName, consumerInfo.Position, true, null))
.MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => eventSubscription.StopAsync())
.MustHaveHappened(Repeated.Exactly.Once);
}
private async Task HandleErrorAsync(IEventSubscription subscription, Exception exception)
{
if (subscription == currentSubscription)
{
subscription.StopAsync().Forget();
subscription = null;
if (retryWindow.CanRetryAfterFailure())
{
Task.Delay(ReconnectWaitMs, disposeCts.Token).ContinueWith(t =>
{
dispatcher.DispatchAsync(() => Subscribe());
}).Forget();
}
else
{
await eventSubscriber.OnErrorAsync(this, exception);
}
}
}
private async Task <IReadOnlyList <StoredEvent> > QueryWithSubscriptionAsync(string streamFilter, Func <Task> action = null, bool fromBeginning = false)
{
var subscriber = new EventSubscriber();
IEventSubscription subscription = null;
try
{
subscription = Sut.CreateSubscription(subscriber, streamFilter, fromBeginning ? null : subscriptionPosition);
if (action != null)
{
await action();
}
using (var cts = new CancellationTokenSource(30000))
{
while (!cts.IsCancellationRequested)
{
subscription.WakeUp();
await Task.Delay(500, cts.Token);
if (subscriber.Events.Count > 0)
{
subscriptionPosition = subscriber.LastPosition;
return(subscriber.Events);
}
}
cts.Token.ThrowIfCancellationRequested();
return(null);
}
}
finally
{
await subscription.StopAsync();
}
}
public void Should_stop_subscription_when_stopped()
{
sut.ActivateAsync(consumerName, store).Wait();
sut.Activate(eventConsumer);
sut.Stop();
sut.Stop();
sut.Dispose();
state.ShouldBeEquivalentTo(new EventConsumerState {
IsStopped = true, Position = initialPosition, Error = null
});
A.CallTo(() => persistence.WriteSnapshotAsync(A <EventConsumerState> .Ignored))
.MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => eventSubscription.StopAsync())
.MustHaveHappened(Repeated.Exactly.Once);
}
public async Task Should_stop_subscription_when_stopped()
{
await sut.OnActivateAsync(consumerName);
await sut.ActivateAsync();
await sut.StopAsync();
await sut.StopAsync();
state.Should().BeEquivalentTo(new EventConsumerState {
IsStopped = true, Position = initialPosition, Error = null
});
A.CallTo(() => persistence.WriteSnapshotAsync(A <EventConsumerState> .Ignored))
.MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => eventSubscription.StopAsync())
.MustHaveHappened(Repeated.Exactly.Once);
}
public async Task Should_stop_subscription_when_stopped()
{
await sut.ActivateAsync(consumerName);
await sut.ActivateAsync();
await sut.StopAsync();
await sut.StopAsync();
grainState.Value.Should().BeEquivalentTo(new EventConsumerState {
IsStopped = true, Position = initialPosition, Error = null
});
A.CallTo(() => grainState.WriteAsync())
.MustHaveHappened(1, Times.Exactly);
A.CallTo(() => eventSubscription.StopAsync())
.MustHaveHappened(1, Times.Exactly);
}
public void Should_stop_subscription_when_stopped()
{
sut.Activate(eventConsumer);
sut.Stop();
sut.Stop();
sut.Dispose();
state.ShouldBeEquivalentTo(new EventConsumerState {
IsStopped = true, Position = initialPosition, Error = null
});
A.CallTo(() => stateHolder.WriteAsync())
.MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => eventSubscription.StopAsync())
.MustHaveHappened(Repeated.Exactly.Once);
}
private static async Task WaitAndStopAsync(IEventSubscription sut)
{
await Task.Delay(200);
await sut.StopAsync();
}
public Task StopAsync(CancellationToken cancellationToken)
{
return(_subscription.StopAsync(cancellationToken));
}
private void Unsubscribe()
{
currentSubscription?.StopAsync().Forget();
}
public override void Dispose()
{
_eventSubscription?.StopAsync().GetAwaiter().GetResult();
base.Dispose();
}
