public object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
var versionAsDouble = bsonReader.ReadDouble();
var version = EventSourceVersion.FromCombined(versionAsDouble);
return(version);
}
/// <inheritdoc/>
public EventSourceVersion GetVersionFor(IApplicationResourceIdentifier eventSource, EventSourceId eventSourceId)
{
var partitionKeyFilter = GetPartitionKeyFilterFor(eventSource, eventSourceId);
var query = new TableQuery <DynamicTableEntity>().Select(new[] { "Version" }).Where(partitionKeyFilter);
var events = new List <DynamicTableEntity>();
TableContinuationToken continuationToken = null;
do
{
_table.ExecuteQuerySegmentedAsync(query, continuationToken).ContinueWith(e =>
{
events.AddRange(e.Result.Results);
continuationToken = e.Result.ContinuationToken;
}).Wait();
} while (continuationToken != null);
var result = events.OrderByDescending(e => long.Parse(e.RowKey)).FirstOrDefault();
if (result == null)
{
return(EventSourceVersion.Zero);
}
var value = result.Properties["Version"].DoubleValue.Value;
var version = EventSourceVersion.FromCombined(value);
return(version);
}
public void FastForward(EventSourceVersion lastVersion)
{
ThrowIfStateful();
ThrowIfNotInitialVersion();
Version = lastVersion.NextCommit();
}
public EventSourceVersion GetLastCommittedVersion(EventSource eventSource, Guid eventSourceId)
{
var eventSourceParam = new OracleParameter(EventParameters.EVENTSOURCE, OracleDbType.NVarchar2, 512);
eventSourceParam.Value = eventSource.GetType().AssemblyQualifiedName;
var eventSourceIdParam = new OracleParameter(EventParameters.EVENTSOURCEID, OracleDbType.Raw, 16);
eventSourceIdParam.Value = eventSourceId.ToByteArray();
var version = EventSourceVersion.Zero;
try
{
OpenConnection();
using (var command = _connection.CreateCommand())
{
command.CommandText = LAST_VERSION_STATEMENT;
command.Parameters.Add(eventSourceIdParam);
command.Parameters.Add(eventSourceParam);
command.BindByName = true;
var reader = command.ExecuteReader(CommandBehavior.SingleResult);
if (reader.Read())
{
version = EventSourceVersion.FromCombined(Convert.ToDouble(reader.GetDecimal(0)));
}
}
}
finally
{
EnsureConnectionClosed(_connection);
}
return(version);
}
/// <inheritdoc/>
public void FastForward(EventSourceVersion lastVersion)
{
ThrowIfStateful();
ThrowIfNotInitialVersion();
Version = lastVersion == null ? EventSourceVersion.Initial : lastVersion.NextCommit();
}
public object NullSafeGet(IDataReader rs, string[] names, object owner)
{
var versionAsDouble = (double)NHibernateUtil.Double.NullSafeGet(rs, names[0]);
var version = EventSourceVersion.FromCombined(versionAsDouble);
return(version);
}
/// <inheritdoc/>
public IEnumerable <EventAndEnvelope> GetFor(IApplicationResourceIdentifier eventSource, EventSourceId eventSourceId)
{
var eventSourceIdentifier = _applicationResourceIdentifierConverter.AsString(eventSource);
var eventPath = GetPathFor(eventSourceIdentifier, eventSourceId);
var files = _files.GetFilesIn(eventPath).OrderBy(f => f);
var eventFiles = files.Where(f => f.EndsWith(".event")).ToArray();
var envelopeFiles = files.Where(f => f.EndsWith(".envelope")).ToArray();
if (eventFiles.Length != envelopeFiles.Length)
{
throw new Exception($"There is a problem with event files for {eventSourceIdentifier} with Id {eventSourceId}");
}
var events = new List <EventAndEnvelope>();
for (var eventIndex = 0; eventIndex < eventFiles.Length; eventIndex++)
{
var envelopeFile = envelopeFiles[eventIndex];
var eventFile = eventFiles[eventIndex];
var envelopeAsJson = _files.ReadString(Path.GetDirectoryName(envelopeFile), Path.GetFileName(envelopeFile));
var eventAsJson = _files.ReadString(Path.GetDirectoryName(eventFile), Path.GetFileName(eventFile));
var envelopeValues = _serializer.GetKeyValuesFromJson(envelopeAsJson);
var _correllationId = Guid.Parse((string)envelopeValues["CorrelationId"]);
var _eventId = Guid.Parse((string)envelopeValues["EventId"]);
var _sequenceNumber = (long)envelopeValues["SequenceNumber"];
var _sequenceNumberForEventType = (long)envelopeValues["SequenceNumberForEventType"];
var _generation = (long)envelopeValues["Generation"];
var _event = _applicationResourceIdentifierConverter.FromString((string)envelopeValues["Event"]);
var _eventSourceId = Guid.Parse((string)envelopeValues["EventSourceId"]);
var _eventSource = _applicationResourceIdentifierConverter.FromString((string)envelopeValues["EventSource"]);
var _eventSourceVersion = EventSourceVersion.FromCombined(double.Parse(envelopeValues["Version"].ToString()));
var _causedBy = (string)envelopeValues["CausedBy"];
var _occurred = (DateTime)envelopeValues["Occurred"];
var envelope = new EventEnvelope(
_correllationId,
_eventId,
_sequenceNumber,
_sequenceNumberForEventType,
(int)_generation,
_event,
_eventSourceId,
_eventSource,
_eventSourceVersion,
_causedBy,
_occurred
);
var eventType = _applicationResourceResolver.Resolve(envelope.Event);
var @event = Activator.CreateInstance(eventType, eventSourceId) as IEvent;
_serializer.FromJson(@event, eventAsJson);
events.Add(new EventAndEnvelope(envelope, @event));
}
return(events);
}
/// <summary>
/// Convert from <see cref="EventSourceVersion"/> to <see cref="grpc.EventSourceVersion"/>.
/// </summary>
/// <param name="version"><see cref="EventSourceVersion"/> to convert from.</param>
/// <returns>Converted <see cref="grpc.EventSourceVersion"/>.</returns>
public static grpc.EventSourceVersion ToProtobuf(this EventSourceVersion version)
{
return(new grpc.EventSourceVersion
{
Commit = version.Commit,
Sequence = version.Sequence
});
}
/// <summary>
/// Convert from <see cref="EventSourceVersion"/> to <see cref="Runtime.Grpc.Interaction.EventSourceVersion"/>
/// </summary>
/// <param name="version"><see cref="EventSourceVersion"/> to convert from</param>
/// <returns>Converted <see cref="Runtime.Grpc.Interaction.EventSourceVersion"/></returns>
public static Runtime.Grpc.Interaction.EventSourceVersion ToProtobuf(this EventSourceVersion version)
{
return(new Runtime.Grpc.Interaction.EventSourceVersion
{
Commit = version.Commit,
Sequence = version.Sequence
});
}
Task Receive(Message message, CancellationToken token)
{
var dynamicEventsAndEnvelopes = new List <dynamic>();
var json = System.Text.Encoding.UTF8.GetString(message.Body);
_serializer.FromJson(dynamicEventsAndEnvelopes, json);
var eventsAndEnvelopes = new List <EventAndEnvelope>();
foreach (var dynamicEventAndEnvelope in dynamicEventsAndEnvelopes)
{
var env = dynamicEventAndEnvelope.Envelope;
var correlationId = (TransactionCorrelationId)Guid.Parse(env.CorrelationId.ToString());
var eventId = (EventId)Guid.Parse(env.EventId.ToString());
var sequenceNumber = (EventSequenceNumber)long.Parse(env.SequenceNumber.ToString());
var sequenceNumberForEventType = (EventSequenceNumber)long.Parse(env.SequenceNumberForEventType.ToString());
var generation = (EventGeneration)long.Parse(env.Generation.ToString());
var @event = _applicationResourceIdentifierConverter.FromString(env.Event.ToString());
var eventSourceId = (EventSourceId)Guid.Parse(env.EventSourceId.ToString());
var eventSource = _applicationResourceIdentifierConverter.FromString(env.EventSource.ToString());
var version = (EventSourceVersion)EventSourceVersion.FromCombined(double.Parse(env.Version.ToString()));
var causedBy = (CausedBy)env.CausedBy.ToString();
var occurred = DateTimeOffset.Parse(env.Occurred.ToString());
var envelope = new EventEnvelope(
correlationId,
eventId,
sequenceNumber,
sequenceNumberForEventType,
generation,
@event,
eventSourceId,
eventSource,
version,
causedBy,
occurred
);
var eventType = _applicationResourceResolver.Resolve(@event);
var eventInstance = Activator.CreateInstance(eventType, new object[] { eventSourceId }) as IEvent;
var e = dynamicEventAndEnvelope.Event.ToString();
_serializer.FromJson(eventInstance, e);
eventsAndEnvelopes.Add(new EventAndEnvelope(envelope, eventInstance));
}
var stream = new CommittedEventStream(eventsAndEnvelopes.First().Envelope.EventSourceId, eventsAndEnvelopes);
Received(stream);
_queueClient.CompleteAsync(message.SystemProperties.LockToken);
return(Task.CompletedTask);
}
/// <inheritdoc/>
public EventSourceVersion GetVersionFor(IApplicationResourceIdentifier eventSource, EventSourceId eventSourceId)
{
var filter = Builders <BsonDocument> .Filter.Eq("EventSourceId", eventSourceId);
var result = _collection.Find(filter).SortByDescending(bson => bson["Version"]).Single();
var value = result["Version"].AsDouble;
var version = EventSourceVersion.FromCombined(value);
return(version);
}
/// <inheritdoc/>
public EventSourceVersion GetLastCommittedVersionFor(IEventSource eventSource)
{
var version = EventSourceVersion.Zero;
_client
.ExecuteStoredProcedureAsync <double>(_getLastCommittedVersionStoredProcedure.SelfLink, eventSource.EventSourceId)
.ContinueWith(t => version = EventSourceVersion.FromCombined(t.Result))
.Wait();
return(version);
}
/// <summary>
/// Set the current version for an <see cref="IEventSource"/> if the version is higher than
/// what is already on the subscription. If the <see cref="IEventSource"/> is not there,
/// it will automatically add it
/// </summary>
/// <param name="eventSource"><see cref="IEventSource"/> by name to set version for</param>
/// <param name="version"><see cref="EventSourceVersion"/> to set</param>
public void SetEventSourceVersion(string eventSource, EventSourceVersion version)
{
if (!_versions.ContainsKey(eventSource))
{
_versions[eventSource] = version;
return;
}
var currentVersion = _versions[eventSource];
if (currentVersion.CompareTo(version) < 0)
_versions[eventSource] = version;
}
void PopulateGenericEventParametersFromDto(IEvent @event, EventDto eventDto)
{
@event.Id = eventDto.Id;
@event.Name = eventDto.Name;
@event.Occured = eventDto.Occurred;
@event.Origin = eventDto.Origin;
@event.EventSource = eventDto.EventSource;
@event.EventSourceId = eventDto.EventSourceId;
@event.CommandContext = eventDto.CommandContext;
@event.CausedBy = eventDto.CausedBy;
@event.Version = EventSourceVersion.FromCombined(eventDto.Version);
}
public EventSourceVersion GetLastCommittedVersion(EventSource eventSource, Guid eventSourceId)
{
var query = Query.EQ("EventSourceId", eventSourceId);
var sort = SortBy.Descending(Version);
var @event = _collection.FindAs <BsonDocument>(query).SetSortOrder(sort).FirstOrDefault();
if (@event == null)
{
return(EventSourceVersion.Zero);
}
return(EventSourceVersion.FromCombined(@event[Version].AsDouble));
}
/// <inheritdoc/>
public EventSourceVersion GetFor(IApplicationResourceIdentifier eventSource, EventSourceId eventSourceId)
{
var fileName = GetFileNameFor(eventSource, eventSourceId);
var version = EventSourceVersion.Zero;
if (_files.Exists(_path, fileName))
{
var versionAsString = _files.ReadString(_path, fileName);
version = EventSourceVersion.FromCombined(double.Parse(versionAsString));
}
else
{
version = _eventStore.GetVersionFor(eventSource, eventSourceId);
}
return(version);
}
/// <inheritdoc/>
public EventSourceVersion GetVersionFor(IApplicationResourceIdentifier eventSource, EventSourceId eventSourceId)
{
var eventSourceIdentifier = _applicationResourceIdentifierConverter.AsString(eventSource);
var eventPath = GetPathFor(eventSourceIdentifier, eventSourceId);
var first = _files.GetFilesIn(eventPath, "*.event").OrderByDescending(f => f).FirstOrDefault();
if (first == null)
{
return(EventSourceVersion.Zero);
}
var versionAsString = Path.GetFileNameWithoutExtension(first);
var versionAsDouble = double.Parse(versionAsString, CultureInfo.InvariantCulture);
return(EventSourceVersion.FromCombined(versionAsDouble));
}
/// <inheritdoc/>
public EventSourceVersion GetFor(IApplicationResourceIdentifier eventSource, EventSourceId eventSourceId)
{
var key = GetKeyFor(eventSource, eventSourceId);
var version = EventSourceVersion.Zero;
var value = _database.StringGet(key);
if (value.IsNull)
{
version = _eventStore.GetVersionFor(eventSource, eventSourceId);
SetFor(eventSource, eventSourceId, version);
}
else
{
version = EventSourceVersion.FromCombined(double.Parse(value.ToString()));
}
return(version);
}
/// <summary>
/// Convert from <see cref="EventSourceVersion"/> to <see cref="Dolittle.Runtime.Events.EventSourceVersion"/>
/// </summary>
/// <param name="protobuf"><see cref="EventSourceVersion"/> to convert from</param>
/// <returns>Converted <see cref="Dolittle.Runtime.Events.EventSourceVersion"/></returns>
public static Dolittle.Runtime.Events.EventSourceVersion ToEventSourceVersion(this EventSourceVersion protobuf)
{
return(new Dolittle.Runtime.Events.EventSourceVersion(protobuf.Commit, protobuf.Sequence));
}
public void FastForward(EventSourceVersion version)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Initializes a new instance of <see cref="CommittedEventStreamCoordinator"/>
/// </summary>
/// <param name="serializer"><see cref="ISerializer"/> to use for deserializing <see cref="IEvent">events</see></param>
/// <param name="applicationResourceIdentifierConverter"><see cref="IApplicationResourceIdentifierConverter"/> used for converting resource identifiers</param>
/// <param name="applicationResourceResolver"><see cref="IApplicationResourceResolver"/> used for resolving types from <see cref="IApplicationResourceIdentifier"/></param>
/// <param name="connectionStringProvider"><see cref="ICanProvideConnectionStringToReceiver">Provider</see> of connection string</param>
public CommittedEventStreamReceiver(
ISerializer serializer,
IApplicationResourceIdentifierConverter applicationResourceIdentifierConverter,
IApplicationResourceResolver applicationResourceResolver,
ICanProvideConnectionStringToReceiver connectionStringProvider)
{
_serializer = serializer;
var factory = new ConnectionFactory();
factory.Uri = connectionStringProvider();
var connection = factory.CreateConnection();
var exchangeName = "Events";
var routingKey = "RoutingKey";
var queueName = "Events";
var model = connection.CreateModel();
model.ExchangeDeclare(exchangeName, ExchangeType.Direct);
model.QueueDeclare(queueName, false, false, false, null);
model.QueueBind(queueName, exchangeName, routingKey, null);
var consumer = new EventingBasicConsumer(model);
consumer.Received += (ch, ea) =>
{
try
{
var dynamicEventsAndEnvelopes = new List <dynamic>();
var json = System.Text.Encoding.UTF8.GetString(ea.Body);
_serializer.FromJson(dynamicEventsAndEnvelopes, json);
var eventsAndEnvelopes = new List <EventAndEnvelope>();
foreach (var dynamicEventAndEnvelope in dynamicEventsAndEnvelopes)
{
var env = dynamicEventAndEnvelope.Envelope;
var correlationId = (TransactionCorrelationId)Guid.Parse(env.CorrelationId.ToString());
var eventId = (EventId)Guid.Parse(env.EventId.ToString());
var sequenceNumber = (EventSequenceNumber)long.Parse(env.SequenceNumber.ToString());
var sequenceNumberForEventType = (EventSequenceNumber)long.Parse(env.SequenceNumberForEventType.ToString());
var generation = (EventGeneration)long.Parse(env.Generation.ToString());
var @event = applicationResourceIdentifierConverter.FromString(env.Event.ToString());
var eventSourceId = (EventSourceId)Guid.Parse(env.EventSourceId.ToString());
var eventSource = applicationResourceIdentifierConverter.FromString(env.EventSource.ToString());
var version = (EventSourceVersion)EventSourceVersion.FromCombined(double.Parse(env.Version.ToString()));
var causedBy = (CausedBy)env.CausedBy.ToString();
var occurred = DateTimeOffset.Parse(env.Occurred.ToString());
var envelope = new EventEnvelope(
correlationId,
eventId,
sequenceNumber,
sequenceNumberForEventType,
generation,
@event,
eventSourceId,
eventSource,
version,
causedBy,
occurred
);
var eventType = applicationResourceResolver.Resolve(@event);
var eventInstance = Activator.CreateInstance(eventType, new object[] { eventSourceId }) as IEvent;
var e = dynamicEventAndEnvelope.Event.ToString();
_serializer.FromJson(eventInstance, e);
eventsAndEnvelopes.Add(new EventAndEnvelope(envelope, eventInstance));
}
var stream = new CommittedEventStream(eventsAndEnvelopes.First().Envelope.EventSourceId, eventsAndEnvelopes);
Received(stream);
model.BasicAck(ea.DeliveryTag, false);
}
catch
{
}
finally
{
}
};
Task.Run(() => model.BasicConsume(queueName, false, consumer));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
return(EventSourceVersion.FromCombined((double)reader.Value));
}
public static EventSourceVersion Next(this EventSourceVersion version)
{
return(new EventSourceVersion(version.Commit + 1, 0));
}
void Received(Topic topic, string eventAsJson)
{
try
{
_logger.Trace($"Message received 'eventAsJson'");
dynamic raw = JsonConvert.DeserializeObject(eventAsJson);
foreach (var rawContentAndEnvelope in raw)
{
var eventSourceId = (EventSourceId)Guid.Parse(rawContentAndEnvelope.Envelope.EventSourceId.ToString());
var eventIdentifier = _applicationResourceIdentifierConverter.FromString(rawContentAndEnvelope.Envelope.Event.ToString());
var version = EventSourceVersion.FromCombined((double)rawContentAndEnvelope.Envelope.Version);
var correlationId = (TransactionCorrelationId)Guid.Parse(rawContentAndEnvelope.Envelope.CorrelationId.ToString());
var eventSource = new ExternalSource(eventSourceId);
CorrelationId = correlationId;
_logger.Trace($"Received event of with resource name '{eventIdentifier.Resource.Name}' from '{eventSourceId}' with version '{version}' in correlation '{correlationId}'");
var eventType = _eventTypes.SingleOrDefault(et => et.Name == eventIdentifier.Resource.Name);
if (eventType != null)
{
_logger.Trace("Matching Event Type : " + eventType.AssemblyQualifiedName);
var @event = GetEventFrom(rawContentAndEnvelope, eventSourceId, eventType);
var uncommittedEventStream = new UncommittedEventStream(eventSource);
uncommittedEventStream.Append(@event, version);
_logger.Information($"Committing uncommitted event stream with correlationId '{correlationId}'");
var envelopes = _eventEnvelopes.CreateFrom(eventSource, uncommittedEventStream.EventsAndVersion);
var envelopesAsArray = envelopes.ToArray();
var eventsAsArray = uncommittedEventStream.ToArray();
_logger.Trace("Create an array of events and envelopes");
var eventsAndEnvelopes = new List <EventAndEnvelope>();
for (var eventIndex = 0; eventIndex < eventsAsArray.Length; eventIndex++)
{
var envelope = envelopesAsArray[eventIndex];
var currentEvent = eventsAsArray[eventIndex];
eventsAndEnvelopes.Add(new EventAndEnvelope(
envelope
.WithTransactionCorrelationId(correlationId)
.WithSequenceNumber(_eventSequenceNumbers.Next())
.WithSequenceNumberForEventType(_eventSequenceNumbers.NextForType(envelope.Event)),
currentEvent
));
}
_logger.Trace("Committing events to event store");
_eventStore.Commit(eventsAndEnvelopes);
_logger.Trace($"Set event source versions for the event source '{envelopesAsArray[0].EventSource}' with id '{envelopesAsArray[0].EventSourceId}'");
_eventSourceVersions.SetFor(envelopesAsArray[0].EventSource, envelopesAsArray[0].EventSourceId, envelopesAsArray[envelopesAsArray.Length - 1].Version);
_logger.Trace("Create a committed event stream");
var committedEventStream = new CommittedEventStream(uncommittedEventStream.EventSourceId, eventsAndEnvelopes);
_committedEventStreamBridge.Send(committedEventStream);
CorrelationId = Guid.Empty;
}
}
}
catch (Exception ex)
{
_logger.Error(ex, "Error during receiving");
}
}
/// <summary>
/// Processes
/// </summary>
/// <param name="committedEventStreamWithContext"></param>
/// <returns></returns>
public Task <CommitSequenceNumber> Process(CommittedEventStreamWithContext committedEventStreamWithContext)
{
try
{
var originatingSequence = committedEventStreamWithContext.EventStream.Sequence;
var context = committedEventStreamWithContext.Context;
var particleStream = committedEventStreamWithContext.EventStream;
EventSourceVersion version = null;
_executionContextManager.CurrentFor(context);
using (var _ = _getEventStore())
{
version = _.GetNextVersionFor(particleStream.Source.Key);
}
var versionedEventSource = new VersionedEventSource(version, new EventSourceKey(particleStream.Source.EventSource, particleStream.Source.Artifact));
var eventEnvelopes = new List <EventEnvelope>();
particleStream.Events.ForEach(_ =>
{
_.Metadata.OriginalContext.CommitInOrigin = particleStream.Sequence;
var envelope = new EventEnvelope(
new EventMetadata(
_.Id,
new VersionedEventSource(version, new EventSourceKey(particleStream.Source.EventSource, particleStream.Source.Artifact)),
_.Metadata.CorrelationId,
_.Metadata.Artifact,
_.Metadata.Occurred,
_.Metadata.OriginalContext
),
_.Event
);
eventEnvelopes.Add(envelope);
version = version.NextSequence();
});
var uncommittedEventStream = new Store.UncommittedEventStream(
particleStream.Id,
particleStream.CorrelationId,
versionedEventSource,
particleStream.Timestamp,
new Store.EventStream(eventEnvelopes)
);
_logger.Information("Commit events to store");
Store.CommittedEventStream committedEventStream = null;
using (var _ = _getEventStore())
{
committedEventStream = _.Commit(uncommittedEventStream);
}
SetOffset(_eventHorizonKey, originatingSequence);
_logger.Information("Process committed events");
_processingHub.Process(committedEventStream);
return(Task.FromResult(committedEventStream.Sequence));
}
catch (Exception ex)
{
_logger.Error(ex, "Couldn't handle incoming commit");
return(Task.FromException <CommitSequenceNumber>(ex));
}
}
/// <inheritdoc/>
public void SetFor(Artifact eventSource, EventSourceId eventSourceId, EventSourceVersion version)
{
}
/// <summary>
/// Initializes a new instance of <see cref="EventAndVersion"/>
/// </summary>
/// <param name="event">The <see cref="IEvent">Event</see></param>
/// <param name="version">The <see cref="EventSourceVersion">version</see> of the <see cref="IEvent"/> on the <see cref="IEventSource"/></param>
public EventAndVersion(IEvent @event, EventSourceVersion version)
{
Event = @event;
Version = version;
}
/// <inheritdoc/>
public void SetFor(IApplicationResourceIdentifier eventSource, EventSourceId eventSourceId, EventSourceVersion version)
{
var fileName = GetFileNameFor(eventSource, eventSourceId);
_files.WriteString(_path, fileName, version.Combine().ToString());
}
/// <summary>
/// Get a value from a <see cref="DynamicTableEntity"/> by giving a property info representing the property to get value for
/// </summary>
/// <param name="entity"><see cref="DynamicTableEntity">Entity</see> to get from</param>
/// <param name="propertyInfo"><see cref="PropertyInfo"/> for the property</param>
/// <returns>Value of the property from the <see cref="DynamicTableEntity">entity</see></returns>
public static object GetValue(DynamicTableEntity entity, PropertyInfo propertyInfo)
{
var valueType = propertyInfo.PropertyType;
var entityProperty = entity.Properties[propertyInfo.Name];
var concept = valueType.IsConcept();
object value = null;
if (concept)
{
valueType = valueType.GetConceptValueType();
}
if (valueType == typeof(EventSourceVersion))
{
value = EventSourceVersion.FromCombined(entityProperty.DoubleValue.Value);
}
if (valueType == typeof(Guid))
{
value = entityProperty.GuidValue.Value;
}
if (valueType == typeof(int))
{
value = entityProperty.Int32Value.Value;
}
if (valueType == typeof(long))
{
value = entityProperty.Int64Value.Value;
}
if (valueType == typeof(string))
{
value = entityProperty.StringValue;
}
if (valueType == typeof(DateTime))
{
value = entityProperty.DateTime.Value;
}
if (valueType == typeof(DateTimeOffset))
{
value = entityProperty.DateTimeOffsetValue.Value;
}
if (valueType == typeof(bool))
{
value = entityProperty.BooleanValue.Value;
}
if (valueType == typeof(double))
{
value = entityProperty.DoubleValue.Value;
}
if (valueType == typeof(float))
{
value = (float)entityProperty.DoubleValue.Value;
}
if (concept)
{
return(ConceptFactory.CreateConceptInstance(propertyInfo.PropertyType, value));
}
return(value);
}
public BoundedContextListener(
KafkaConnectionString connectionString,
ListenerConfiguration configuration,
IEventConverter eventConverter,
IUncommittedEventStreamCoordinator uncommittedEventStreamCoordinator,
ISerializer serializer,
ILogger logger,
IApplicationResourceIdentifierConverter applicationResourceIdentifierConverter,
IImplementationsOf <IEvent> eventTypes,
IEventStore eventStore,
IEventEnvelopes eventEnvelopes,
IEventSequenceNumbers eventSequenceNumbers,
IEventSourceVersions eventSourceVersions,
ICommittedEventStreamBridge committedEventStreamBridge)
{
_serializer = serializer;
_eventConverter = eventConverter;
_uncommittedEventStreamCoordinator = uncommittedEventStreamCoordinator;
_logger = logger;
_applicationResourceIdentifierConverter = applicationResourceIdentifierConverter;
_eventTypes = eventTypes;
_eventSequenceNumbers = eventSequenceNumbers;
_eventStore = eventStore;
_eventEnvelopes = eventEnvelopes;
_eventSourceVersions = eventSourceVersions;
_committedEventStreamBridge = committedEventStreamBridge;
logger.Information($"Listening on topic '{configuration.Topic}' from '{connectionString}'");
var config = new Dictionary <string, object>
{
{ "bootstrap.servers", connectionString },
{ "group.id", "simple-consumer" },
{ "enable.auto.commit", true },
{ "auto.commit.interval.ms", 1000 },
{
"default.topic.config",
new Dictionary <string, object>()
{
{ "auto.offset.reset", "smallest" }
}
}
};
_consumer = new Consumer <Ignore, string>(config, null, new StringDeserializer(Encoding.UTF8));
_consumer.Assign(new [] { new TopicPartition(configuration.Topic, 0) });
_consumer.OnMessage += (_, msg) =>
{
try
{
logger.Trace($"Message received '{msg.Value}'");
var raw = _serializer.FromJson <dynamic[]>(msg.Value);
foreach (var rawContentAndEnvelope in raw)
{
var eventSourceId = (EventSourceId)Guid.Parse(rawContentAndEnvelope.Content.EventSourceId.ToString());
var eventIdentifier = _applicationResourceIdentifierConverter.FromString(rawContentAndEnvelope.Envelope.Event.ToString());
var version = EventSourceVersion.FromCombined((double)rawContentAndEnvelope.Envelope.Version);
var correlationId = (TransactionCorrelationId)Guid.Parse(rawContentAndEnvelope.Envelope.CorrelationId.ToString());
CorrelationId = correlationId;
_logger.Trace($"Received event of with resource name '{eventIdentifier.Resource.Name}' from '{eventSourceId}' with version '{version}' in correlation '{correlationId}'");
var eventType = _eventTypes.SingleOrDefault(et => et.Name == eventIdentifier.Resource.Name);
if (eventType != null)
{
_logger.Trace("Matching Event Type : " + eventType.AssemblyQualifiedName);
var @event = Activator.CreateInstance(eventType, eventSourceId) as IEvent;
_serializer.FromJson(@event, rawContentAndEnvelope.Content.ToString());
var eventSource = new ExternalSource(eventSourceId);
var uncommittedEventStream = new UncommittedEventStream(eventSource);
uncommittedEventStream.Append(@event, version);
_logger.Information($"Committing uncommitted event stream with correlationId '{correlationId}'");
var envelopes = _eventEnvelopes.CreateFrom(eventSource, uncommittedEventStream.EventsAndVersion);
var envelopesAsArray = envelopes.ToArray();
var eventsAsArray = uncommittedEventStream.ToArray();
_logger.Trace("Create an array of events and envelopes");
var eventsAndEnvelopes = new List <EventAndEnvelope>();
for (var eventIndex = 0; eventIndex < eventsAsArray.Length; eventIndex++)
{
var envelope = envelopesAsArray[eventIndex];
var currentEvent = eventsAsArray[eventIndex];
eventsAndEnvelopes.Add(new EventAndEnvelope(
envelope
.WithTransactionCorrelationId(correlationId)
.WithSequenceNumber(_eventSequenceNumbers.Next())
.WithSequenceNumberForEventType(_eventSequenceNumbers.NextForType(envelope.Event)),
currentEvent
));
}
_logger.Trace("Committing events to event store");
_eventStore.Commit(eventsAndEnvelopes);
_logger.Trace($"Set event source versions for the event source '{envelopesAsArray[0].EventSource}' with id '{envelopesAsArray[0].EventSourceId}'");
_eventSourceVersions.SetFor(envelopesAsArray[0].EventSource, envelopesAsArray[0].EventSourceId, envelopesAsArray[envelopesAsArray.Length - 1].Version);
_logger.Trace("Create a committed event stream");
var committedEventStream = new CommittedEventStream(uncommittedEventStream.EventSourceId, eventsAndEnvelopes);
_committedEventStreamBridge.Send(committedEventStream);
CorrelationId = Guid.Empty;
}
}
}
catch (Exception ex)
{
_logger.Error(ex, "Error during receiving");
}
};
}
/// <summary>
/// Initializes a new instance of the <see cref="EventSourceConcurrencyConflict"/> class.
/// </summary>
/// <param name="currentVersion">The current version before commit.</param>
/// <param name="commitVersion">The version of the commit that causes a concurrency conflict.</param>
public EventSourceConcurrencyConflict(EventSourceVersion currentVersion, EventSourceVersion commitVersion)
: base($"Current Version is {currentVersion}, tried to commit {commitVersion}")
{
}
/// <inheritdoc/>
public void SetFor(IApplicationResourceIdentifier eventSource, EventSourceId eventSourceId, EventSourceVersion version)
{
var key = GetKeyFor(eventSource, eventSourceId);
_database.StringSet(key, version.Combine());
}
