public TAggregate GetById <TAggregate>(Guid id, int version = int.MaxValue) where TAggregate : class, IEventSource { if (version <= 0) { throw new InvalidOperationException("Cannot get version <= 0"); } var streamName = _streamNameBuilder.GenerateForAggregate(typeof(TAggregate), id); var aggregate = ConstructAggregate <TAggregate>(); long sliceStart = 0; StreamEventsSlice currentSlice; var appliedEventCount = 0; do { long sliceCount = sliceStart + ReadPageSize <= version ? ReadPageSize : version - sliceStart; currentSlice = _streamStoreConnection.ReadStreamForward(streamName, sliceStart, (int)sliceCount); if (currentSlice is StreamNotFoundSlice) { throw new AggregateNotFoundException(id, typeof(TAggregate)); } if (currentSlice is StreamDeletedSlice) { throw new AggregateDeletedException(id, typeof(TAggregate)); } sliceStart = currentSlice.NextEventNumber; appliedEventCount += currentSlice.Events.Length; aggregate.RestoreFromEvents(currentSlice.Events.Select(evt => _eventSerializer.Deserialize(evt))); } while (version > currentSlice.NextEventNumber && !currentSlice.IsEndOfStream); if (version != Int32.MaxValue && version != appliedEventCount) { throw new AggregateVersionException(id, typeof(TAggregate), version, aggregate.ExpectedVersion); } if (version != Int32.MaxValue && aggregate.ExpectedVersion != version - 1) { throw new AggregateVersionException(id, typeof(TAggregate), version, aggregate.ExpectedVersion); } return(aggregate); }
public IReadOnlyList <IDomainEvent> GetEvents(Guid aggregateId) { var events = new List <IDomainEvent>(); using (var context = new EventStoreContext(ConnectionString.Get())) { foreach (var dbEvent in context.Events.Where(a => a.AggregateId == aggregateId)) { events.Add(_eventSerializer.Deserialize <IDomainEvent>(dbEvent.Data)); } } return(events); }
private IRecordedEvent Transform(ReactiveEventEntity entity) { return(new RecordedEvent( entity.EventNumber, entity.EventId, entity.EventType, entity.AggregateId, entity.AggregateType, entity.AggregateVersion, _serializer.Deserialize(entity.SerializedData, _typeMapper.GetEventType(entity.EventType)) as IEvent, _serializer.Deserialize(entity.SerializedMetadata, _typeMapper.GetMetadataType(entity.EventType)) as IMetadata, DateTimeOffset.Parse(entity.Recorded) )); }
public async Task <TA> RehydrateAsync(TKey key) { var partitionKey = new PartitionKey(key.ToString()); var events = new List <IDomainEvent <TKey> >(); using var setIterator = _container.GetItemQueryIterator <EventData <TKey> >(requestOptions: new QueryRequestOptions { MaxItemCount = 100, PartitionKey = partitionKey }); while (setIterator.HasMoreResults) { foreach (var item in await setIterator.ReadNextAsync()) { var @event = _eventSerializer.Deserialize <TKey>(item.Type, item.Data); events.Add(@event); } } if (!events.Any()) { return(null); } var result = BaseAggregateRoot <TA, TKey> .Create(events.OrderBy(e => e.AggregateVersion)); return(result); }
public static IObservable <EventWithPosition <TEvent> > DeserializeWithPosition <TEvent>( this IObservable <Event> source, Action <Exception> exceptionHandler = null, IEventSerializer serializer = null) { serializer = serializer ?? new EventSerializer(); exceptionHandler = exceptionHandler ?? (_ => { }); return (source.Select(@event => { if ([email protected](typeof(TEvent).Name)) { return default(EventWithPosition <TEvent>); } try { return new EventWithPosition <TEvent>( serializer.Deserialize <TEvent>(@event), @event.Position); } catch (Exception e) { exceptionHandler(e); return default(EventWithPosition <TEvent>); } }) .Where(e => !Equals(e, default(EventWithPosition <TEvent>)))); }
public async Task <T> Load <T>(string id) where T : Aggregate, new() { Ensure.NotEmptyString(id, nameof(id)); var stream = StreamName.For <T>(id); var aggregate = new T(); try { await _eventStore.ReadStream(stream, StreamReadPosition.Start, Fold); } catch (Exceptions.StreamNotFound e) { throw new Exceptions.AggregateNotFound <T>(id, e); } return(aggregate); void Fold(StreamEvent streamEvent) { var evt = Deserialize(streamEvent); if (evt == null) { return; } aggregate !.Fold(evt); } object?Deserialize(StreamEvent streamEvent) => _serializer.Deserialize(streamEvent.Data.AsSpan(), streamEvent.EventType); }
private void Run_ShouldWriteEventData(IEventSerializer serializer) { var configuration = SetupDatabase(); var subscriber = new DatabaseEventSubscriber <IEvent>(configuration, serializer); var aggregateId = Guid.NewGuid().ToString(); var expectedData = $"This is my random data {Guid.NewGuid()}"; var testEvent = new EventWithData(aggregateId, expectedData); subscriber.OnEvent(testEvent); var connection = configuration.CreateConnection(); connection.Open(); var command = connection.CreateCommand(); command.CommandText = $"select data from {configuration.TableName}"; var actualBytes = command.ExecuteScalar(); var actual = serializer.Deserialize(testEvent.Type, (byte[])actualBytes); Assert.IsType <EventWithData>(actual); Assert.Equal(expectedData, ((EventWithData)actual).Data); }
protected async Task Handler(StreamSubscription sub, ResolvedEvent re, CancellationToken cancellationToken) { _debugLog?.Invoke( "Subscription {Subscription} got an event {@Event}", sub.SubscriptionId, re ); _lastProcessedPosition = GetPosition(re); if (re.Event.EventType.StartsWith("$")) { await Store(); } try { var evt = _eventSerializer.Deserialize(re.Event.Data.Span, re.Event.EventType); if (evt != null) { _debugLog?.Invoke("Handling event {Event}", evt); await Task.WhenAll( _projections.Select( x => x.HandleEvent(evt, (long?) re.OriginalPosition?.CommitPosition) ) ); } } catch (Exception e) { _log.LogWarning(e, "Error when handling the event {Event}", re.Event.EventType); } await Store(); Task Store() => StoreCheckpoint(GetPosition(re), cancellationToken); }
public async Task HandleAsync(Event @event) { _context.KeepAlive(); await _handler.HandleAsync(_context, _serializer.Deserialize(@event)); _context.KeepAlive(); }
public async Task HandleAsync(Event @event) { var command = _serializer.Deserialize(@event); await _handler.HandleAsync( new DomainCommandContext(_queryEndpointId, command.CreateEventContext(_hubClientFactory)), command.Data); }
public async Task <KeyValuePair <int, GrainState <T> > > ReadStateFromStorage() { _stream = $"{typeof(T).Name}:{ModelVersion()}:{this.GrainId()}"; var stream = _eventStore.ReadStreamAsync( Direction.Forwards, _stream, StreamPosition.Start); var state = new GrainState <T>(); var version = 0; if (await stream.ReadState != ReadState.StreamNotFound) { await foreach (var resolvedEvent in stream) { var json = Encoding.UTF8.GetString(resolvedEvent.Event.Data.Span); try { var eventObj = _eventSerializer.Deserialize(typeof(T), resolvedEvent.Event.EventType, json); state = state.Apply(eventObj); version++; } catch (Exception ex) { _logger.LogCritical(5004, ex, ex.Message); return(new KeyValuePair <int, GrainState <T> >(-1, new GrainState <T>())); } } } return(new KeyValuePair <int, GrainState <T> >(version, state)); }
public IDisposable SubscribeToStreamFrom( string stream, long?lastCheckpoint, bool resolveLinkTos, Action <Message> eventAppeared, Action liveProcessingStarted = null, Action <SubscriptionDropReason, Exception> subscriptionDropped = null, UserCredentials userCredentials = null, int readBatchSize = 500) { var settings = new CatchUpSubscriptionSettings(10, readBatchSize, false); StreamName = stream; var sub = _eventStoreConnection.SubscribeToStreamFrom( stream, lastCheckpoint, settings, resolvedEvent => { Interlocked.Exchange(ref _position, resolvedEvent.EventNumber); eventAppeared(_serializer.Deserialize(resolvedEvent) as Message); }, _ => liveProcessingStarted?.Invoke(), (reason, exception) => subscriptionDropped?.Invoke(reason, exception), userCredentials); return(new Disposer(() => { sub.Dispose(); return Unit.Default; })); }
private async Task HandleEvent(StreamSubscription subscription, ResolvedEvent resolvedEvent, CancellationToken cancellationToken) { var domainEvent = _eventSerializer.Deserialize(resolvedEvent); if (domainEvent == null) { return; } _logger.LogInformation($"PullRequestCommentsProjector handled event: {domainEvent}"); switch (domainEvent) { case SingleCommentWasAdded added: var comment = new PullRequestComment { PullRequestId = added.PullRequestId, CommentId = added.CommentId, PostedAt = added.OccurredAt, Author = added.Author, Text = added.Text }; await _repository.Save(comment); break; } }
private IEnumerable <IRecordedEvent> Transform(IEnumerable <RecordedEventEntity> entities) { foreach (var entity in entities) { yield return(new RecordedEvent( entity.EventNumber, entity.EventId, entity.EventType, entity.AggregateId, entity.AggregateType, entity.AggregateVersion, _eventSerializer.Deserialize(entity.SerializedData, _typeMapper.GetEventType(entity.EventType)) as IEvent, _eventSerializer.Deserialize(entity.SerializedMetadata, _typeMapper.GetMetadataType(entity.EventType)) as IMetadata, entity.Recorded )); } }
private StoredEvent ToStoredEvent(RecordedEvent recordedEvent) => new StoredEvent( recordedEvent.StreamId, recordedEvent.Id, recordedEvent.Number, recordedEvent.Type, recordedEvent.Created, (IDomainEvent)_serializer.Deserialize(recordedEvent));
protected virtual void GotEvent(RecordedEvent recordedEvent) { Interlocked.Exchange(ref StreamPosition, recordedEvent.EventNumber); if (Serializer.Deserialize(recordedEvent) is IMessage @event) { Bus.Publish(@event); } }
public T Load(int id) { IList <Event> result = _session.QueryOver <Event>().Where(f => f.AggregateId == id).List(); IEnumerable <IDomainEvent> domainEvents = result.Select(f => _serializer.Deserialize(Type.GetType(f.Type, true), f.Data)); T o = new T(); o.LoadFromHistory(domainEvents); return(o); }
private DomainEventStream ConvertFrom(EventStream record) { return(new DomainEventStream( record.CommandId, record.AggregateRootId, record.AggregateRootTypeName, record.Version, record.CreatedOn, _eventSerializer.Deserialize <IDomainEvent>(_jsonSerializer.Deserialize <IDictionary <string, string> >(record.Events)))); }
Event Deserialize(ResolvedEvent @event, IEventSerializer serializer) { var e = serializer.Deserialize( new EventData( @event.OriginalEvent.EventId, @event.OriginalEvent.EventType, false, @event.OriginalEvent.Data, @event.OriginalEvent.Metadata)); e.Version = @event.Event.EventNumber; return(e); }
public IEnumerable <IDomainEvent> GetEventsFor(Guid aggregateId) { var results = _repository.Get(x => x.AggregateId == aggregateId).ToList(); foreach (var eventEntity in results) { var type = _typeFactory.GetFor(eventEntity.EventName); var domainEvent = _serializer.Deserialize(eventEntity.EventData, type); yield return(domainEvent); } }
private IDomainEvent Deserialize(Models.Event entity) { var domainEvent = _eventSerializer.Deserialize(entity.Data, Type.GetType(entity.Type)); domainEvent.AggregateId = entity.AggregateId; domainEvent.AppliedByUserId = entity.AppliedByUserId; domainEvent.Version = entity.AggregateVersion; domainEvent.Timestamp = entity.Timestamp; domainEvent.Id = entity.EventId; return(domainEvent); }
protected async Task HandleMessage(Message msg) { var eventType = msg.UserProperties["type"] as string; var domainEvent = _eventSerializer.Deserialize <Guid>(eventType, msg.Body); if (null == domainEvent) { throw new SerializationException($"unable to deserialize event {eventType} : {msg.Body}"); } var @event = EventReceivedFactory.Create((dynamic)domainEvent); await _mediator.Publish(@event, CancellationToken.None); }
public void OnRelayMessage(byte[] data) { var remoteEvt = _serializer.Deserialize(data); if (_callbacks.ContainsKey(remoteEvt.Type)) { _callbacks[remoteEvt.Type](remoteEvt); } else { Debug.Log($"No follow up for relayed message of type {remoteEvt.Type}"); } }
private IEnumerable <IRecordedEvent> QueryEvents(string query) { using (var connection = new SqlConnection(_options.ConnectionString)) { var command = new SqlCommand(query, connection); connection.Open(); var reader = command.ExecuteReader(); while (reader.Read()) { var eventNumber = reader.GetInt64(0); var eventId = reader.GetGuid(1); var eventType = reader.GetString(2); var aggregateId = reader.GetGuid(3); var aggregateType = reader.GetString(4); var aggregateVersion = reader.GetInt64(5); var serializedData = reader.GetString(6); var serializedMetadata = reader.GetString(7); var recorded = reader.GetDateTimeOffset(8); yield return(new RecordedEvent( eventNumber, eventId, eventType, aggregateId, aggregateType, aggregateVersion, _serializer.Deserialize(serializedData, _typeMapper.GetEventType(eventType)) as IEvent, _serializer.Deserialize(serializedMetadata, _typeMapper.GetMetadataType(eventType)) as IMetadata, recorded )); } } }
protected virtual void EventRead(RecordedEvent recordedEvent) { // do not publish or increase counters if cancelled if (_cancelled) { return; } Interlocked.Exchange(ref StreamPosition, recordedEvent.EventNumber); firstEventRead = true; if (Serializer.Deserialize(recordedEvent) is IMessage @event) { Bus.Publish(@event); } }
private void Process <TEvent>(Action <TEvent> handle, BrokeredMessage brokeredMessage) where TEvent : DomainEvent { var jsonEvent = brokeredMessage.GetBody <string>(); var productDeletedEvent = _eventSerializer.Deserialize <TEvent>(jsonEvent); handle(productDeletedEvent); try { brokeredMessage.Complete(); } catch (Exception ex) { //do something else, e.g log brokeredMessage.DeadLetter(); //move to dead letter queue to inspect later } }
public static TEvent ToDomainEvent <TEvent>( StoredDomainEvent storedEvent, IEventSerializer serializer) where TEvent : IDomainEvent { var eventType = default(Type); try { eventType = Type.GetType(storedEvent.AggregateRootTypeName); } catch (Exception ex) { throw new InvalidOperationException(string.Format("Domain event type load error, because: {0}", ex)); } return(serializer.Deserialize <TEvent>(storedEvent.EventBody)); }
public async Task Handle(NotificationMessage <string> notificationMessage, CancellationToken cancellationToken) { if (notificationMessage == null) { throw new ArgumentNullException(nameof(notificationMessage)); } var eventStore = _jsonSerializer.Deserialize <EventStore>(notificationMessage.Message); var @event = _eventSerializer.Deserialize <Event>(eventStore.TypeName, eventStore.PayLoad); var projection = Invoker.CreateInstanceOfProjection <SpeechProjection>(); projection.Project(@event); if (projection.IsDeleted) { await _elasticSearchClient.DeleteAsync(projection).ContinueWith( result => { if (result.Status == TaskStatus.RanToCompletion) { Console.WriteLine($"**ElasticSearchNotifer::Handle - DeleteAsync {projection.Id} "); _publisher.PublishAsync(Topics.ReadModelAcknowledged, projection); } else if (result.Status == TaskStatus.Faulted) { Console.WriteLine($"**ElasticSearchNotifer::Handle - DeleteAsync {result.Exception?.GetBaseException().Message}"); } }, cancellationToken); } else { await _elasticSearchClient.CreateAsync(projection).ContinueWith( result => { if (result.Status == TaskStatus.RanToCompletion) { Console.WriteLine($"**ElasticSearchNotifer::Handle - CreateAsync {projection.Id} "); _publisher.PublishAsync(Topics.ReadModelAcknowledged, projection); } else if (result.Status == TaskStatus.Faulted) { Console.WriteLine($"**ElasticSearchNotifer::Handle - CreateAsync {result.Exception?.GetBaseException().Message}"); } }, cancellationToken); } }
public MockRepositorySpecification() { StreamNameBuilder = new PrefixedCamelCaseStreamNameBuilder(); StreamStoreConnection = new MockStreamStoreConnection("Test"); StreamStoreConnection.Connect(); EventSerializer = new JsonMessageSerializer(); MockRepository = new StreamStoreRepository(StreamNameBuilder, StreamStoreConnection, EventSerializer); var connectorBus = new InMemoryBus("connector"); StreamStoreConnection.SubscribeToAll(evt => { if (evt is ProjectedEvent) { return; } connectorBus.Publish((IMessage)EventSerializer.Deserialize(evt)); }); RepositoryEvents = new TestQueue(connectorBus, new[] { typeof(Event) }); }
Task OnEventReceived(string eventName, byte[] @event) { if (SubscriptionsManager.IsEmpty) { return(Task.CompletedTask); } var eventType = _eventNameTypeResolver.GetEventType(eventName); var eo = _eventSerializer.Deserialize(eventType, @event); var handlers = SubscriptionsManager.GetHandlers(eventType, _serviceProvider); if (handlers == null) { return(Task.CompletedTask); } return(_eventReceiver.Invoke(eventType, eo, handlers)); }
Event Deserialize(ResolvedEvent @event, IEventSerializer serializer) { var e = serializer.Deserialize( new EventData( @event.OriginalEvent.EventId, @event.OriginalEvent.EventType, false, @event.OriginalEvent.Data, @event.OriginalEvent.Metadata)); e.Version = @event.Event.EventNumber; return e; }