public virtual Task Append(Guid aggregateId, long expectedAggregateVersion, IEnumerable <IPendingEvent> pendingEvents) { // From testing, returning a task has better performance than using await/async on sql methods. return(Task.Run(() => { using (var connection = new SqlConnection(_options.ConnectionString)) { connection.Open(); using (var transaction = connection.BeginTransaction()) { foreach (var @event in pendingEvents) { var command = new SqlCommand($@"INSERT INTO {_options.EventsTableName} VALUES(@eventId, @eventType, @aggregateId, @aggregateType, @aggregateVersion, @serializedData, @serializedMetadata, @recorded)", connection, transaction); command.Parameters.AddWithValue("@eventId", Guid.NewGuid()); command.Parameters.AddWithValue("@eventType", @event.EventType); command.Parameters.AddWithValue("@aggregateId", aggregateId); command.Parameters.AddWithValue("@aggregateType", @event.AggregateType); command.Parameters.AddWithValue("@aggregateVersion", ++expectedAggregateVersion); command.Parameters.AddWithValue("@serializedData", _serializer.Serialize(@event.Data)); command.Parameters.AddWithValue("@serializedMetadata", _serializer.Serialize(@event.Metadata)); command.Parameters.AddWithValue("@recorded", DateTimeOffset.Now); command.ExecuteNonQuery(); } transaction.Commit(); } } })); }
public void ShouldSerializeDomainEvent() { var registrationId = new RegistrationId(1); var domainEvent = new RegistrationPaid(registrationId, new ExternalRegistrationId(), DateTime.UtcNow); var serialized = _eventSerializer.Serialize(domainEvent); serialized.IsSuccess.Should().BeTrue(); serialized.Value.Namespace.Should().Be("Registrations"); serialized.Value.Type.Should().Be(nameof(RegistrationPaid)); serialized.Value.Payload.Should().Contain(registrationId.Value.ToString()); }
public async Task <TView> AddAsync(string subject, Func <TView> add, CancellationToken cancellationToken = default) { if (cancellationToken.IsCancellationRequested) { _logger.LogInformation($"{nameof(RedisProjectionWriter<TView>)}.{nameof(AddAsync)} was cancelled before execution"); cancellationToken.ThrowIfCancellationRequested(); } var view = add(); await _cache.SetAsync(BuildKey(subject), _eventSerializer.Serialize(view), cancellationToken); return(view); }
EventData CreateMessage(object message, Type type, object?metadata) { var msg = Ensure.NotNull(message, nameof(message)); var typeName = TypeMap.GetTypeNameByType(type); var metaBytes = metadata == null ? null : _serializer.Serialize(metadata); return(new EventData( Uuid.NewUuid(), typeName, _serializer.Serialize(msg), metaBytes, _serializer.ContentType )); }
public async Task DispatchAsync(TA aggregateRoot) { if (null == aggregateRoot) { throw new ArgumentNullException(nameof(aggregateRoot)); } if (!aggregateRoot.Events.Any()) { return; } _logger.LogInformation("publishing " + aggregateRoot.Events.Count + " events for {AggregateId} ...", aggregateRoot.Id); var messages = aggregateRoot.Events.Select(@event => { var eventType = @event.GetType(); var serialized = _eventSerializer.Serialize(@event); var message = new Message(serialized) { CorrelationId = aggregateRoot.Id.ToString(), UserProperties = { { "aggregate", aggregateRoot.Id.ToString() }, { "type", eventType.AssemblyQualifiedName } } }; return(message); }).ToList(); await _topicClient.SendAsync(messages); }
public void OnEvent(T @event) { using (var conn = _configuration.CreateConnection()) { conn.Open(); var cmd = conn.CreateCommand(); cmd.CommandText = $@"insert into {_configuration.TableName} ( id , aggregateId , eventType , eventDateTime , savedTimestamp , data ) values ( @id , @aggregateId , @eventType , @eventDateTime , @savedTimestamp , @data )"; cmd.AddWithValue("@id", @event.Id); cmd.AddWithValue("@aggregateId", @event.AggregateId); cmd.AddWithValue("@eventType", @event.Type); cmd.AddWithValue("@eventDateTime", @event.EventDateTime); cmd.AddWithValue("@savedTimestamp", DateTime.Now); cmd.AddWithValue("@data", _serializer.Serialize(@event)); cmd.ExecuteNonQuery(); } }
public when_using_listener_start_with_custom_stream_synched(StreamStoreConnectionFixture fixture) { var conn = fixture.Connection; conn.Connect(); // Build an origin stream from strings to which the the events are appended var originStreamName = $"testStream-{Guid.NewGuid():N}"; var result = fixture.Connection.AppendToStream( originStreamName, ExpectedVersion.NoStream, null, _eventSerializer.Serialize(new TestEvent())); Assert.True(result.NextExpectedVersion == 0); // Wait for the stream to be written CommonHelpers.WaitForStream(conn, originStreamName); StreamListener listener = new QueuedStreamListener( originStreamName, fixture.Connection, new PrefixedCamelCaseStreamNameBuilder(), _eventSerializer); listener.EventStream.Subscribe(new AdHocHandler <Event>(Handle)); listener.Start(originStreamName); }
public Task <WriteResult> Append(IEnumerable <IDomainEvent> events, Maybe <long> expectedVersion = default) { return(_store.AppendToStreamAsync( Id, expectedVersion.OrElse(ExpectedVersion.NoStream), events.Select(e => _serializer.Serialize(e, Guid.NewGuid(), _metadataContext.GetMetadata())))); }
public void EventProcessingLoop_PullsEventFromConsumer_And_SendsItToMediator() { //Arrange UserSubscribed subscription = fixture.Create <UserSubscribed>(); string jsonSubscription = eventSerializer.Serialize(subscription); consumer.Consume(Arg.Any <CancellationToken>()).Returns( new ConsumeResult <Ignore, string>() { Message = new Message <Ignore, string>() { Value = jsonSubscription } }); consumer.When(c => c.Consume(Arg.Any <CancellationToken>())).Do( c => { tokenSource.Cancel(); } ); //Act loop.Run().Wait(); //Assert mediator.Received(1).Send( Arg.Is <object>( o => o is ProcessEventCommand <UserSubscribed> ) ); }
void Publish(string stream, object message, Type type, RabbitMqProduceOptions?options) { if (_channel == null) { throw new InvalidOperationException("Producer hasn't been initialized, call Initialize"); } var payload = _serializer.Serialize(message); var eventType = TypeMap.GetTypeNameByType(type); var prop = _channel.CreateBasicProperties(); prop.ContentType = _serializer.ContentType; prop.DeliveryMode = options?.DeliveryMode ?? RabbitMqProduceOptions.DefaultDeliveryMode; prop.Type = eventType; if (options != null) { prop.Expiration = options.Expiration; prop.Headers = options.Headers; prop.Persistent = options.Persisted; prop.Priority = options.Priority; prop.AppId = options.AppId; prop.CorrelationId = options.CorrelationId; prop.MessageId = options.MessageId; prop.ReplyTo = options.ReplyTo; } _channel.BasicPublish(stream, options?.RoutingKey ?? "", true, prop, payload); }
public void Handle(DomainEvent domainEvent) { var serializedBody = _eventSerializer.Serialize(domainEvent); var storedEvent = new StoredEvent(domainEvent.GetType().ToString(), domainEvent.OcurrendOn, serializedBody); _storedEventRepository.Add(storedEvent); }
public Entities.Event Create(string streamId, IEventContext <IEvent> context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.Payload == null) { throw new ArgumentNullException($"{nameof(context)}.{nameof(context.Payload)}"); } var @event = context.Payload; var type = @event.GetType(); return(new Entities.Event { StreamId = streamId, CorrelationId = context.CorrelationId, CausationId = context.CausationId, Data = _eventSerializer.Serialize(@event), Id = @event.Id, Name = type.Name, Type = type.FullName, Timestamp = @event.Timestamp, Actor = context.Actor, }); }
PubsubMessage CreateMessage(object message, Type type) { return(new() { Data = ByteString.CopyFrom(_serializer.Serialize(message)), Attributes = { { "contentType", _serializer.ContentType }, { "eventType", TypeMap.GetTypeNameByType(type) } }
public void SendEvent(IEvent @event) { Guard.DebugAssertArgumentNotNull(@event, nameof(@event)); var address = (@event as IEventWithAddress)?.Address ?? string.Empty; var messageBytes = _eventSerializer.Serialize(@event); _channel.BasicPublish(_exchangeName, address, false, null, messageBytes); _log.Verbose("{ExchangeName}<<<{Event}", _exchangeName, @event); }
public static async Task Publish( this EventStoreClient eventStore, string streamName, IDomainEvent domainEvent, IEventSerializer eventSerializer ) { await eventStore.AppendToStreamAsync(streamName, StreamState.Any, new[] { eventSerializer.Serialize(domainEvent) }); }
IEnumerable <EventData> Serialize(IEnumerable <Event> events, IEventSerializer serializer) { return(events.Select(e => { var event_id = Guid.NewGuid(); var type = e.GetType().Name; var serialized = serializer.Serialize(e); return new EventData(event_id, type, false, serialized.Data, serialized.Metadata); })); }
private EventEntity ToEventEntity(IDomainEvent e) { var eType = e.GetType().Name; var eData = _serializer.Serialize(e); var entity = new EventEntity( e.EventId, e.TimeStamp, e.AggregateId, eType, eData ); return(entity); }
public void AddEvents(IEnumerable <IEvent> events) { foreach (var eachEvent in events) { _session.Save(new StoredEvent { Body = _serializer.Serialize(eachEvent), UtcCreationTime = eachEvent.UtcCreationTime }); } }
private EventStream ConvertTo(DomainEventStream eventStream) { return(new EventStream { CommandId = eventStream.CommandId, AggregateRootId = eventStream.AggregateRootId, AggregateRootTypeName = eventStream.AggregateRootTypeName, Version = eventStream.Version, CreatedOn = eventStream.Timestamp, Events = _jsonSerializer.Serialize(_eventSerializer.Serialize(eventStream.Events)) }); }
void Publish(object message, Type type) { var payload = _serializer.Serialize(message); var eventType = TypeMap.GetTypeNameByType(type); var prop = _channel.CreateBasicProperties(); prop.ContentType = _serializer.ContentType; prop.DeliveryMode = 2; prop.Type = eventType; _channel.BasicPublish(_exchange, eventType, true, prop, payload); }
public void Setup() { if (Complexity == "Simple") { _ev = TestData.SimpleEventInstance(); } else { _ev = TestData.ComplexEventInstance(); } // BTDB Setup _eventSerializer = new EventSerializer(); _eventDeserializer = new EventDeserializer(); bool hasMedataData; var meta = _eventSerializer.Serialize(out hasMedataData, _ev).ToAsyncSafe(); _eventSerializer.ProcessMetadataLog(meta); _eventDeserializer.ProcessMetadataLog(meta); _btdbSerializedData = _eventSerializer.Serialize(out hasMedataData, _ev).ToAsyncSafe(); BtdbByteSize = _btdbSerializedData.Length; object obj; _eventDeserializer.Deserialize(out obj, _btdbSerializedData); obj.Should().BeEquivalentTo(_ev); // ProtoBuf Setup Serializer = ModelFactory.CreateModel(); _eventType = typeof(Event); _memStream = new MemoryStream(); Serializer.Serialize(_memStream, _ev); ProtoBufByteSize = (int)_memStream.Length; _memStream.Position = 0; Serializer.Deserialize(_memStream, null, _eventType).Should().BeEquivalentTo(_ev); BtdbSerialization(); BtdbDeserialization(); ProtoBufSerialization(); ProtoBufDeserialization(); }
EventData CreateMessage(object message, Type type) { var msg = Ensure.NotNull(message, nameof(message)); var typeName = TypeMap.GetTypeNameByType(type); return(new EventData( Uuid.NewUuid(), typeName, _serializer.Serialize(msg), null, _serializer.ContentType )); }
private EventStreamMessage CreateEventMessage(DomainEventStreamMessage eventStream) { var message = new EventStreamMessage(); message.CommandId = eventStream.CommandId; message.AggregateRootTypeCode = eventStream.AggregateRootTypeCode; message.AggregateRootId = eventStream.AggregateRootId; message.Timestamp = eventStream.Timestamp; message.Version = eventStream.Version; message.Events = _eventSerializer.Serialize(eventStream.Events); message.Items = eventStream.Items; return(message); }
public KafkaEventPublisherTests() { fixture = new Fixture(); producer = Substitute.For <IProducer <string, string> >(); kafkaGatewayFactory = Substitute.For <IKafkaGatewayFactory>(); kafkaGatewayFactory.CreateProducer().Returns(producer); eventSerializer = Substitute.For <IEventSerializer>(); eventSerializer.Serialize <Event>(Arg.Any <Event>()).Returns("We are the knight who say Ni"); eventPublisher = new KafkaEventPublisher(kafkaGatewayFactory, eventSerializer); }
public static StoredDomainEvent ToStoredDomainEvent( IDomainEvent domainEvent, IEventSerializer serializer) { return(new StoredDomainEvent() { EventId = domainEvent.Id, EventBody = serializer.Serialize(domainEvent), EventSequence = domainEvent.Sequence, AggregateRootId = domainEvent.AggregateRootId, AggregateRootTypeName = domainEvent.AggregateRootTypeName, CommandId = domainEvent.CommandId, OccurredOn = domainEvent.Timestamp }); }
private Message CreateMessage(string eventName, IEventNotification <IEvent> context) { var @event = context.Payload; var body = Encoding.UTF8.GetBytes(_eventSerializer.Serialize(context.Payload)); return(new Message { MessageId = @event.Id, Type = eventName, CorrelationId = context.CorrelationId, CausationId = context.CausationId, UserId = context.UserId, Body = body, }); }
public static Message FromDomainEvent <TE>(TE @event, IEventSerializer serializer) where TE : IDomainEvent { if (null == @event) { throw new ArgumentNullException(nameof(@event)); } if (null == serializer) { throw new ArgumentNullException(nameof(serializer)); } var type = @event.GetType().FullName; return(new Message(Guid.NewGuid(), DateTime.UtcNow, type, serializer.Serialize(@event))); }
public static StoredEvent BuildFromDomainEvent <TE>(TE @event, IEventSerializer serializer) where TE : Event { if (null == @event) { throw new ArgumentNullException(nameof(@event)); } if (null == serializer) { throw new ArgumentNullException(nameof(serializer)); } var type = @event.GetType().FullName; return(new StoredEvent(@event, serializer.Serialize(@event))); }
private EventStreamMessage CreateEventMessage(DomainEventStreamMessage eventStream) { var message = new EventStreamMessage { Id = eventStream.Id, CommandId = eventStream.CommandId, AggregateRootTypeName = eventStream.AggregateRootTypeName, AggregateRootId = eventStream.AggregateRootId, Timestamp = eventStream.Timestamp, Version = eventStream.Version, Events = _eventSerializer.Serialize(eventStream.Events), Items = eventStream.Items }; return(message); }
public async Task Handle(Event @event, long aggregateVersion) { if (@event == null) { throw new EventNullException(nameof(@event)); } var serializedBody = _eventSerializer.Serialize(@event); var eventStore = new EventStore(@event.AggregateId, aggregateVersion, $"{aggregateVersion}@{@event.AggregateId}", @event.GetType().AssemblyQualifiedName, @event.OcurrendOn, serializedBody); await _eventStoreRepository.AppendAsync(eventStore); }
IEnumerable<EventData> Serialize(IEnumerable<Event> events, IEventSerializer serializer) { return events.Select(e => { var event_id = Guid.NewGuid(); var type = e.GetType().Name; var serialized = serializer.Serialize(e); return new EventData(event_id, type, false, serialized.Data, serialized.Metadata); }); }