private CommittedEvent ReadEventFromDbReader(NpgsqlDataReader reader) { StoredEvent<string> rawEvent = ReadEvent(reader); var document = _translator.TranslateToCommon(rawEvent); _converter.Upgrade(document); var payload = _formatter.Deserialize(document.Data, document.EventName); // TODO: Legacy stuff... we do not have a dummy id with the current schema. var dummyCommitId = Guid.Empty; var evnt = new CommittedEvent(dummyCommitId, document.EventIdentifier, document.EventSourceId, document.EventSequence, document.EventTimeStamp, payload, document.EventVersion); // TODO: Legacy stuff... should move. if (evnt is ISourcedEvent) { ((ISourcedEvent)evnt).InitializeFrom(rawEvent); } return evnt; }
public virtual CommittedEvent <TAggregateSaga, TIdentity, TAggregateEvent> From <TAggregateEvent>(TAggregateEvent aggregateEvent, long version, IMetadata metadata = null) where TAggregateEvent : IAggregateEvent <TAggregateSaga, TIdentity> { if (aggregateEvent == null) { throw new ArgumentNullException(nameof(aggregateEvent)); } _eventDefinitionService.Load(aggregateEvent.GetType()); var eventDefinition = _eventDefinitionService.GetDefinition(aggregateEvent.GetType()); var aggregateSequenceNumber = version + 1; var eventId = EventId.NewDeterministic( GuidFactories.Deterministic.Namespaces.Events, $"{Id.Value}-v{aggregateSequenceNumber}"); var now = DateTimeOffset.UtcNow; var eventMetadata = new Metadata { Timestamp = now, AggregateSequenceNumber = aggregateSequenceNumber, AggregateName = Name.Value, AggregateId = Id.Value, EventId = eventId, EventName = eventDefinition.Name, EventVersion = eventDefinition.Version }; eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString()); if (metadata != null) { eventMetadata.AddRange(metadata); } var committedEvent = new CommittedEvent <TAggregateSaga, TIdentity, TAggregateEvent>(Id, aggregateEvent, eventMetadata, now, aggregateSequenceNumber); return(committedEvent); }
public void CommittedEvent_WhenTagged_ContainsAggregateEventAsTaggedElement() { var aggregateEventTagger = new AggregateEventTagger(new EventDefinitions()); var aggregateSequenceNumber = 3; var aggregateId = TestAggregateId.New; var entityId = TestId.New; var entity = new Test(entityId); var aggregateEvent = new TestAddedEvent(entity); var now = DateTimeOffset.UtcNow; var eventId = EventId.NewDeterministic(GuidFactories.Deterministic.Namespaces.Events, $"{aggregateId.Value}-v{3}"); var eventMetadata = new EventMetadata { Timestamp = now, AggregateSequenceNumber = aggregateSequenceNumber, AggregateName = typeof(TestAggregate).GetAggregateName().Value, AggregateId = aggregateId.Value, EventId = eventId }; var committedEvent = new CommittedEvent <TestAggregateId, TestAddedEvent>( aggregateId, aggregateEvent, eventMetadata, now, aggregateSequenceNumber); var taggedEvent = aggregateEventTagger.ToJournal(committedEvent); if (taggedEvent is Tagged a) { a.Tags.Should().Contain("TestAdded"); } else { false.Should().BeTrue(); } }
private void ValidateHistoricalEvent(CommittedEvent evnt) { if (evnt.EventSourceId != EventSourceId) { var message = String.Format("Cannot apply historical event from other event source."); throw new InvalidOperationException(message); } // TODO: Do we really really need this check? Why don't we trust IEventStore? if (evnt.EventSequence != Version + 1) { var message = String.Format("Cannot apply event with sequence {0}. Since the initial version of the " + "aggregate root is {1}. Only an event with sequence number {2} can be applied.", evnt.EventSequence, Version, Version + 1); throw new InvalidOperationException(message); } }
/// <inheritdoc/> public Task <IProcessingResult> Process(CommittedEvent @event, PartitionId partitionId, string failureReason, uint retryCount, CancellationToken cancellationToken) { _logger.Trace("Retrying processing of Event from Event Horizon"); return(Process(@event, cancellationToken)); }
/// <inheritdoc/> public abstract Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, CancellationToken cancellationToken);
/// <summary> /// Gets the <see cref="AggregateMetadata" /> from a <see cref="CommittedEvent" />. /// </summary> /// <param name="committedEvent">The <see cref="CommittedEvent" />.</param> /// <returns>The <see cref="AggregateMetadata"/>.</returns> public static AggregateMetadata GetAggregateMetadata(this CommittedEvent committedEvent) => committedEvent is CommittedAggregateEvent aggregateEvent ?
/// <summary> /// Gets the <see cref="EventMetadata"/> from the <see cref="CommittedEvent"/>. /// </summary> /// <param name="committedEvent">The <see cref="CommittedEvent"/>.</param> /// <returns>The converted <see cref="EventMetadata" />.</returns> public static EventMetadata GetEventMetadata(this CommittedEvent committedEvent) =>
/// <inheritdoc/> public override Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, string failureReason, uint retryCount, ExecutionContext executionContext, CancellationToken cancellationToken) => Filter(@event, partitionId, eventProcessorId, executionContext, cancellationToken);
/// <inheritdoc/> public Task Write(CommittedEvent @event, ScopeId scope, StreamId streamId, PartitionId partitionId, CancellationToken cancellationToken) => Write(@event, streamId, partitionId, cancellationToken);
/// <summary> /// Convert to a protobuf message representation of <see cref="CommittedEvent"/>. /// </summary> /// <param name="event"><see cref="CommittedEvent"/> to convert from.</param> /// <returns>Converted <see cref="Contracts.CommittedEvent"/>.</returns> public static Contracts.CommittedEvent ToProtobuf(this CommittedEvent @event) => @event is CommittedExternalEvent externalEvent?
/// <summary> /// Gets the <see cref="EventHorizonMetadata"/> from the <see cref="CommittedEvent"/>. /// </summary> /// <param name="committedEvent">The <see cref="CommittedEvent"/>.</param> /// <returns>The converted <see cref="EventHorizonMetadata" />.</returns> public static EventHorizonMetadata GetEventHorizonMetadata(this CommittedEvent committedEvent) => committedEvent is CommittedExternalEvent externalEvent?
/// <inheritdoc/> public Task <IProcessingResult> Process(CommittedEvent @event, PartitionId partitionId, string failureReason, uint retryCount, ExecutionContext executionContext, CancellationToken cancellationToken) { Log.RetryProcessEvent(_logger, _subscriptionId); return(Process(@event, cancellationToken)); }
/// <inheritdoc/> public Task <IProcessingResult> Process(CommittedEvent @event, PartitionId partitionId, ExecutionContext executionContext, CancellationToken cancellationToken) => Process(@event, cancellationToken);
private static bool AreEqual(UncommittedEvent uncommitted, CommittedEvent committed) { return uncommitted.EventIdentifier == committed.EventIdentifier && uncommitted.EventSourceId == committed.EventSourceId && uncommitted.Payload.Equals(committed.Payload) && uncommitted.EventTimeStamp == committed.EventTimeStamp && uncommitted.EventSequence == committed.EventSequence; }
private void CommittedEvent_Trans(CommittedEvent evt, EventEnvelope envelope) { // Put your code here throw new NotImplementedException(); }
/// <inheritdoc/> public Task <IProjectionResult> Project(ProjectionCurrentState state, CommittedEvent @event, PartitionId partitionId, ExecutionContext executionContext, CancellationToken cancellationToken) => Process(state, @event, partitionId, new ProjectionRequest(), executionContext, cancellationToken);
bool ShouldProcessEvent(CommittedEvent @event) => _projectionDefinition.Events.Select(_ => _.EventType).Contains(@event.Type.Id);
bool TryGetKey(ProjectionEventSelector eventSelector, CommittedEvent @event, PartitionId partition, out ProjectionKey key) => PartitionIsKey(eventSelector.KeySelectorType, partition, out key) || EventSourceIsKey(eventSelector.KeySelectorType, @event.EventSource, out key) || PropertyIsKey(eventSelector.KeySelectorType, @event.Content, eventSelector.KeySelectorExpression, out key) || StaticIsKey(eventSelector.KeySelectorType, eventSelector.StaticKey, out key) || OccurredIsKey(eventSelector.KeySelectorType, eventSelector.OccurredFormat, @event.Occurred, out key);
public CouldNotGetProjectionKey(CommittedEvent @event) : base($"Could not get projection key from event on sequence number {@event.EventLogSequenceNumber} with content '{@event.Content}'") { }
/// <summary> /// /// </summary> /// <param name="issuccess"></param> protected virtual void OnCommittedEvent(bool issuccess) { CommittedEvent?.Invoke(issuccess); }
public void On(CommittedEvent evnt) { CommittedEventProcessed = true; }
public Task <FilterResult> Filter(CommittedEvent @event) { _logger.Warning("Filtering public event '{Event}'", @event); return(Task.FromResult(new FilterResult(true))); }
private void ApplyEventFromHistory(CommittedEvent evnt) { ValidateHistoricalEvent(evnt); Log.DebugFormat("Handling historical event {0} in event source {1}", evnt, this); HandleEvent(evnt.Payload); _currentVersion++; }
/// <inheritdoc/> public abstract Task <IFilterResult> Filter(CommittedEvent @event, PartitionId partitionId, EventProcessorId eventProcessorId, string failureReason, uint retryCount, CancellationToken cancellationToken);
protected virtual void Emit <TAggregateEvent>(TAggregateEvent aggregateEvent, IMetadata metadata = null) where TAggregateEvent : IAggregateEvent <TAggregateSaga, TIdentity> { if (aggregateEvent == null) { throw new ArgumentNullException(nameof(aggregateEvent)); } _eventDefinitionService.Load(typeof(TAggregateEvent)); var eventDefinition = _eventDefinitionService.GetDefinition(typeof(TAggregateEvent)); var aggregateSequenceNumber = Version + 1; var eventId = EventId.NewDeterministic( GuidFactories.Deterministic.Namespaces.Events, $"{Id.Value}-v{aggregateSequenceNumber}"); var now = DateTimeOffset.UtcNow; var eventMetadata = new Metadata { Timestamp = now, AggregateSequenceNumber = aggregateSequenceNumber, AggregateName = Name.Value, AggregateId = Id.Value, EventId = eventId, EventName = eventDefinition.Name, EventVersion = eventDefinition.Version, }; eventMetadata.Add(MetadataKeys.TimestampEpoch, now.ToUnixTime().ToString()); if (metadata != null) { eventMetadata.AddRange(metadata); } var committedEvent = new CommittedEvent <TAggregateSaga, TIdentity, TAggregateEvent>(Id, aggregateEvent, eventMetadata, now, Version); Persist(committedEvent, ApplyCommittedEvents); Logger.Info($"[{Name}] With Id={Id} Commited [{typeof(TAggregateEvent).PrettyPrint()}]"); Version++; var aggregateApplyMethod = GetEventApplyMethods(aggregateEvent); Persist(aggregateEvent, aggregateApplyMethod); Logger.Info($"[{Name}] With Id={Id} Commited [{typeof(TAggregateEvent).PrettyPrint()}]"); Version++; var domainEvent = new DomainEvent <TAggregateSaga, TIdentity, TAggregateEvent>(Id, aggregateEvent, eventMetadata, now, Version); Publish(domainEvent); if (SnapshotStrategy.ShouldCreateSnapshot(this)) { var aggregateSnapshot = CreateSnapshot(); if (aggregateSnapshot != null) { var t = aggregateSnapshot.GetType(); _snapshotDefinitionService.Load(aggregateSnapshot.GetType()); var snapshotDefinition = _snapshotDefinitionService.GetDefinition(aggregateSnapshot.GetType()); var snapshotMetadata = new Aggregates.Snapshot.SnapshotMetadata { AggregateId = Id.Value, AggregateName = Name.Value, AggregateSequenceNumber = Version, SnapshotName = snapshotDefinition.Name, SnapshotVersion = snapshotDefinition.Version }; var commitedSnapshot = new ComittedSnapshot <TAggregateSaga, TIdentity, IAggregateSnapshot <TAggregateSaga, TIdentity> >( Id, aggregateSnapshot, snapshotMetadata, now, Version); SaveSnapshot(commitedSnapshot); } } }