public void Should_abort_if_handling_failed()
{
consumerInfo.Position = "2";
A.CallTo(() => eventConsumer.On(envelope1)).Returns(TaskHelper.True);
A.CallTo(() => eventConsumer.On(envelope2)).Throws(new InvalidOperationException());
sut.Subscribe(eventConsumer);
sut.Refresh();
sut.Dispose();
A.CallTo(() => eventConsumer.On(envelope1)).MustHaveHappened();
A.CallTo(() => eventConsumer.On(envelope2)).MustHaveHappened();
A.CallTo(() => eventConsumer.On(envelope3)).MustNotHaveHappened();
A.CallTo(() => eventConsumerInfoRepository.StopAsync(consumerName, A <string> .Ignored)).MustHaveHappened();
}
public void Subscribe(IEventConsumer eventConsumer, int delay = 5000)
{
Guard.NotNull(eventConsumer, nameof(eventConsumer));
ThrowIfDisposed();
if (timer != null)
{
return;
}
var consumerName = eventConsumer.Name;
var consumerStarted = false;
timer = new CompletionTimer(delay, async ct =>
{
if (!consumerStarted)
{
await eventConsumerInfoRepository.CreateAsync(consumerName);
consumerStarted = true;
}
try
{
var status = await eventConsumerInfoRepository.FindAsync(consumerName);
var position = status.Position;
if (status.IsResetting)
{
position = null;
await ResetAsync(eventConsumer, consumerName, position);
}
else if (status.IsStopped)
{
return;
}
await eventStore.GetEventsAsync(se =>
{
return(HandleEventAsync(eventConsumer, se, consumerName));
}, ct, eventConsumer.EventsFilter, position);
}
catch (Exception ex)
{
log.LogFatal(ex, w => w.WriteProperty("action", "EventHandlingFailed"));
await eventConsumerInfoRepository.StopAsync(consumerName, ex.ToString());
}
});
eventNotifier.Subscribe(timer.Trigger);
}
private void Stop(Exception ex, IEventConsumer eventConsumer)
{
foreach (var block in blocks)
{
block.Stop();
}
try
{
eventConsumerInfoRepository.StopAsync(eventConsumer.Name, ex.ToString()).Wait();
}
catch (Exception ex2)
{
log.LogFatal(ex2, w => w
.WriteProperty("action", "StopConsumer")
.WriteProperty("state", "Failed"));
}
}
private async Task SubscribeAsync(IEventConsumer eventConsumer, string position)
{
var consumerName = eventConsumer.Name;
var subscription = eventStore.CreateSubscription(eventConsumer.EventsFilter, position);
await subscription.SubscribeAsync(async storedEvent =>
{
await DispatchConsumerAsync(ParseEvent(storedEvent), eventConsumer, eventConsumer.Name);
await eventConsumerInfoRepository.SetPositionAsync(eventConsumer.Name, storedEvent.EventPosition, false);
}, async exception =>
{
await eventConsumerInfoRepository.StopAsync(consumerName, exception.ToString());
subscription.Dispose();
});
currentSubscription = subscription;
}
public async Task <IActionResult> Stop(string name)
{
await eventConsumerRepository.StopAsync(name);
return(NoContent());
}
