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 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(); }