public async Task OnErrorAsync(IEventSubscription subscription, Exception exception)
{
Unsubscribe();
if (retryWindow.CanRetryAfterFailure())
{
await Task.Delay(ReconnectWaitMs, timerCancellation.Token);
Subscribe();
}
else
{
await eventSubscriber.OnErrorAsync(subscription, exception);
}
}
private async Task HandleErrorAsync(IEventSubscription subscription, Exception exception)
{
if (subscription == currentSubscription)
{
Unsubscribe();
if (retryWindow.CanRetryAfterFailure())
{
RetryAsync().Forget();
}
else
{
await eventSubscriber.OnErrorAsync(this, exception);
}
}
}
private async Task HandleErrorAsync(IEventSubscription subscription, Exception exception)
{
if (subscription == currentSubscription)
{
Unsubscribe();
if (retryWindow.CanRetryAfterFailure())
{
Task.Delay(ReconnectWaitMs, timerCts.Token).ContinueWith(t =>
{
dispatcher.DispatchAsync(() => Subscribe());
}).Forget();
}
else
{
await eventSubscriber.OnErrorAsync(this, exception);
}
}
}
private async Task OnMessage(object message)
{
if (isStopped)
{
return;
}
try
{
var oldStateId = stateId;
var newStateId = stateId = Guid.NewGuid();
switch (message)
{
case Teardown teardown:
{
isStopped = true;
return;
}
case Setup setup:
{
eventConsumer = setup.EventConsumer;
var status = await eventConsumerInfoRepository.FindAsync(eventConsumer.Name);
if (status != null)
{
statusError = status.Error;
statusPosition = status.Position;
statusIsRunning = !status.IsStopped;
}
if (statusIsRunning)
{
await SubscribeThisAsync(statusPosition);
}
break;
}
case StartConsumerMessage startConsumer:
{
if (statusIsRunning)
{
return;
}
await SubscribeThisAsync(statusPosition);
statusError = null;
statusIsRunning = true;
break;
}
case StopConsumerMessage stopConsumer:
{
if (!statusIsRunning)
{
return;
}
await UnsubscribeThisAsync();
statusIsRunning = false;
break;
}
case ResetConsumerMessage resetConsumer:
{
await UnsubscribeThisAsync();
await ClearAsync();
await SubscribeThisAsync(null);
statusError = null;
statusPosition = null;
statusIsRunning = true;
break;
}
case Reconnect reconnect:
{
if (!statusIsRunning || reconnect.StateId != oldStateId)
{
return;
}
await SubscribeThisAsync(statusPosition);
break;
}
case SubscriptionFailed subscriptionFailed:
{
if (subscriptionFailed.Subscription != eventSubscription)
{
return;
}
await UnsubscribeThisAsync();
if (retryWindow.CanRetryAfterFailure())
{
Task.Delay(ReconnectWaitMs).ContinueWith(t => dispatcher.SendAsync(new Reconnect {
StateId = newStateId
})).Forget();
}
else
{
throw subscriptionFailed.Exception;
}
break;
}
case SubscriptionEventReceived eventReceived:
{
if (eventReceived.Subscription != eventSubscription)
{
return;
}
var @event = ParseEvent(eventReceived.Event);
await DispatchConsumerAsync(@event);
statusError = null;
statusPosition = @eventReceived.Event.EventPosition;
break;
}
}
await eventConsumerInfoRepository.SetAsync(eventConsumer.Name, statusPosition, !statusIsRunning, statusError);
}
catch (Exception ex)
{
try
{
await UnsubscribeThisAsync();
}
catch (Exception unsubscribeException)
{
ex = new AggregateException(ex, unsubscribeException);
}
log.LogFatal(ex, w => w
.WriteProperty("action", "HandleEvent")
.WriteProperty("state", "Failed")
.WriteProperty("eventConsumer", eventConsumer.Name));
statusError = ex.ToString();
statusIsRunning = false;
await eventConsumerInfoRepository.SetAsync(eventConsumer.Name, statusPosition, !statusIsRunning, statusError);
}
}