private void HandleEvent(EventStoreCatchUpSubscription arg1, ResolvedEvent arg2)
{
var @event = SerializationUtils.DeserializeEvent(arg2.OriginalEvent);
if (@event == null)
{
return;
}
var eventType = @event.GetType();
if (@event is IMessage)
{
if (@event is IEvent)
{
_domainEntry.Publish(@event as IEvent);
}
if (@event is ICommand)
{
_domainEntry.Send(@event as ICommand);
}
}
_latestPosition = arg2.OriginalPosition;
if (_latestPosition.HasValue && _domainEntry.CanHandle(eventType))
{
_checkpointRepository.Save(_latestPosition.Value);
}
}
public async Task EventAppeared(EventStoreCatchUpSubscription subscription, ResolvedEvent @event)
{
CurrentCheckpoint = @event.OriginalEventNumber;
var ev = TryDeserializeEvent(@event.Event.Metadata, @event.Event.Data);
await EventAppearedCallback(ev, @event.OriginalEventNumber + 1);
}
private Task GotEvent(EventStoreCatchUpSubscription sub, ResolvedEvent evt)
{
try {
lock (_updateLock) {
if (evt.Event.Data.Length <= 0 || !evt.Event.IsJson || evt.Event.EventType.StartsWith("$") || evt.IsResolved)
{
return(Task.CompletedTask);
}
var e = _deserializer(evt);
if (e is IEvent message)
{
Apply(message);
}
// ReSharper disable once PossibleInvalidOperationException
// this always has a value here
_checkPoint = evt.OriginalPosition.Value;
}
}
catch (Exception e) {
//Console.WriteLine(e);
}
if (_isLive)
{
UpdateSubscribers();
}
return(Task.CompletedTask);
}
private void OnSubscriptionDropped(EventStoreCatchUpSubscription catchUpSubscription, SubscriptionDropReason dropReason, Exception exception)
{
string innerExceptionMessage = string.Empty;
if (exception != null && exception.InnerException != null)
{
innerExceptionMessage = string.Format(" ({0})", exception.InnerException.Message);
}
// logProvider.Log("Subscription dropped (reason: " + SubscriptionDropReasonText(dropReason) + innerExceptionMessage + ")", LogMessageLevel.Info);
if (dropReason == SubscriptionDropReason.ProcessingQueueOverflow)
{
// This happens when the server detects that _liveQueue.Count >= MaxPushQueueSize which defaults to 10,000
// In the forum James Nugent suggests "Wait and reconnect probably with back off" https://gist.github.com/jen20/6092666
// For now we will just re-subscribe
InitialiseCatchUpSubscription();
}
if (SubscriptionDropMayBeRecoverable(dropReason))
{
InitialiseCatchUpSubscription();
}
}
private async void EventAppeared(EventStoreCatchUpSubscription subscription, ResolvedEvent resolvedEvent)
{
this.logger.Info("Processed event: " + resolvedEvent.OriginalPosition + "/" + resolvedEvent.OriginalEventNumber.ToString());
await EventStoreEventLogClient.SemaphoreSlim.WaitAsync();
try
{
if (
resolvedEvent.OriginalStreamId.StartsWith(StreamIdPrefix) &&
await this.ProcessEvent(
Encoding.UTF8.GetString(resolvedEvent.OriginalEvent.Metadata),
Encoding.UTF8.GetString(resolvedEvent.OriginalEvent.Data)
)
)
{
this.lastPositionString = resolvedEvent.OriginalPosition?.ToString();
if (this.isLive)
{
this.ProcessLive(this.lastPositionString);
}
}
}
catch (Exception ex)
{
this.logger.Error(ex, "Error occured while processing event.");
}
finally
{
EventStoreEventLogClient.SemaphoreSlim.Release();
}
}
private async Task EventAppeared(EventStoreCatchUpSubscription sub, ResolvedEvent evt)
{
_logger.LogTrace("EventAppeared {SubscriptionName} {Stream} Projector {ProjectorId}",
sub.SubscriptionName,
sub.StreamId,
ProjectorId);
var de = evt.Event.ToDomainEvent();
var desc = new ProjectionEventData
{
EventData = de,
EventNumber = evt.OriginalEventNumber
};
// if (_useQueue)
// {
// _logger.LogTrace("Enqueue Event {@0}", desc);
// await Queue.EnqueueAsync(desc).ConfigureAwait(false);
// }
// else
// {
await HandleEventAsync(desc).ConfigureAwait(false);
// }
}
private Task EventAppeared(EventStoreCatchUpSubscription arg1, ResolvedEvent arg2)
{
if (arg2.Event == null || arg2.Event.EventStreamId.StartsWith("$") || arg2.Event.EventType.StartsWith("$"))
{
return(Task.CompletedTask);
}
dynamic data = JObject.Parse(Encoding.UTF8.GetString(arg2.Event.Data));
dynamic metaData = JObject.Parse(Encoding.UTF8.GetString(arg2.Event.Metadata));
if (arg2.Event.EventType.Equals("TaskAddedV1"))
{
HandleTaskAdded(data, metaData);
}
if (arg2.Event.EventType.Equals("TaskRemovedV1"))
{
HandleTaskDeleted(data, metaData);
}
if (arg2.Event.EventType.Equals("WrongRemoveTaskRequestedV1"))
{
HandleWrongRemoveTaskRequested(data, metaData);
}
return(Task.CompletedTask);
}
private void SubscriptionDropped(EventStoreCatchUpSubscription subscription, SubscriptionDropReason reason, Exception ex)
{
// Known bug in ES, must manually stop subscription or sub will continue delivering events.
// https://groups.google.com/forum/#!searchin/event-store/subscription/event-store/AdKzv8TxabM/6RzudeuAAgAJ
_sub.Stop();
Subscribe();
}
private void HandleDrop(
EventStoreCatchUpSubscription subscription,
SubscriptionDropReason reason,
Exception ex)
{
RecoverSubscription();
}
private void HandleEvent(EventStoreCatchUpSubscription subscription, ResolvedEvent resolved)
{
if (!CanHandleSubscriptionEvent(subscription))
{
return;
}
try
{
connectionLock.EnterReadLock();
if (CanHandleSubscriptionEvent(subscription))
{
var storedEvent = Formatter.Read(resolved);
PublishAsync(storedEvent).Wait();
position = resolved.OriginalEventNumber;
}
}
finally
{
connectionLock.ExitReadLock();
}
}
private void Dropped(EventStoreCatchUpSubscription sub, SubscriptionDropReason reason, Exception ex)
{
//Reconnect if we drop
//TODO: check the reason and handle it appropriately
_view.ErrorMsg = "Subscription Dropped, press Enter to reconnect";
Subscribe();
}
private async Task EventAppeared(EventStoreCatchUpSubscription sub, ResolvedEvent e, CancellationToken token,
Func <string, long, IFullEvent, Task> callback)
{
// Don't care about metadata streams
if (e.Event == null || e.Event.EventStreamId[0] == '$')
{
return;
}
if (token.IsCancellationRequested)
{
Logger.WarnEvent("Cancelation", "Token cancel requested");
ThreadPool.QueueUserWorkItem((_) => sub.Stop(TimeSpan.FromSeconds(10)));
token.ThrowIfCancellationRequested();
}
try
{
await EventAppeared(e, token, callback).ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.ErrorEvent("AppearedException", ex, "Stream: [{Stream:l}] Position: {StreamPosition} {ExceptionType} - {ExceptionMessage}", e.Event.EventStreamId, e.Event.EventNumber, ex.GetType().Name, ex.Message);
//throw;
}
}
private void GotEvent(EventStoreCatchUpSubscription sub, ResolvedEvent evt)
{
try
{
//create local copies of state variables
var total = _checkpoint.Value;
var checkpoint = evt.Event.EventNumber;
var amount = (string)JObject.Parse(Encoding.UTF8.GetString(evt.Event.Data))["amount"];
switch (evt.Event.EventType.ToUpperInvariant())
{
case "CREDIT":
total += int.Parse(amount);
break;
case "DEBIT":
total -= int.Parse(amount);
break;
default:
throw new Exception("Unknown Event Type");
}
_checkpoint.Save(checkpoint, total);
}
catch (Exception ex)
{
_view.ErrorMsg = "Event Exception: " + ex.Message;
}
//repaint screen
_view.Total = _checkpoint.Value;
}
private async Task EventAppeared(EventStoreCatchUpSubscription subscription, ResolvedEvent resolvedEvent)
{
if (_subscriptionEpochStopping ||
!IsValidEvent(resolvedEvent))
{
return;
}
// ReSharper disable once PossibleInvalidOperationException
var commitPosition = resolvedEvent.OriginalPosition.Value.CommitPosition;
try
{
await EventAppeared(resolvedEvent, commitPosition);
}
catch (Exception e)
{
if (Retry())
{
Log.Warning(e, "Exception received for subscription epoch {Name}. Retrying...", SubscriptionName);
throw;
}
if (_settings.StopOnException)
{
TerminateSubscriptionDueToError(resolvedEvent, e);
return;
}
ExceptionReceivedAfterMaxRetries(resolvedEvent, e);
}
await OnUpdateLastCommitPosition(commitPosition);
}
private Task EventAppeared(EventStoreCatchUpSubscription _, ResolvedEvent resolvedEvent)
{
//filter out technical and test events from the $all stream
if (resolvedEvent.Event.EventType.StartsWith("$") ||
resolvedEvent.Event.EventType.StartsWith("eventType") ||
resolvedEvent.Event.EventType.StartsWith("PersistentConfig1") ||
resolvedEvent.Event.EventType.StartsWith("Subscription"))
{
return(Task.CompletedTask);
}
//Deserialize event to C# object
var @event = resolvedEvent.Deserialize();
//tell user which events are being projected
Console.WriteLine("Projecting event {0}", @event.GetType().Name);
//check which event appeared in the projection and update read model
switch (@event)
{
case Events.UserRegistered e:
_items.Add(new UserReadModel()
{
UserId = e.UserId,
Name = e.Name
});
break;
case Events.UserNameUpdated e:
UpdateItem(e.UserId, user => user.Name = e.Name);
break;
}
return(Task.CompletedTask);
}
private void GotEvent(EventStoreCatchUpSubscription sub, ResolvedEvent evt)
{
try
{
//create local copies of state variables
var total = _total;
var checkpoint = evt.Event.EventNumber;
var amount = (string)JObject.Parse(Encoding.UTF8.GetString(evt.Event.Data))["amount"];
switch (evt.Event.EventType.ToUpperInvariant())
{
case "CREDIT":
total += int.Parse(amount);
break;
case "DEBIT":
total -= int.Parse(amount);
break;
default:
throw new Exception("Unknown Event Type");
}
File.WriteAllText(_localFile, checkpoint + "," + total);
//Update the common state after commit to disk
_total = total;
Checkpoint = checkpoint;
}
catch (Exception ex)
{
_view.ErrorMsg = "Event Exception: " + ex.Message;
}
//repaint screen
_view.Total = _total;
}
void EventAppeared(EventStoreCatchUpSubscription sub, ResolvedEvent evnt)
{
if (evnt.OriginalStreamId.StartsWith("$"))
{
return;
}
dynamic ev = _adapter.TryGetDomainEvent(evnt);
if (ev == null)
{
return;
}
try
{
lock (this)
{
Dispatch(ev);
_succeded++;
_checkPoint = evnt.OriginalPosition.GetValueOrDefault();
_lastEventNumber = evnt.OriginalEventNumber;
if (ev.Timestamp > LastUpdate)
{
LastUpdate = ev.Timestamp;
}
}
}
catch (Exception)
{
Debugger.Break();
}
}
async Task EventAppeared(
EventStoreCatchUpSubscription _,
ResolvedEvent resolvedEvent)
{
if (resolvedEvent.Event.EventType.StartsWith("$"))
{
return;
}
var @event = resolvedEvent.Deserialze();
Log.Debug("Projecting event {event}", @event.ToString());
try
{
await Task.WhenAll(_projections.Select(x => x.Project(@event)));
await _checkpointStore.StoreCheckpoint(
resolvedEvent.OriginalPosition.Value
);
}
catch (Exception e)
{
Log.Error(
e,
"Error occured when projecting the event {event}",
@event
);
throw;
}
}
private static void EventAppeared(EventStoreCatchUpSubscription s, ResolvedEvent e)
{
if (e.Event.EventType != "withdrew")
{
return;
}
var o = e.Deserialze();
var withdrew = o as V1.Withdrew;
var withdrewFix = new V1.WithdrewFix
{
Id = withdrew.Id,
Amount = new Account().CalculateFee(withdrew.Amount),
Description = "my fix",
ChangedAt = DateTime.Now,
WithdrewId = e.Event.EventId
};
var data = new EventData(
Guid.NewGuid(),
EventTypeMapper.GetTypeName(withdrewFix.GetType()),
true,
Encoding.Default.GetBytes(JsonConvert.SerializeObject(withdrewFix)), null);
eventStoreConnection.AppendToStreamAsync(e.OriginalStreamId, ExpectedVersion.Any, data);
Console.WriteLine($"Last position of fix=> {e.OriginalPosition.Value.CommitPosition}");
}
private Task EventAppeared(EventStoreCatchUpSubscription sub, ResolvedEvent @event)
{
var processedEvent = EventSerializer.DeserializeResolvedEvent(@event);
if (processedEvent != null)
{
try
{
_handleEvent(processedEvent);
}
catch (Exception ex)
{
//TODO: handle
}
}
if ([email protected])
{
throw new ArgumentException("ResolvedEvent didn't come off a subscription to all (has no position).");
}
_lastProcessedPosition = new Position(@event.OriginalPosition.Value.CommitPosition, @event.OriginalPosition.Value.PreparePosition);
try
{
_lastProcessedUpdatedAction?.Invoke(@event.OriginalPosition.Value.CommitPosition, @event.OriginalPosition.Value.PreparePosition);
}
catch (Exception ex)
{
//TODO: handle
}
return(Task.CompletedTask);
}
/// <summary>
/// Catches up subscription event appeared.
/// </summary>
/// <param name="subscription">The subscription.</param>
/// <param name="resolvedEvent">The resolved event.</param>
/// <param name="endpointId">The endpoint identifier.</param>
/// <returns></returns>
private async Task CatchUpSubscriptionEventAppeared(EventStoreCatchUpSubscription subscription, ResolvedEvent resolvedEvent, Guid catchUpSubscriptionId, Guid endpointId)
{
try
{
// Check the event data has been received
if (this.EventAppeared != null)
{
// Serialise the event data
String serialisedData = JsonConvert.SerializeObject(resolvedEvent);
SubscriptionDataTransferObject subscriptionInformation = new SubscriptionDataTransferObject()
{
SerialisedData = serialisedData,
EventId = (Guid)((RecordedEvent)resolvedEvent.Event).EventId,
SubscriptionGroupId = catchUpSubscriptionId.ToString(),
};
var handledSuccessfully = await this.EventAppeared(subscriptionInformation);
if (!handledSuccessfully)
{
throw new Exception($"Failed to Process Event {resolvedEvent.Event.EventId} on catchup subscription group {catchUpSubscriptionId}");
}
}
else
{
Logger.LogInformation("Unable to process event as EventAppeared Event handler is null");
}
}
catch (Exception ex)
{
Logger.LogError(ex);
}
}
public async Task SubscribeAsync(Func <StoredEvent, Task> onNext, Func <Exception, Task> onError = null)
{
Guard.NotNull(onNext, nameof(onNext));
if (publishNext != null)
{
throw new InvalidOperationException("An handler has already been registered.");
}
publishNext = onNext;
publishError = onError;
await CreateProjectionAsync();
try
{
connectionLock.EnterWriteLock();
internalSubscription = SubscribeToEventStore();
}
finally
{
connectionLock.ExitWriteLock();
}
}
private void LiveProcessingStarted(EventStoreCatchUpSubscription sub)
{
if (!_onCompletedFired)
{
_onCompletedFired = true;
_subject.OnCompleted();
}
}
private void ProcessEvent(EventStoreCatchUpSubscription subscribtion, ResolvedEvent resolvedEvent)
{
var alarm = resolvedEvent.ParseJson <IrresponsibleGamblerDetected>();
Publish(alarm);
StoreCheckpoint(resolvedEvent);
}
public IObservable <OccuredEvent> Start(long?position)
{
eventSub?.Dispose();
eventSub = new Subject <OccuredEvent>();
activeSub = connection.SubscribeToStreamFrom(StreamName, position, settings, Handle);
return(eventSub);
}
private async Task RecoverSubscription()
{
var checkpointToken = await _checkpoints.Get();
_subscription = _streamId == null
? SubscribeToAllFrom(checkpointToken.ParsePosition())
: SubscribeToStreamFrom(checkpointToken == null ? default(int?) : int.Parse(checkpointToken));
}
private void SubscriptionDropped(EventStoreCatchUpSubscription _, SubscriptionDropReason reason, Exception error)
{
Unsubscribe();
Debug("Subscription dropped. Reason: " + reason);
Error(error);
Thread.Sleep(5000);
Subscribe();
}
private void SubscriptionDropped(
IActorRef self,
EventStoreCatchUpSubscription subscription,
SubscriptionDropReason reason,
Exception exception)
{
self.Tell(Kill.Instance);
}
static Task OnEvent(EventStoreCatchUpSubscription sub, ResolvedEvent ev)
{
return(Task.Run(() =>
Console.WriteLine($"EventType: {ev.Event.EventType}, EventNumber: {ev.OriginalEventNumber}")));
// Console.WriteLine("saw event");
// return new Task(() =>
// );
}
private Task EventAppeared(EventStoreCatchUpSubscription subscription, ResolvedEvent resolvedEvent)
{
if (resolvedEvent.Event.EventType.StartsWith("$"))
{
return(Task.CompletedTask);
}
var @event = resolvedEvent.Deserialize();
Log.Debug("Projecting event {type}", @event.GetType().Name);
switch (@event)
{
case Events.CalendarCreated e:
_calendarDetails.Add(new ReadModels.CalendarDetails
{
CalendarId = e.CalendarId,
Description = e.CalendarDescription,
MaximumBookingTimeInMinutes = e.MaximumBookingTimeInMinutes,
NumberOfBookings = 0
});
_calendarOverviews.Add(new ReadModels.CalendarOverview {
CalendarId = e.CalendarId,
Description = e.CalendarDescription
});
break;
case Events.CalendarDescriptionChanged e:
UpdateCalendarDetails(e.CalendarId, c => c.Description = e.NewCalendarDescription);
UpdateCalendarOverview(e.CalendarId, c => c.Description = e.NewCalendarDescription);
break;
case Events.CalendarMaxBookingTimeChanged e:
UpdateCalendarDetails(e.CalendarId, c => c.MaximumBookingTimeInMinutes = e.NewMaximumBookingTimeInMinutes);
break;
case Events.BookingAdded e:
UpdateCalendarDetails(e.CalendarId, c => c.NumberOfBookings++);
_bookingDetails.Add(new ReadModels.BookingDetails
{
CalendarId = e.CalendarId,
BookingId = e.BookingId,
BookedBy = e.BookedBy,
StartTime = e.Start,
EndTime = e.End
});
break;
case Events.BookingRemoved e:
UpdateCalendarDetails(e.CalendarId, c => c.NumberOfBookings--);
_bookingDetails.Remove(
_bookingDetails.FirstOrDefault(b => b.BookingId == e.BookingId));
break;
}
return(Task.CompletedTask);
}
