public BoundedContextListener(
BoundedContextListenerConfiguration configuration,
IEventConverter eventConverter,
IUncommittedEventStreamCoordinator uncommittedEventStreamCoordinator,
ILogger logger,
IApplicationResourceIdentifierConverter applicationResourceIdentifierConverter,
IImplementationsOf <IEvent> eventTypes,
IEventStore eventStore,
IEventEnvelopes eventEnvelopes,
IEventSequenceNumbers eventSequenceNumbers,
IEventSourceVersions eventSourceVersions,
ICommittedEventStreamBridge committedEventStreamBridge,
IConsumer consumer)
{
_eventConverter = eventConverter;
_uncommittedEventStreamCoordinator = uncommittedEventStreamCoordinator;
_logger = logger;
_applicationResourceIdentifierConverter = applicationResourceIdentifierConverter;
_eventTypes = eventTypes;
_eventSequenceNumbers = eventSequenceNumbers;
_eventStore = eventStore;
_eventEnvelopes = eventEnvelopes;
_eventSourceVersions = eventSourceVersions;
_committedEventStreamBridge = committedEventStreamBridge;
_consumer = consumer;
_serializer = new JsonSerializer();
_configuration = configuration;
}
public ReadModule(IImplementationsOf <IReadModel> readModels, ITypeFinder typeFinder)
{
_readModels = readModels;
var customClassMapTypes = typeFinder.FindMultiple(typeof(IBsonClassMapForReadModel <>));
var readModelHasCustomClassMap = GetHasCustomClassMapDictionary(customClassMapTypes.ToList());
RegisterBsonClassMaps(readModelHasCustomClassMap);
}
public Bootstrapping(
ILogger logger,
IImplementationsOf <ICanHandleGitHubWebhooks> handlers,
IWebhookCoordinator coordinator
)
{
_logger = logger;
_handlers = handlers;
_coordinator = coordinator;
}
/// <summary>
/// Instantiates an instance of <see cref="Bootstrapping" />
/// </summary>
/// <param name="logger">A looger</param>
/// <param name="handlers">A collection of implementations that can handle github webhook requests</param>
/// <param name="registry">A registry of handler methods for associating requests with handlers</param>
public Bootstrapping(
ILogger logger,
IImplementationsOf <ICanHandleGitHubWebhooks> handlers,
IWebhookHandlerRegistry registry
)
{
_logger = logger;
_handlers = handlers;
_registry = registry;
}
void PopulateProcessMethodsFrom(IImplementationsOf <IEventProcessor> eventProcessors)
{
eventProcessors.ForEach(eventProcessorType =>
{
var methods = eventProcessorType.GetMethods(BindingFlags.Instance | BindingFlags.Public).Where(method => {
var parameters = method.GetParameters();
return(method.Name == ProcessMethodName &&
parameters.Length == 1 &&
typeof(IEvent).GetTypeInfo().IsAssignableFrom(parameters[0].ParameterType.GetTypeInfo()));
});
methods.ForEach(RegisterProcessMethod);
});
}
/// <summary>
/// Initializes a new instance of <see cref="ProcessMethodEventProcessors"/>
/// </summary>
/// <param name="artifactTypeMap"><see cref="IArtifactTypeMap"/> for identifying <see cref="IEvent">events</see> </param>
/// <param name="objectFactory"><see cref="IObjectFactory"/> for going between <see cref="PropertyBag"/> and instances of types</param>
/// <param name="processors"><see cref="IImplementationsOf{ICanProcessEvents}"/> for discovering implementations of <see cref="ICanProcessEvents"/></param>
/// <param name="container"><see cref="IContainer"/> for the implementation <see cref="ProcessMethodEventProcessor"/> when acquiring instances of implementations of <see cref="ICanProcessEvents"/></param>
/// <param name="systemClock"><see cref="ISystemClock"/> for timing <see cref="IEventProcessors"/></param>
/// <param name="logger"><see cref="ILogger"/> for logging</param>
public ProcessMethodEventProcessors(
IArtifactTypeMap artifactTypeMap,
IObjectFactory objectFactory,
IImplementationsOf <ICanProcessEvents> processors,
IContainer container,
ISystemClock systemClock,
ILogger logger)
{
_artifactTypeMap = artifactTypeMap;
_processors = processors;
_container = container;
_systemClock = systemClock;
_logger = logger;
_objectFactory = objectFactory;
}
/// <summary>
/// Initializes a new instance of <see cref="EventProcessors"/>
/// </summary>
/// <param name="eventProcessors"><see cref="IImplementationsOf{IEventProcessor}">Implementations of event processors - types</see></param>
/// <param name="container"><see cref="IContainer"/></param>
public EventProcessors(IImplementationsOf <IEventProcessor> eventProcessors, IContainer container)
{
PopulateProcessMethodsFrom(eventProcessors);
_container = container;
}
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");
}
};
}
public BypassControllersManager(IImplementationsOf <ICanBypassSecurity> securityBypassers, IContainer container)
{
_securityBypassers = securityBypassers;
_container = container;
}
/// <summary>
/// Initializes a new instance of the <see cref="EventHandlersProvider"/> class.
/// </summary>
/// <param name="handlers"><see cref="IImplementationsOf{T}"/> of type <see cref="ICanHandleEvents"/>.</param>
/// <param name="logger">The <see cref="ILogger"/> to use for logging.</param>
public EventHandlersProvider(IImplementationsOf <ICanHandleEvents> handlers, ILogger logger)
{
_handlers = handlers;
_logger = logger;
}