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