private static async Task MessageAppeared(string errorStream, string chekPointStream, Func<object, Dictionary<string, object>, Task> handle, ResolvedEvent @event)
{
try
{
var eventWithMeta = Serialization.DeserializeResolvedEventWithMetadata(@event);
var causationMetadata = eventWithMeta.Metadata;
causationMetadata.Cast();
Exception error = null;
try
{
await handle(eventWithMeta.Event, causationMetadata);
}
catch (Exception ex)
{
Log.ErrorFormat(ex, "error handling message id {0}", @event.Event.EventId);
error = ex;
}
if (error != null)
{
var eventData = Append.NewEventData(error.Message, MessageMetadata.New(causationMetadata), "handleError");
await Append.ToStream(errorStream, eventData);
}
await SetCheckPoint(chekPointStream, @event.OriginalEventNumber);
}
catch (Exception ex)
{
Log.ErrorFormat(ex, "error when event {0} id {1} appeared on stream checkPointed by {2}", @event.GetType(), @event.Event.EventId, chekPointStream);
}
}
public override void RecordEventOrder(ResolvedEvent resolvedEvent, CheckpointTag orderCheckpointTag, Action committed)
{
EnsureStarted();
if (_stopping)
throw new InvalidOperationException("Stopping");
var orderStreamName = _namingBuilder.GetOrderStreamName();
_orderStream.EmitEvents(
new[]
{
new EmittedDataEvent(
orderStreamName, Guid.NewGuid(), "$>",
resolvedEvent.PositionSequenceNumber + "@" + resolvedEvent.PositionStreamId, null,
orderCheckpointTag, _lastOrderCheckpointTag, v => committed())
});
_lastOrderCheckpointTag = orderCheckpointTag;
}
public override void RecordEventOrder(
ResolvedEvent resolvedEvent, CheckpointTag orderCheckpointTag, Action committed)
{
EnsureStarted();
if (_stopping)
throw new InvalidOperationException("Stopping");
var orderStreamName = _namingBuilder.GetOrderStreamName();
//TODO: -order stream requires correctly configured event expiration.
// the best is to truncate using $startFrom, but $maxAge should be also acceptable
_orderStream.EmitEvents(
new[]
{
new EmittedDataEvent(
orderStreamName, Guid.NewGuid(), "$>",
false, resolvedEvent.PositionSequenceNumber + "@" + resolvedEvent.PositionStreamId, null,
orderCheckpointTag, _lastOrderCheckpointTag, v => committed())
});
_lastOrderCheckpointTag = orderCheckpointTag;
}
public static EntryElement ToEntry(ResolvedEvent eventLinkPair, Uri requestedUrl, EmbedLevel embedContent, bool singleEntry = false)
{
if (eventLinkPair.Event == null || requestedUrl == null)
{
return(null);
}
var evnt = eventLinkPair.Event;
EntryElement entry;
if (embedContent > EmbedLevel.Content)
{
var richEntry = new RichEntryElement();
entry = richEntry;
richEntry.EventType = evnt.EventType;
richEntry.EventNumber = evnt.EventNumber;
richEntry.StreamId = evnt.EventStreamId;
richEntry.PositionEventNumber = eventLinkPair.OriginalEvent.EventNumber;
richEntry.PositionStreamId = eventLinkPair.OriginalEvent.EventStreamId;
richEntry.IsJson = (evnt.Flags & PrepareFlags.IsJson) != 0;
if (embedContent >= EmbedLevel.Body)
{
if (richEntry.IsJson)
{
if (embedContent >= EmbedLevel.PrettyBody)
{
try
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(Helper.UTF8NoBom.GetString(evnt.Data));
}
catch
{
// ignore - we tried
}
}
else
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
}
}
else if (embedContent >= EmbedLevel.TryHarder)
{
try
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(richEntry.Data);
// it is json if successed
richEntry.IsJson = true;
}
catch
{
// ignore - we tried
}
}
// metadata
if (embedContent >= EmbedLevel.PrettyBody)
{
try
{
richEntry.MetaData = Helper.UTF8NoBom.GetString(evnt.Metadata);
richEntry.IsMetaData = richEntry.MetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
richEntry.MetaData = FormatJson(richEntry.MetaData);
}
catch
{
// ignore - we tried
}
var lnk = eventLinkPair.Link;
if (lnk != null)
{
try
{
richEntry.LinkMetaData = Helper.UTF8NoBom.GetString(lnk.Metadata);
richEntry.IsLinkMetaData = richEntry.LinkMetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
richEntry.LinkMetaData = FormatJson(richEntry.LinkMetaData);
}
catch
{
// ignore - we tried
}
}
}
}
}
else
{
entry = new EntryElement();
}
var escapedStreamId = Uri.EscapeDataString(evnt.EventStreamId);
entry.SetTitle(evnt.EventNumber + "@" + evnt.EventStreamId);
entry.SetId(HostName.Combine(requestedUrl, "/streams/{0}/{1}", escapedStreamId, evnt.EventNumber));
entry.SetUpdated(evnt.TimeStamp);
entry.SetAuthor(AtomSpecs.Author);
entry.SetSummary(evnt.EventType);
if ((singleEntry || embedContent == EmbedLevel.Content) && ((evnt.Flags & PrepareFlags.IsJson) != 0))
{
entry.SetContent(AutoEventConverter.CreateDataDto(eventLinkPair));
}
entry.AddLink("edit", HostName.Combine(requestedUrl, "/streams/{0}/{1}", escapedStreamId, evnt.EventNumber));
entry.AddLink("alternate", HostName.Combine(requestedUrl, "/streams/{0}/{1}", escapedStreamId, evnt.EventNumber));
return(entry);
}
public static string MetaAsString(this ResolvedEvent evt) => evt.Event.IsJson ? Deserialise(evt.Event.Metadata) : null;
private async Task EventAppeared(EventStorePersistentSubscriptionBase @base, ResolvedEvent resolvedEvent) => await Dispatch(resolvedEvent);
public bool ProcessPartitionCreated(string partition, CheckpointTag createPosition, ResolvedEvent data,
out EmittedEventEnvelope[] emittedEvents)
{
emittedEvents = null;
return(false);
}
private Task HandleEvent(EventStorePersistentSubscriptionBase sub, ResolvedEvent resolvedEvent)
{
_firstEvent = resolvedEvent;
_resetEvent.Set();
return(Task.CompletedTask);
}
private IDomainEvent ConvertToDomainEvent(ResolvedEvent @event)
{
var eventType = _eventStoreSettings.EventTypes[@event.Event.EventType];
return(_jsonByteConverter.Deserialize(@event.Event.Data, eventType) as IDomainEvent);
}
public StreamEventAppeared(ResolvedEvent @event)
{
Event = @event;
}
private void GotDebit(EventStoreSubscription sub, ResolvedEvent resolvedEvent)
{
_debitCount++;
_view.Debits = _debitCount;
_view.Transactions = _creditCount + _debitCount;
}
private static async Task EventAppeared(EventStorePersistentSubscriptionBase eventStorePersistentSubscriptionBase, ResolvedEvent resolvedEvent)
{
if (resolvedEvent.Event.EventNumber > 0 &&
resolvedEvent.Event.EventNumber % 500 == 0)
{
var metaJsonData = Encoding.UTF8.GetString(resolvedEvent.Event.Metadata);
var eventMetaData = JsonConvert.DeserializeObject <DomainMetadata>(metaJsonData);
if (eventMetaData.Schema != AccountSchema.SchemaName)
{
return;
}
var account = await _repository.GetAccountById(Guid.Parse(eventMetaData.StreamId));
await _eventStore.SaveSnapshot(new AccountEventStreamId(account.Id), new AccountSnapShot()
{
Balance = account.State.Balance,
AccountNumber = account.State.AccountNumber,
StreamId = account.Id,
SnapshotStreamVersion = account.StreamVersion
});
Console.WriteLine($"Account: {eventMetaData.StreamId}, balance: {account.State.Balance}");
Console.WriteLine($"Event {resolvedEvent.Event.EventNumber}: {resolvedEvent.Event.EventId}");
}
}
private uint GetAssignmentId(ResolvedEvent ev)
{
string sourceStreamId = GetSourceStreamId(ev);
return(_hash.Hash(sourceStreamId) % (uint)_state.Assignments.Length);
}
private void OnEventRemoved(PersistentSubscriptionClient client, ResolvedEvent ev)
{
var assignmentId = GetAssignmentId(ev);
_state.EventRemoved(client.CorrelationId, assignmentId);
}
public TaggedResolvedEvent(ResolvedEvent resolvedEvent, string eventCategory, CheckpointTag readerPosition)
{
ResolvedEvent = resolvedEvent;
EventCategory = eventCategory;
ReaderPosition = readerPosition;
}
private void OnEventAppeared(EventStoreCatchUpSubscription catchUpSubscription, ResolvedEvent resolvedEvent)
{
if (resolvedEvent.Event.EventType.StartsWith("$"))
{
return;
}
Trace.TraceInformation("Created: {0}", resolvedEvent.OriginalEvent.Created);
Trace.TraceInformation("OriginalEventStreamId: {0}", resolvedEvent.OriginalEvent.EventStreamId);
Trace.TraceInformation("OriginalEventType: {0}", resolvedEvent.OriginalEvent.EventType);
Trace.TraceInformation("OriginalEventData: {0}", Encoding.UTF8.GetString(resolvedEvent.Event.Data));
var eventType = Type.GetType(resolvedEvent.OriginalEvent.EventType + ", " + typeof(DomainEvent).Assembly.FullName);
var json = Encoding.UTF8.GetString(resolvedEvent.OriginalEvent.Data);
var @event = JsonConvert.DeserializeObject(json, eventType) as dynamic;
_hub.Publish(@event);
SaveLastCheckPoint(resolvedEvent);
}
private IDomainEvent<TKey> Map(ResolvedEvent resolvedEvent)
{
var meta = System.Text.Json.JsonSerializer.Deserialize<EventMeta>(resolvedEvent.Event.Metadata);
return _eventDeserializer.Deserialize<TKey>(meta.EventType, resolvedEvent.Event.Data);
}
public override void RecordEventOrder(ResolvedEvent resolvedEvent, CheckpointTag orderCheckpointTag, Action committed)
{
committed();
}
public static EntryElement ToEntry(ResolvedEvent eventLinkPair, Uri requestedUrl, EmbedLevel embedContent, bool singleEntry = false)
{
if (requestedUrl == null)
{
return(null);
}
var evnt = eventLinkPair.Event;
var link = eventLinkPair.Link;
EntryElement entry;
if (embedContent > EmbedLevel.Content && evnt != null)
{
var richEntry = new RichEntryElement();
entry = richEntry;
richEntry.EventId = evnt.EventId;
richEntry.EventType = evnt.EventType;
richEntry.EventNumber = evnt.EventNumber;
richEntry.StreamId = evnt.EventStreamId;
richEntry.PositionEventNumber = eventLinkPair.OriginalEvent.EventNumber;
richEntry.PositionStreamId = eventLinkPair.OriginalEvent.EventStreamId;
richEntry.IsJson = (evnt.Flags & PrepareFlags.IsJson) != 0;
if (embedContent >= EmbedLevel.Body && eventLinkPair.Event != null)
{
if (richEntry.IsJson)
{
if (embedContent >= EmbedLevel.PrettyBody)
{
try
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(Helper.UTF8NoBom.GetString(evnt.Data));
}
catch
{
// ignore - we tried
}
}
else
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
}
}
else if (embedContent >= EmbedLevel.TryHarder)
{
try
{
richEntry.Data = Helper.UTF8NoBom.GetString(evnt.Data);
// next step may fail, so we have already assigned body
richEntry.Data = FormatJson(richEntry.Data);
// it is json if successed
richEntry.IsJson = true;
}
catch
{
// ignore - we tried
}
}
// metadata
if (embedContent >= EmbedLevel.PrettyBody)
{
try
{
richEntry.MetaData = Helper.UTF8NoBom.GetString(evnt.Metadata);
richEntry.IsMetaData = richEntry.MetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
richEntry.MetaData = FormatJson(richEntry.MetaData);
}
catch
{
// ignore - we tried
}
var lnk = eventLinkPair.Link;
if (lnk != null)
{
try
{
richEntry.LinkMetaData = Helper.UTF8NoBom.GetString(lnk.Metadata);
richEntry.IsLinkMetaData = richEntry.LinkMetaData.IsNotEmptyString();
// next step may fail, so we have already assigned body
richEntry.LinkMetaData = FormatJson(richEntry.LinkMetaData);
}
catch
{
// ignore - we tried
}
}
}
}
}
else
{
entry = new EntryElement();
}
if (evnt != null)
{
SetEntryProperties(evnt.EventStreamId, evnt.EventNumber, evnt.TimeStamp, requestedUrl, entry);
entry.SetSummary(evnt.EventType);
if ((singleEntry || embedContent == EmbedLevel.Content) && ((evnt.Flags & PrepareFlags.IsJson) != 0))
{
entry.SetContent(AutoEventConverter.CreateDataDto(eventLinkPair));
}
}
else if (link != null)
{
var pieces = Encoding.UTF8.GetString(link.Data).Split('@');
if (pieces.Length != 2)
{
throw new Exception("link not in proper format.");
}
var eventNumber = int.Parse(pieces[0]);
var streamId = pieces[1];
SetEntryProperties(streamId, eventNumber, link.TimeStamp, requestedUrl, entry);
entry.SetSummary("$>");
}
return(entry);
}
private void DeliverEvent(EventStore.Core.Data.ResolvedEvent pair, float progress)
{
_deliveredEvents++;
EventRecord positionEvent = pair.OriginalEvent;
if (positionEvent.LogPosition > _limitingCommitPosition)
return;
var resolvedEvent = new ResolvedEvent(pair, null);
if (resolvedEvent.IsLinkToDeletedStream || resolvedEvent.IsStreamDeletedEvent)
return;
_publisher.Publish(
//TODO: publish both link and event data
new ReaderSubscriptionMessage.CommittedEventDistributed(
EventReaderCorrelationId, resolvedEvent,
_stopOnEof ? (long?) null : positionEvent.LogPosition, progress, source: GetType(),
preTagged:
CheckpointTag.FromByStreamPosition(
0, _catalogStreamName, _catalogCurrentSequenceNumber, positionEvent.EventStreamId,
positionEvent.EventNumber, _limitingCommitPosition.Value)));
//TODO: consider passing phase from outside instead of using 0 (above)
}
static Task HandleEvent(ResolvedEvent evnt)
{
return(Task.CompletedTask);
}
private static Task HandleEvent(EventStorePersistentSubscriptionBase sub, ResolvedEvent resolvedEvent)
{
throw new Exception("test");
}
private async Task EventAppeared(EventStoreSubscription subscription, ResolvedEvent resolvedEvent) => await Dispatch(resolvedEvent);
public string GetStatePartition(CheckpointTag eventPosition, string category, ResolvedEvent data)
{
throw new NotImplementedException();
}
public SequencedEvent(long sequence, ResolvedEvent @event)
{
this.Sequence = sequence;
this.Event = @event;
}
public static object Deserialize(this ResolvedEvent resolvedEvent) =>
JsonConvert.DeserializeObject(Encoding.UTF8.GetString(resolvedEvent.Event.Data),
new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.Objects
});
private string GetLinkToFor(ResolvedEvent ev)
{
return(string.Format("{0}@{1}", ev.Event.EventNumber, ev.Event.EventStreamId));
}
protected abstract IMessage CreateMessage(IEvent @event, ResolvedEvent resolvedEvent);
private Task SubscribeReturn(StreamSubscription ss, ResolvedEvent vnt, CancellationToken ct)
{
Console.WriteLine($"Received event {vnt.OriginalEventNumber}@{vnt.OriginalStreamId}");
Console.WriteLine($"Data {Encoding.UTF8.GetString(vnt.Event.Data.Span)}");
return(Task.CompletedTask);
}
private void WriteStateCompleted(Action <ResolvedEvent, OperationResult> completed, ResolvedEvent ev,
ClientMessage.WriteEventsCompleted msg)
{
if (completed != null)
{
completed(ev, msg.Result);
}
}
public TaggedResolvedEvent(ResolvedEvent resolvedEvent, string eventCategory, CheckpointTag readerPosition)
{
ResolvedEvent = resolvedEvent;
EventCategory = eventCategory;
ReaderPosition = readerPosition;
}
public StreamEventAppeared(Guid correlationId, ResolvedEvent @event)
{
CorrelationId = correlationId;
Event = @event;
}
public object Deserialize(ResolvedEvent resolvedEvent)
{
return(null);
}
private void EventAppeared(ResolvedEvent e)
{
if (_unsubscribed != 0)
return;
if (_subscription == null) throw new Exception("Subscription not confirmed, but event appeared!");
if (_verboseLogging)
_log.Debug("Subscription {0:B} to {1}: event appeared ({2}, {3}, {4} @ {5}).",
_correlationId, _streamId == string.Empty ? "<all>" : _streamId,
e.OriginalStreamId, e.OriginalEventNumber, e.OriginalEvent.EventType, e.OriginalPosition);
ExecuteActionAsync(() => _eventAppeared(_subscription, e));
}
public async Task HandleReadEvents(EventStoreCatchUpSubscription subscription, ResolvedEvent resolvedEvent)
{
if (resolvedEvent.OriginalPosition == null)
{
throw new ArgumentNullException(nameof(resolvedEvent.OriginalPosition));
}
var @event = resolvedEvent.DeserializeEvent();
if (@event != null)
{
var queryEvent = GenericEventActivator.CreateQueryEvent(@event);
await _mediator.Publish(queryEvent);
await UpdatePosition(resolvedEvent.OriginalPosition.Value);
}
}
public abstract void RecordEventOrder(ResolvedEvent resolvedEvent, CheckpointTag orderCheckpointTag, Action committed);
public string GetStatePartition(CheckpointTag eventPosition, string category, ResolvedEvent data)
{
_logger("GetStatePartition(" + "..." + ")");
return(@data.EventStreamId);
}
public ReadAllEventsCompleted(long commitPosition, long preparePosition, ResolvedEvent[] events, long nextCommitPosition, long nextPreparePosition)
{
CommitPosition = commitPosition;
PreparePosition = preparePosition;
Events = events;
NextCommitPosition = nextCommitPosition;
NextPreparePosition = nextPreparePosition;
}
public string TransformCatalogEvent(CheckpointTag eventPosition, ResolvedEvent data)
{
throw new NotImplementedException();
}
public ReadAllEventsCompleted(long commitPosition, long preparePosition, ResolvedEvent[] events, long nextCommitPosition, long nextPreparePosition, ReadAllEventsCompleted.ReadAllResult result, string error)
{
CommitPosition = commitPosition;
PreparePosition = preparePosition;
Events = events;
NextCommitPosition = nextCommitPosition;
NextPreparePosition = nextPreparePosition;
Result = result;
Error = error;
}
public bool ProcessPartitionCreated(string partition, CheckpointTag createPosition, ResolvedEvent data, out EmittedEventEnvelope[] emittedEvents)
{
throw new NotImplementedException();
}
